devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/index-x8s9rwfh.js

@@ -1,2020 +0,0 @@
-import {
-  createD1Database,
-  createKVNamespace,
-  createQueue,
-  createR2Bucket,
-  getEffectiveAccountId,
-  getPrimaryAccount,
-  listD1Databases,
-  listHyperdrives,
-  listKVNamespaces,
-  listQueues,
-  listR2Buckets,
-  listVectorizeIndexes
-} from "./index-h7r11y4a.js";
-
-// src/config/env-vars.ts
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { dirname, resolve } from "pathe";
-var ENV_DESCRIPTOR_FLAG = "__devflareEnvDescriptor";
-function createDescriptor(state) {
-  const descriptor = {
-    [ENV_DESCRIPTOR_FLAG]: true,
-    __state: state,
-    optional() {
-      return createDescriptor({
-        ...state,
-        optional: true
-      });
-    },
-    parse(parser) {
-      return createDescriptor({
-        ...state,
-        parser
-      });
-    },
-    parser(parser) {
-      return this.parse(parser);
-    },
-    default(value) {
-      return createDescriptor({
-        ...state,
-        defaultValue: value,
-        hasDefault: true,
-        optional: false
-      });
-    },
-    dev(value) {
-      return createDescriptor({
-        ...state,
-        devValue: value,
-        hasDevDefault: true
-      });
-    }
-  };
-  return descriptor;
-}
-function createEnvVarDescriptor(name) {
-  return createDescriptor({
-    name,
-    optional: false,
-    hasDefault: false,
-    hasDevDefault: false
-  });
-}
-var env = new Proxy({}, {
-  get(_target, prop) {
-    if (typeof prop !== "string") {
-      return;
-    }
-    return createEnvVarDescriptor(prop);
-  }
-});
-function isEnvVarDescriptor(value) {
-  return Boolean(value && typeof value === "object" && value[ENV_DESCRIPTOR_FLAG] === true);
-}
-function parseEnvValue(rawValue) {
-  const trimmed = rawValue.trim();
-  const quote = trimmed[0];
-  if ((quote === '"' || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
-    const inner = trimmed.slice(1, -1);
-    if (quote !== '"') {
-      return inner;
-    }
-    return inner.replace(/\\n/g, `
-`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-  }
-  return trimmed;
-}
-function parseDevflareEnvFile(contents) {
-  const values = {};
-  for (const line of contents.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const assignment = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trimStart() : trimmed;
-    const equalsIndex = assignment.indexOf("=");
-    if (equalsIndex <= 0) {
-      continue;
-    }
-    const key = assignment.slice(0, equalsIndex).trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-      continue;
-    }
-    values[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
-  }
-  return values;
-}
-function collectAncestorDirectories(startDir) {
-  const directories = [];
-  let current = resolve(startDir);
-  while (true) {
-    directories.push(current);
-    const parent = dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return directories.reverse();
-}
-function getDevflareDotenvPaths(startDir) {
-  return collectAncestorDirectories(startDir).flatMap((directory) => [
-    resolve(directory, ".env.dev"),
-    resolve(directory, ".env")
-  ]);
-}
-async function loadDevflareDotenv(startDir) {
-  const values = {};
-  const files = [];
-  for (const filePath of getDevflareDotenvPaths(startDir)) {
-    if (!existsSync(filePath)) {
-      continue;
-    }
-    Object.assign(values, parseDevflareEnvFile(await readFile(filePath, "utf8")));
-    files.push(filePath);
-  }
-  return { values, files };
-}
-async function loadDevflareDotenvIntoProcess(startDir) {
-  const loaded = await loadDevflareDotenv(startDir);
-  for (const [key, value] of Object.entries(loaded.values)) {
-    if (process.env[key] === undefined) {
-      process.env[key] = value;
-    }
-  }
-  return loaded;
-}
-function formatMissingEnvTree(missing) {
-  const root = {};
-  for (const item of missing) {
-    let current = root;
-    for (const segment of item.path.slice(0, -1)) {
-      const next = current[segment];
-      if (!next || typeof next !== "object") {
-        current[segment] = {};
-      }
-      current = current[segment];
-    }
-    current[item.path[item.path.length - 1] ?? item.name] = item.name;
-  }
-  const lines = [];
-  const writeNode = (node, depth) => {
-    const indent = "\t".repeat(depth);
-    for (const [key, value] of Object.entries(node)) {
-      if (value && typeof value === "object") {
-        lines.push(`${indent}${key}:`);
-        writeNode(value, depth + 1);
-      } else {
-        lines.push(`${indent}${key}: ${String(value)}`);
-      }
-    }
-  };
-  writeNode(root, 1);
-  return lines.join(`
-`);
-}
-
-class EnvVarResolutionError extends Error {
-  missing;
-  mode;
-  code = "ENV_VARS_MISSING";
-  constructor(missing, mode) {
-    super(["These environment variables are missing:", "", formatMissingEnvTree(missing)].join(`
-`));
-    this.missing = missing;
-    this.mode = mode;
-    this.name = "EnvVarResolutionError";
-  }
-}
-
-class EnvVarParseError extends Error {
-  variableName;
-  path;
-  code = "ENV_VAR_PARSE_FAILED";
-  constructor(variableName, path, cause) {
-    super(`Could not parse environment variable ${variableName} for vars.${path.join(".")}.
-` + `Parser error: ${cause instanceof Error ? cause.message : String(cause)}`);
-    this.variableName = variableName;
-    this.path = path;
-    this.name = "EnvVarParseError";
-  }
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || isEnvVarDescriptor(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-var OMIT_VALUE = Symbol("omit optional env var");
-function resolveDescriptorValue(descriptor, sources, path, mode, missing) {
-  const state = descriptor.__state;
-  const rawValue = sources[state.name];
-  if (rawValue !== undefined) {
-    try {
-      return state.parser ? state.parser(rawValue) : rawValue;
-    } catch (error) {
-      throw new EnvVarParseError(state.name, path, error);
-    }
-  }
-  if (mode === "dev" && state.hasDevDefault) {
-    return state.devValue;
-  }
-  if (state.hasDefault) {
-    return state.defaultValue;
-  }
-  if (state.optional) {
-    return OMIT_VALUE;
-  }
-  missing.push({ path, name: state.name });
-  return OMIT_VALUE;
-}
-function resolveVarValue(value, sources, path, mode, missing) {
-  if (isEnvVarDescriptor(value)) {
-    return resolveDescriptorValue(value, sources, path, mode, missing);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item, index) => resolveVarValue(item, sources, [...path, String(index)], mode, missing)).filter((item) => item !== OMIT_VALUE);
-  }
-  if (isPlainObject(value)) {
-    const resolved = {};
-    for (const [key, childValue] of Object.entries(value)) {
-      const child = resolveVarValue(childValue, sources, [...path, key], mode, missing);
-      if (child !== OMIT_VALUE) {
-        resolved[key] = child;
-      }
-    }
-    return resolved;
-  }
-  return value;
-}
-function resolveVarsObject(vars, sources, mode, missing) {
-  if (!vars) {
-    return vars;
-  }
-  const resolved = resolveVarValue(vars, sources, [], mode, missing);
-  return resolved === OMIT_VALUE ? undefined : resolved;
-}
-async function resolveConfigEnvVars(config, options) {
-  const startDir = options.configPath ? dirname(resolve(options.cwd, options.configPath)) : options.cwd;
-  const dotenv = await loadDevflareDotenv(startDir);
-  const sources = {
-    ...dotenv.values,
-    ...process.env
-  };
-  const missing = [];
-  const vars = resolveVarsObject(config.vars, sources, options.mode, missing);
-  if (missing.length > 0) {
-    throw new EnvVarResolutionError(missing, options.mode);
-  }
-  return vars === config.vars ? config : {
-    ...config,
-    vars
-  };
-}
-
-// 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 rateLimitBindingSchema = z.object({
-  namespaceId: z.string().regex(/^[1-9]\d*$/, "namespaceId must be a positive integer string"),
-  simple: z.object({
-    limit: z.number().int().positive(),
-    period: z.union([z.literal(10), z.literal(60)])
-  }).strict()
-}).strict();
-var versionMetadataBindingSchema = z.object({
-  binding: z.string().min(1)
-}).strict();
-var workerLoaderBindingSchema = z.object({}).strict();
-var secretsStoreBindingSchema = z.union([
-  z.string().min(1),
-  z.object({
-    storeId: z.string().min(1),
-    secretName: z.string().min(1)
-  }).strict()
-]);
-var serviceBindingKeys = new Set(["service", "environment", "entrypoint", "__ref"]);
-function isServiceBindingValue(val) {
-  if (typeof val !== "object" && typeof val !== "function" || val === null) {
-    return false;
-  }
-  const obj = val;
-  if (typeof obj.service !== "string" || obj.service.trim().length === 0) {
-    return false;
-  }
-  if (obj.environment !== undefined && (typeof obj.environment !== "string" || obj.environment.trim().length === 0)) {
-    return false;
-  }
-  if (obj.entrypoint !== undefined && (typeof obj.entrypoint !== "string" || obj.entrypoint.trim().length === 0)) {
-    return false;
-  }
-  if (typeof val === "object") {
-    for (const key of Object.keys(obj)) {
-      if (!serviceBindingKeys.has(key)) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-var serviceBindingSchema = z.custom(isServiceBindingValue, {
-  message: "Expected service binding object with { service: string, environment?: string, entrypoint?: string } or ref().worker"
-});
-var aiBindingSchema = z.object({
-  binding: z.string(),
-  remote: z.boolean().optional(),
-  staging: z.boolean().optional()
-}).strict();
-var aiSearchNamespaceBindingSchema = z.object({
-  namespace: z.string().min(1),
-  remote: z.boolean().optional()
-}).strict();
-var aiSearchInstanceBindingSchema = z.object({
-  instanceName: z.string().min(1),
-  remote: z.boolean().optional()
-}).strict();
-var vectorizeBindingSchema = z.object({
-  indexName: z.string(),
-  remote: z.boolean().optional()
-});
-var hyperdriveBindingByIdSchema = z.object({
-  id: z.string(),
-  localConnectionString: z.string().optional()
-}).strict();
-var hyperdriveBindingByNameSchema = z.object({
-  name: z.string(),
-  localConnectionString: z.string().optional(),
-  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 browserBindingValueSchema = z.union([
-  z.string(),
-  z.object({
-    remote: z.boolean().optional()
-  }).strict()
-]);
-var browserBindingSchema = z.record(z.string(), browserBindingValueSchema).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 mtlsCertificateBindingByIdSchema = z.object({
-  certificateId: z.string().min(1),
-  remote: z.boolean().optional()
-}).strict();
-var mtlsCertificateBindingByWranglerIdSchema = z.object({
-  certificate_id: z.string().min(1),
-  remote: z.boolean().optional()
-}).strict();
-var mtlsCertificateBindingSchema = z.union([
-  z.string().min(1),
-  mtlsCertificateBindingByIdSchema,
-  mtlsCertificateBindingByWranglerIdSchema
-]);
-var dispatchNamespaceBindingSchema = z.union([
-  z.string().min(1),
-  z.object({
-    namespace: z.string().min(1),
-    outbound: z.object({
-      service: z.string().min(1),
-      environment: z.string().optional(),
-      parameters: z.array(z.string()).optional()
-    }).strict().optional(),
-    remote: z.boolean().optional()
-  }).strict()
-]);
-var workflowBindingSchema = z.object({
-  name: z.string().min(1),
-  className: z.string().min(1),
-  scriptName: z.string().min(1).optional(),
-  remote: z.boolean().optional(),
-  limits: z.object({
-    steps: z.number().int().positive()
-  }).strict().optional()
-}).strict();
-var pipelineBindingSchema = z.union([
-  z.string().min(1),
-  z.object({
-    pipeline: z.string().min(1),
-    remote: z.boolean().optional()
-  }).strict()
-]);
-var imagesBindingSchema = z.object({
-  remote: z.boolean().optional()
-}).strict().or(z.literal(true));
-var mediaBindingSchema = z.object({
-  remote: z.boolean().optional()
-}).strict().or(z.literal(true));
-var artifactsBindingSchema = z.union([
-  z.string().min(1),
-  z.object({
-    namespace: z.string().min(1),
-    remote: z.boolean().optional()
-  }).strict()
-]);
-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(),
-  rateLimits: z.record(z.string(), rateLimitBindingSchema).optional(),
-  versionMetadata: versionMetadataBindingSchema.optional(),
-  workerLoaders: z.record(z.string(), workerLoaderBindingSchema).optional(),
-  secretsStore: z.record(z.string(), secretsStoreBindingSchema).optional(),
-  services: z.record(z.string(), serviceBindingSchema).optional(),
-  ai: aiBindingSchema.optional(),
-  aiSearchNamespaces: z.record(z.string(), aiSearchNamespaceBindingSchema).optional(),
-  aiSearch: z.record(z.string(), aiSearchInstanceBindingSchema).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().superRefine((bindings, ctx) => {
-    if (!bindings || Object.keys(bindings).length <= 1) {
-      return;
-    }
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Wrangler currently supports one Images binding per Worker"
-    });
-  }),
-  media: z.record(z.string(), mediaBindingSchema).optional().superRefine((bindings, ctx) => {
-    if (!bindings || Object.keys(bindings).length <= 1) {
-      return;
-    }
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "Wrangler currently supports one Media Transformations binding per Worker"
-    });
-  }),
-  artifacts: z.record(z.string(), artifactsBindingSchema).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 };
-  }
-  const localConnectionString = "localConnectionString" in config ? config.localConnectionString : ("previewLocalConnectionString" in config) ? config.previewLocalConnectionString : undefined;
-  if ("id" in config) {
-    return {
-      configurationId: config.id,
-      ...localConnectionString && { localConnectionString }
-    };
-  }
-  return {
-    name: config.name,
-    ...localConnectionString && { localConnectionString }
-  };
-}
-function normalizeMtlsCertificateBinding(config) {
-  if (typeof config === "string") {
-    return { certificateId: config };
-  }
-  if ("certificateId" in config) {
-    return {
-      certificateId: config.certificateId,
-      ...config.remote !== undefined && { remote: config.remote }
-    };
-  }
-  return {
-    certificateId: config.certificate_id,
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeDispatchNamespaceBinding(config) {
-  if (typeof config === "string") {
-    return { namespace: config };
-  }
-  return {
-    namespace: config.namespace,
-    ...config.outbound && {
-      outbound: {
-        service: config.outbound.service,
-        ...config.outbound.environment && { environment: config.outbound.environment },
-        ...config.outbound.parameters && { parameters: config.outbound.parameters }
-      }
-    },
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeWorkflowBinding(config) {
-  return {
-    name: config.name,
-    className: config.className,
-    ...config.scriptName && { scriptName: config.scriptName },
-    ...config.remote !== undefined && { remote: config.remote },
-    ...config.limits && {
-      limits: {
-        steps: config.limits.steps
-      }
-    }
-  };
-}
-function normalizePipelineBinding(config) {
-  if (typeof config === "string") {
-    return { pipeline: config };
-  }
-  return {
-    pipeline: config.pipeline,
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeImagesBinding(binding, config) {
-  if (config === true) {
-    return { binding };
-  }
-  return {
-    binding,
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeMediaBinding(binding, config) {
-  if (config === true) {
-    return { binding };
-  }
-  return {
-    binding,
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeArtifactsBinding(config) {
-  if (typeof config === "string") {
-    return { namespace: config };
-  }
-  return {
-    namespace: config.namespace,
-    ...config.remote !== undefined && { remote: config.remote }
-  };
-}
-function normalizeSecretsStoreBinding(config, defaultStoreId, bindingName = "unknown") {
-  if (typeof config === "string") {
-    if (!defaultStoreId) {
-      throw new Error(`Secrets Store binding "${bindingName}" uses shorthand and requires top-level secretsStoreId.`);
-    }
-    return {
-      storeId: defaultStoreId,
-      secretName: config
-    };
-  }
-  return {
-    storeId: config.storeId,
-    secretName: config.secretName
-  };
-}
-function getLocalKVNamespaceIdentifier(config) {
-  const normalized = normalizeKVBinding(config);
-  return normalized.namespaceId ?? normalized.name ?? "";
-}
-function getLocalD1DatabaseIdentifier(config) {
-  const normalized = normalizeD1Binding(config);
-  return normalized.databaseId ?? 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(),
-  tail: 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 tailConsumerSchema = z4.union([
-  z4.string().min(1),
-  z4.object({
-    service: z4.string().min(1),
-    environment: z4.string().min(1).optional()
-  }).strict()
-]);
-var triggersSchema = z4.object({
-  crons: z4.array(z4.string()).optional()
-}).optional();
-var previewsConfigSchema = z4.object({
-  includeCrons: z4.boolean().optional().default(false)
-}).optional();
-var serverConfigSchema = z4.object({
-  host: z4.string().min(1).optional(),
-  port: z4.number().int().min(1).max(65535).optional()
-}).strict().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()
-}).superRefine((route, ctx) => {
-  if (!route.custom_domain) {
-    return;
-  }
-  if (route.pattern.includes("*")) {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      path: ["pattern"],
-      message: "Wildcard operators (*) are not allowed in Custom Domains"
-    });
-  }
-  if (route.pattern.includes("/")) {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      path: ["pattern"],
-      message: "Paths are not allowed in Custom Domains"
-    });
-  }
-});
-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(),
-  html_handling: z4.enum(["auto-trailing-slash", "force-trailing-slash", "drop-trailing-slash", "none"]).optional(),
-  not_found_handling: z4.enum(["single-page-application", "404-page", "none"]).optional(),
-  run_worker_first: z4.union([z4.boolean(), z4.array(z4.string())]).optional()
-}).strict().optional();
-var smartPlacementSchema = z4.object({
-  mode: z4.enum(["off", "smart"]),
-  hint: z4.string().optional()
-}).strict().superRefine((placement, ctx) => {
-  if (placement.hint !== undefined && placement.mode !== "smart") {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      path: ["hint"],
-      message: "placement.hint can only be set when placement.mode is smart"
-    });
-  }
-});
-var targetedRegionPlacementSchema = z4.object({
-  mode: z4.literal("targeted").optional(),
-  region: z4.string().min(1)
-}).strict();
-var targetedHostPlacementSchema = z4.object({
-  mode: z4.literal("targeted").optional(),
-  host: z4.string().min(1)
-}).strict();
-var targetedHostnamePlacementSchema = z4.object({
-  mode: z4.literal("targeted").optional(),
-  hostname: z4.string().min(1)
-}).strict();
-var placementSchema = z4.union([
-  smartPlacementSchema,
-  targetedRegionPlacementSchema,
-  targetedHostPlacementSchema,
-  targetedHostnamePlacementSchema
-]).optional();
-var samplingRateSchema = z4.number().min(0).max(1);
-var observabilityLogsSchema = z4.object({
-  enabled: z4.boolean().optional(),
-  head_sampling_rate: samplingRateSchema.optional(),
-  invocation_logs: z4.boolean().optional(),
-  persist: z4.boolean().optional(),
-  destinations: z4.array(z4.string()).optional()
-}).strict();
-var observabilityTracesSchema = z4.object({
-  enabled: z4.boolean().optional(),
-  head_sampling_rate: samplingRateSchema.optional(),
-  persist: z4.boolean().optional(),
-  destinations: z4.array(z4.string()).optional()
-}).strict();
-var observabilitySchema = z4.object({
-  enabled: z4.boolean().optional(),
-  head_sampling_rate: samplingRateSchema.optional(),
-  logs: observabilityLogsSchema.optional(),
-  traces: observabilityTracesSchema.optional()
-}).strict().optional();
-var limitsSchema = z4.object({
-  cpu_ms: z4.number().optional(),
-  subrequests: z4.number().optional()
-}).strict().optional();
-var rolloutStepPercentageSchema = z4.union([
-  z4.number().int().positive(),
-  z4.array(z4.number().int().positive()).min(1)
-]);
-var containerConfigSchema = z4.object({
-  className: z4.string().min(1),
-  image: z4.string().min(1),
-  maxInstances: z4.number().int().positive().optional(),
-  instanceType: z4.string().min(1).optional(),
-  name: z4.string().min(1).optional(),
-  imageBuildContext: z4.string().min(1).optional(),
-  imageVars: z4.record(z4.string(), z4.string()).optional(),
-  rolloutActiveGracePeriod: z4.number().int().nonnegative().optional(),
-  rolloutStepPercentage: rolloutStepPercentageSchema.optional()
-}).strict();
-var containersConfigSchema = z4.array(containerConfigSchema).optional();
-var moduleRuleSchema = z4.object({
-  type: z4.enum(["ESModule", "CommonJS", "CompiledWasm", "Text", "Data"]),
-  globs: z4.array(z4.string()).min(1),
-  fallthrough: z4.boolean().optional()
-}).strict();
-var moduleRulesSchema = z4.array(moduleRuleSchema).optional();
-var renamedClassMigrationSchema = z4.object({
-  from: z4.string(),
-  to: z4.string()
-}).strict();
-var migrationSchema = z4.object({
-  tag: z4.string(),
-  new_classes: z4.array(z4.string()).optional(),
-  renamed_classes: z4.array(renamedClassMigrationSchema).optional(),
-  deleted_classes: z4.array(z4.string()).optional(),
-  new_sqlite_classes: z4.array(z4.string()).optional()
-}).strict();
-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];
-}
-function getSecretsStoreShorthandBindings(config) {
-  return Object.entries(config.bindings?.secretsStore ?? {}).filter(([, binding]) => typeof binding === "string").map(([bindingName]) => bindingName);
-}
-function addSecretsStoreShorthandIssues(ctx, config, pathPrefix = []) {
-  if (config.secretsStoreId) {
-    return;
-  }
-  for (const bindingName of getSecretsStoreShorthandBindings(config)) {
-    ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
-      path: [...pathPrefix, "bindings", "secretsStore", bindingName],
-      message: `Secrets Store binding "${bindingName}" uses shorthand and requires top-level secretsStoreId.`
-    });
-  }
-}
-var varValueSchema = z5.lazy(() => z5.union([
-  z5.string(),
-  z5.number(),
-  z5.boolean(),
-  z5.null(),
-  z5.custom(isEnvVarDescriptor),
-  z5.array(varValueSchema),
-  z5.record(z5.string(), varValueSchema)
-]));
-var rootConfigShape = {
-  name: z5.string({
-    required_error: "Worker name is required"
-  }),
-  accountId: z5.string().optional(),
-  secretsStoreId: z5.string().min(1).optional(),
-  compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
-  compatibilityFlags: z5.array(z5.string()).optional().transform((flags = []) => normalizeCompatibilityFlags(flags)),
-  previews: previewsConfigSchema,
-  server: serverConfigSchema,
-  files: filesSchema,
-  bindings: bindingsSchema,
-  triggers: triggersSchema,
-  rules: moduleRulesSchema,
-  findAdditionalModules: z5.boolean().optional(),
-  baseDir: z5.string().optional(),
-  preserveFileNames: z5.boolean().optional(),
-  logpush: z5.boolean().optional(),
-  uploadSourceMaps: z5.boolean().optional(),
-  keepVars: z5.boolean().optional(),
-  tailConsumers: z5.array(tailConsumerSchema).optional(),
-  vars: z5.record(z5.string(), varValueSchema).optional(),
-  secrets: z5.record(z5.string(), secretConfigSchema).optional(),
-  routes: z5.array(routeConfigSchema).optional(),
-  wsRoutes: z5.array(wsRouteConfigSchema).optional(),
-  assets: assetsConfigSchema,
-  containers: containersConfigSchema,
-  placement: placementSchema,
-  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()
-}).strict().superRefine((config, ctx) => {
-  addSecretsStoreShorthandIssues(ctx, config);
-  for (const [envName, envConfig] of Object.entries(config.env ?? {})) {
-    addSecretsStoreShorthandIssues(ctx, {
-      ...envConfig,
-      secretsStoreId: envConfig.secretsStoreId ?? config.secretsStoreId
-    }, ["env", envName]);
-  }
-});
-var configSchema = canonicalConfigSchema;
-
-// src/config/preview.ts
-var PREVIEW_SCOPED_NAME_PREFIX = "__DEVFLARE_PREVIEW_SCOPE__:";
-function invalidPreviewScopedName(reason) {
-  throw new Error(`Invalid Devflare preview-scoped value: ${reason}. Recreate it with preview.scope(...) instead of constructing preview markers manually.`);
-}
-function decodePreviewScopedName(value) {
-  const payload = value.slice(PREVIEW_SCOPED_NAME_PREFIX.length);
-  let parsed;
-  try {
-    parsed = JSON.parse(payload);
-  } catch {
-    invalidPreviewScopedName("the encoded payload is not valid JSON");
-  }
-  const baseName = typeof parsed.baseName === "string" ? parsed.baseName : "";
-  if (!baseName.trim()) {
-    invalidPreviewScopedName("the encoded payload is missing a non-empty baseName");
-  }
-  return {
-    baseName,
-    separator: typeof parsed.separator === "string" && parsed.separator.length > 0 ? parsed.separator : "-"
-  };
-}
-function normalizePreviewFragment(rawValue) {
-  let normalized = rawValue.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-  if (!normalized) {
-    normalized = "preview";
-  }
-  if (!/^[a-z]/.test(normalized)) {
-    normalized = `b-${normalized}`;
-  }
-  return normalized;
-}
-function getPreviewIdentifierFromEnv(env2) {
-  const explicitIdentifier = env2.DEVFLARE_PREVIEW_IDENTIFIER?.trim();
-  if (explicitIdentifier) {
-    return {
-      identifier: normalizePreviewFragment(explicitIdentifier),
-      source: "env-identifier"
-    };
-  }
-  const previewPr = env2.DEVFLARE_PREVIEW_PR?.trim();
-  if (previewPr) {
-    return {
-      identifier: normalizePreviewFragment(`pr-${previewPr}`),
-      source: "env-pr"
-    };
-  }
-  const previewBranch = env2.DEVFLARE_PREVIEW_BRANCH?.trim();
-  if (previewBranch) {
-    return {
-      identifier: normalizePreviewFragment(previewBranch),
-      source: "env-branch"
-    };
-  }
-  return {
-    identifier: undefined,
-    source: "none"
-  };
-}
-function resolvePreviewIdentifier(options = {}) {
-  if (options.identifier?.trim()) {
-    return {
-      identifier: normalizePreviewFragment(options.identifier),
-      source: "identifier"
-    };
-  }
-  const env2 = options.env ?? process.env;
-  const envIdentifier = getPreviewIdentifierFromEnv(env2);
-  if (envIdentifier.identifier) {
-    return envIdentifier;
-  }
-  return options.environment === "preview" ? {
-    identifier: "preview",
-    source: "environment"
-  } : {
-    identifier: undefined,
-    source: "none"
-  };
-}
-function mapRecordValues(record, mapper) {
-  return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
-}
-function isPreviewScopedName(value) {
-  return typeof value === "string" && value.startsWith(PREVIEW_SCOPED_NAME_PREFIX);
-}
-function materializePreviewScopedString(value, options = {}) {
-  if (!isPreviewScopedName(value)) {
-    return value;
-  }
-  const scoped = decodePreviewScopedName(value);
-  const previewIdentifier = resolvePreviewIdentifier(options).identifier;
-  return previewIdentifier ? `${scoped.baseName}${scoped.separator}${previewIdentifier}` : scoped.baseName;
-}
-function materializePreviewScopedConfig(config, options = {}) {
-  if (!config.bindings) {
-    return config;
-  }
-  const bindings = config.bindings;
-  const hasPreviewIdentifier = Boolean(resolvePreviewIdentifier(options).identifier);
-  return {
-    ...config,
-    bindings: {
-      ...bindings,
-      ...bindings.kv ? {
-        kv: mapRecordValues(bindings.kv, (binding) => {
-          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
-        })
-      } : {},
-      ...bindings.d1 ? {
-        d1: mapRecordValues(bindings.d1, (binding) => {
-          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
-        })
-      } : {},
-      ...bindings.r2 ? {
-        r2: mapRecordValues(bindings.r2, (binding) => {
-          return materializePreviewScopedString(binding, options);
-        })
-      } : {},
-      ...bindings.queues ? {
-        queues: {
-          ...bindings.queues,
-          ...bindings.queues.producers ? {
-            producers: mapRecordValues(bindings.queues.producers, (queueName) => {
-              return materializePreviewScopedString(queueName, options);
-            })
-          } : {},
-          ...bindings.queues.consumers ? {
-            consumers: bindings.queues.consumers.map((consumer) => ({
-              ...consumer,
-              queue: materializePreviewScopedString(consumer.queue, options),
-              ...consumer.deadLetterQueue ? {
-                deadLetterQueue: materializePreviewScopedString(consumer.deadLetterQueue, options)
-              } : {}
-            }))
-          } : {}
-        }
-      } : {},
-      ...bindings.services ? {
-        services: mapRecordValues(bindings.services, (binding) => ({
-          ...binding,
-          service: materializePreviewScopedString(binding.service, options)
-        }))
-      } : {},
-      ...bindings.vectorize ? {
-        vectorize: mapRecordValues(bindings.vectorize, (binding) => ({
-          ...binding,
-          indexName: materializePreviewScopedString(binding.indexName, options)
-        }))
-      } : {},
-      ...bindings.hyperdrive ? {
-        hyperdrive: mapRecordValues(bindings.hyperdrive, (binding) => {
-          if (typeof binding === "string") {
-            return materializePreviewScopedString(binding, options);
-          }
-          if (binding && typeof binding === "object" && "name" in binding && typeof binding.name === "string") {
-            if (hasPreviewIdentifier && binding.previewId) {
-              return {
-                id: binding.previewId,
-                ...binding.localConnectionString && {
-                  localConnectionString: binding.localConnectionString
-                },
-                ...!binding.localConnectionString && binding.previewLocalConnectionString && {
-                  localConnectionString: binding.previewLocalConnectionString
-                }
-              };
-            }
-            return {
-              ...binding,
-              name: materializePreviewScopedString(binding.name, options)
-            };
-          }
-          return binding;
-        })
-      } : {},
-      ...bindings.browser ? {
-        browser: mapRecordValues(bindings.browser, (binding) => {
-          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
-        })
-      } : {},
-      ...bindings.analyticsEngine ? {
-        analyticsEngine: mapRecordValues(bindings.analyticsEngine, (binding) => ({
-          ...binding,
-          dataset: materializePreviewScopedString(binding.dataset, options)
-        }))
-      } : {}
-    }
-  };
-}
-
-// src/config/resolve.ts
-function isPlainObject2(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 (isPlainObject2(override)) {
-    const baseObject = isPlainObject2(base) ? base : {};
-    const mergedObject = {
-      ...baseObject
-    };
-    for (const [key, value] of Object.entries(override)) {
-      mergedObject[key] = mergeEnvironmentValue(baseObject[key], value);
-    }
-    return mergedObject;
-  }
-  return override;
-}
-function withNormalizedCompatibilityFlags(config) {
-  return {
-    ...config,
-    compatibilityFlags: normalizeCompatibilityFlags(config.compatibilityFlags)
-  };
-}
-function mergeConfigForEnvironment(config, environment) {
-  if (!environment || !config.env?.[environment]) {
-    return withNormalizedCompatibilityFlags(config);
-  }
-  const mergedConfig = mergeEnvironmentValue(config, config.env[environment]);
-  return withNormalizedCompatibilityFlags(mergedConfig);
-}
-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 materializeHyperdriveIdBindings(bindings, idsByName) {
-  if (!bindings) {
-    return;
-  }
-  return Object.fromEntries(Object.entries(bindings).map(([bindingName, bindingConfig]) => {
-    const normalized = normalizeHyperdriveBinding(bindingConfig);
-    return [
-      bindingName,
-      {
-        id: normalized.configurationId ?? idsByName?.get(normalized.name ?? "") ?? normalized.name ?? "",
-        ...normalized.localConnectionString && {
-          localConnectionString: normalized.localConnectionString
-        }
-      }
-    ];
-  }));
-}
-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 as existsSync2 } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "pathe";
-
-// src/config/framework-providers.ts
-import { readFile as readFile2 } 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 readFile2(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");
-  }
-}
-async function resolveConfigDotenvDirectory(cwd, configFile) {
-  const explicitConfigPath = resolve2(cwd, configFile);
-  if (existsSync2(explicitConfigPath)) {
-    return dirname2(explicitConfigPath);
-  }
-  const discoveredConfigPath = await resolveConfigPath(cwd);
-  return discoveredConfigPath ? dirname2(discoveredConfigPath) : cwd;
-}
-async function resolveConfigPath(cwd) {
-  for (const file of CONFIG_FILES) {
-    const path = join2(cwd, file);
-    if (existsSync2(path)) {
-      return path;
-    }
-  }
-  return;
-}
-async function loadConfig(options = {}) {
-  const cwd = resolve2(options.cwd ?? process.cwd());
-  const configFile = options.configFile ?? "devflare.config";
-  const { loadConfig: c12LoadConfig } = resolveC12Module(cwd);
-  await loadDevflareDotenvIntoProcess(await resolveConfigDotenvDirectory(cwd, configFile));
-  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 ?? {}
-  };
-}
-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: materializeHyperdriveIdBindings(hyperdriveBindings)
-  }));
-}
-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: materializeHyperdriveIdBindings(hyperdriveBindings)
-    }));
-  }
-  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: materializeHyperdriveIdBindings(hyperdriveBindings, 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/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/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: materializeHyperdriveIdBindings(hyperdriveBindings)
-      })),
-      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 ? materializeHyperdriveIdBindings(hyperdriveBindings, hyperdriveIdsByName.idsByName) : materializeHyperdriveIdBindings(hyperdriveBindings) : 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 { getDevflareDotenvPaths, EnvVarResolutionError, resolveConfigEnvVars, normalizeCompatibilityFlags, browserBindingSchema, getSingleBrowserBindingName, normalizeDOBinding, normalizeD1Binding, normalizeKVBinding, normalizeHyperdriveBinding, normalizeMtlsCertificateBinding, normalizeDispatchNamespaceBinding, normalizeWorkflowBinding, normalizePipelineBinding, normalizeImagesBinding, normalizeMediaBinding, normalizeArtifactsBinding, normalizeSecretsStoreBinding, getLocalKVNamespaceIdentifier, getLocalD1DatabaseIdentifier, configSchema, resolvePreviewIdentifier, isPreviewScopedName, materializePreviewScopedString, materializePreviewScopedConfig, mergeConfigForEnvironment, resolveConfigForEnvironment, prepareConfigResourcesForDeploy, resolveResources, ConfigResourceResolutionError, loadResolvedConfig, resolveConfigPath, loadConfig, ConfigNotFoundError };