devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/_chunks/loader-Cr0_OWPy.js

@@ -0,0 +1,1288 @@
+import { l as isEnvVarDescriptor, n as materializePreviewScopedConfig, u as loadDevflareDotenvIntoProcess } from "./preview-C3Cdr8an.js";
+import { S as bindingsSchema, a as normalizeD1Binding, d as normalizeKVBinding, g as normalizeR2Binding, h as normalizeQueueProducer, l as normalizeHyperdriveBinding, n as getLocalKVNamespaceIdentifier, t as getLocalD1DatabaseIdentifier } from "./schema-normalization-BCwTLTGp.js";
+import { d as getPrimaryAccount, n as getEffectiveAccountId } from "./preferences-BKp_7XJx.js";
+import { _ as listR2Buckets, g as listQueues, h as listKVNamespaces, i as createR2Bucket, m as listHyperdrives, n as createKVNamespace, p as listD1Databases, r as createQueue, t as createD1Database, v as listVectorizeIndexes } from "./account-resources-CsmVowJp.js";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "pathe";
+import { z } from "zod";
+//#region src/config/compatibility.ts
+const FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
+function normalizeCompatibilityFlags(flags = []) {
+	return [...new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags])];
+}
+//#endregion
+//#region src/config/schema-build.ts
+const rolldownOptionsSchema = z.custom((value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}, { message: "Expected Rolldown options object" });
+/**
+* Rolldown configuration for Durable Object bundling.
+* Controls Devflare's Rolldown-based DO bundler in local development.
+*/
+const rolldownConfigSchema = z.object({
+	target: z.string().optional(),
+	minify: z.boolean().optional(),
+	sourcemap: z.boolean().optional(),
+	options: rolldownOptionsSchema.optional()
+}).optional();
+/**
+* Vite-related configuration namespace.
+* This keeps Vite-specific configuration distinct from Rolldown/DO bundling.
+*
+* Note: raw Vite build/server configuration still belongs in `vite.config.*`.
+* Devflare currently models `plugins` here and leaves room for future Vite-side
+* config without overloading the root config shape.
+*/
+const viteConfigSchema = z.object({ plugins: z.array(z.unknown()).optional() }).catchall(z.unknown()).optional();
+const envConfigSchemaInner = z.lazy(() => z.object(rootConfigShape).omit({
+	accountId: true,
+	wsRoutes: true
+}).partial().strict());
+//#endregion
+//#region src/config/cron.ts
+const CRON_FIELDS = [
+	{
+		name: "minute",
+		min: 0,
+		max: 59
+	},
+	{
+		name: "hour",
+		min: 0,
+		max: 23
+	},
+	{
+		name: "day-of-month",
+		min: 1,
+		max: 31
+	},
+	{
+		name: "month",
+		min: 1,
+		max: 12,
+		names: {
+			JAN: 1,
+			FEB: 2,
+			MAR: 3,
+			APR: 4,
+			MAY: 5,
+			JUN: 6,
+			JUL: 7,
+			AUG: 8,
+			SEP: 9,
+			OCT: 10,
+			NOV: 11,
+			DEC: 12
+		}
+	},
+	{
+		name: "day-of-week",
+		min: 0,
+		max: 7,
+		names: {
+			SUN: 0,
+			MON: 1,
+			TUE: 2,
+			WED: 3,
+			THU: 4,
+			FRI: 5,
+			SAT: 6
+		}
+	}
+];
+/** Resolve a single value token (number or 3-letter name) for a field. */
+function resolveFieldValue(token, field) {
+	if (/^\d+$/.test(token)) {
+		const value = Number.parseInt(token, 10);
+		if (value < field.min || value > field.max) return null;
+		return value;
+	}
+	if (field.names) {
+		const named = field.names[token.toUpperCase()];
+		if (named !== void 0) return named;
+	}
+	return null;
+}
+/** Validate a single non-`*` element (a number, range, or stepped form). */
+function isValidFieldElement(element, field) {
+	let base = element;
+	let step = null;
+	const slashIndex = element.indexOf("/");
+	if (slashIndex !== -1) {
+		base = element.slice(0, slashIndex);
+		step = element.slice(slashIndex + 1);
+		if (!/^\d+$/.test(step) || Number.parseInt(step, 10) < 1) return false;
+	}
+	if (base === "*") return true;
+	const dashIndex = base.indexOf("-");
+	if (dashIndex !== -1) {
+		const startToken = base.slice(0, dashIndex);
+		const endToken = base.slice(dashIndex + 1);
+		const start = resolveFieldValue(startToken, field);
+		const end = resolveFieldValue(endToken, field);
+		if (start === null || end === null) return false;
+		return start <= end;
+	}
+	return resolveFieldValue(base, field) !== null;
+}
+/** Validate a single cron field (which may be a comma-separated list). */
+function isValidCronField(value, field) {
+	if (value.length === 0) return false;
+	const elements = value.split(",");
+	for (const element of elements) if (element.length === 0 || !isValidFieldElement(element, field)) return false;
+	return true;
+}
+/**
+* Returns true when `expression` is a valid Cloudflare 5-field cron expression.
+*
+* Accepts `*`, numbers, ranges (`1-5`), lists (`1,3,5`), steps (`*\/5`,
+* `1-30/5`, `5/15`) and the 3-letter month (`JAN`-`DEC`) / weekday
+* (`SUN`-`SAT`) names, with the correct per-field numeric ranges. Cloudflare
+* cron has no seconds and no year field, so anything other than 5 fields is
+* rejected.
+*/
+function isValidCronExpression(expression) {
+	if (typeof expression !== "string") return false;
+	const fields = expression.trim().split(/\s+/);
+	if (fields.length !== CRON_FIELDS.length) return false;
+	for (let index = 0; index < CRON_FIELDS.length; index++) if (!isValidCronField(fields[index], CRON_FIELDS[index])) return false;
+	return true;
+}
+/**
+* Human-readable message for an invalid cron expression, naming the bad value.
+*/
+function formatInvalidCronMessage(expression) {
+	return `Invalid cron expression "${expression}". Cloudflare cron triggers use 5 fields: minute (0-59) hour (0-23) day-of-month (1-31) month (1-12 or JAN-DEC) day-of-week (0-7 or SUN-SAT). Each field accepts *, numbers, ranges (1-5), lists (1,3,5) and steps (*/5).`;
+}
+/**
+* Throw a descriptive error when `expression` is not a valid cron expression.
+*/
+function assertValidCronExpression(expression) {
+	if (!isValidCronExpression(expression)) throw new Error(formatInvalidCronMessage(expression));
+}
+/**
+* Cloudflare Workers compatibility date schema.
+* Must be in YYYY-MM-DD format (e.g., '2025-01-07').
+*/
+const compatibilityDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, { message: "Compatibility date must be in YYYY-MM-DD format" });
+/**
+* Built-in file router configuration used for `src/routes/**` discovery.
+*/
+const routesConfigSchema = z.object({
+	dir: z.string(),
+	prefix: z.string().optional()
+});
+/**
+* File handler configuration.
+* Maps handler types to their source file paths.
+*/
+const filesSchema = z.object({
+	fetch: z.union([z.string(), z.literal(false)]).optional(),
+	queue: z.union([z.string(), z.literal(false)]).optional(),
+	scheduled: z.union([z.string(), z.literal(false)]).optional(),
+	email: z.union([z.string(), z.literal(false)]).optional(),
+	tail: z.union([z.string(), z.literal(false)]).optional(),
+	durableObjects: z.union([z.string(), z.literal(false)]).optional(),
+	entrypoints: z.union([z.string(), z.literal(false)]).optional(),
+	workflows: z.union([z.string(), z.literal(false)]).optional(),
+	routes: z.union([routesConfigSchema, z.literal(false)]).optional(),
+	transport: z.union([z.string(), z.null()]).optional()
+}).optional();
+/**
+* Tail Consumer configuration.
+*/
+const tailConsumerSchema = z.union([z.string().min(1), z.object({
+	service: z.string().min(1),
+	environment: z.string().min(1).optional()
+}).strict()]);
+/**
+* Trigger configuration for scheduled (cron) events.
+*
+* Each cron expression is validated against the Cloudflare 5-field cron grammar
+* at config-parse time, so a typo fails before deploy instead of silently never
+* firing in production.
+*/
+const triggersSchema = z.object({ crons: z.array(z.string()).optional() }).superRefine((triggers, ctx) => {
+	if (!triggers.crons) return;
+	triggers.crons.forEach((cron, index) => {
+		if (!isValidCronExpression(cron)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["crons", index],
+			message: formatInvalidCronMessage(cron)
+		});
+	});
+}).optional();
+/**
+* Preview-specific Devflare behavior.
+*/
+const previewsConfigSchema = z.object({ includeCrons: z.boolean().optional().default(false) }).optional();
+/**
+* Dev server configuration for `devflare dev`.
+*
+* Controls the host and port the local Miniflare runtime instance binds to.
+* This is a development-only setting and is never emitted to compiled Wrangler
+* output. CLI flags (`--runtime-port`, `--runtime-host`) and environment
+* variables (`DEVFLARE_RUNTIME_PORT`, `DEVFLARE_RUNTIME_HOST`) take precedence
+* over these values.
+*/
+const serverConfigSchema = z.object({
+	host: z.string().min(1).optional(),
+	port: z.number().int().min(1).max(65535).optional()
+}).strict().optional();
+/**
+* Secret declaration options.
+*/
+const secretConfigSchema = z.object({ required: z.boolean().optional().default(true) });
+/**
+* Route configuration for worker deployment.
+*/
+const routeConfigSchema = z.object({
+	pattern: z.string(),
+	zone_name: z.string().optional(),
+	zone_id: z.string().optional(),
+	custom_domain: z.boolean().optional()
+}).superRefine((route, ctx) => {
+	if (!route.custom_domain) return;
+	if (route.pattern.includes("*")) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["pattern"],
+		message: "Wildcard operators (*) are not allowed in Custom Domains"
+	});
+	if (route.pattern.includes("/")) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["pattern"],
+		message: "Paths are not allowed in Custom Domains"
+	});
+});
+/**
+* WebSocket route configuration for dev mode Durable Object proxying.
+*/
+const wsRouteConfigSchema = z.object({
+	pattern: z.string(),
+	doNamespace: z.string(),
+	idParam: z.string().default("id"),
+	forwardPath: z.string().default("/websocket")
+});
+/**
+* Static assets configuration.
+*/
+const assetsConfigSchema = z.object({
+	directory: z.string(),
+	binding: z.string().optional(),
+	html_handling: z.enum([
+		"auto-trailing-slash",
+		"force-trailing-slash",
+		"drop-trailing-slash",
+		"none"
+	]).optional(),
+	not_found_handling: z.enum([
+		"single-page-application",
+		"404-page",
+		"none"
+	]).optional(),
+	run_worker_first: z.union([z.boolean(), z.array(z.string())]).optional()
+}).strict().optional();
+const smartPlacementSchema = z.object({
+	mode: z.enum(["off", "smart"]),
+	hint: z.string().optional()
+}).strict().superRefine((placement, ctx) => {
+	if (placement.hint !== void 0 && placement.mode !== "smart") ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["hint"],
+		message: "placement.hint can only be set when placement.mode is smart"
+	});
+});
+const targetedRegionPlacementSchema = z.object({
+	mode: z.literal("targeted").optional(),
+	region: z.string().min(1)
+}).strict();
+const targetedHostPlacementSchema = z.object({
+	mode: z.literal("targeted").optional(),
+	host: z.string().min(1)
+}).strict();
+const targetedHostnamePlacementSchema = z.object({
+	mode: z.literal("targeted").optional(),
+	hostname: z.string().min(1)
+}).strict();
+/**
+* Worker placement configuration.
+*/
+const placementSchema = z.union([
+	smartPlacementSchema,
+	targetedRegionPlacementSchema,
+	targetedHostPlacementSchema,
+	targetedHostnamePlacementSchema
+]).optional();
+const samplingRateSchema = z.number().min(0).max(1);
+const observabilityLogsSchema = z.object({
+	enabled: z.boolean().optional(),
+	head_sampling_rate: samplingRateSchema.optional(),
+	invocation_logs: z.boolean().optional(),
+	persist: z.boolean().optional(),
+	destinations: z.array(z.string()).optional()
+}).strict();
+const observabilityTracesSchema = z.object({
+	enabled: z.boolean().optional(),
+	head_sampling_rate: samplingRateSchema.optional(),
+	persist: z.boolean().optional(),
+	destinations: z.array(z.string()).optional()
+}).strict();
+/**
+* Observability configuration for logs and traces.
+*/
+const observabilitySchema = z.object({
+	enabled: z.boolean().optional(),
+	head_sampling_rate: samplingRateSchema.optional(),
+	logs: observabilityLogsSchema.optional(),
+	traces: observabilityTracesSchema.optional()
+}).strict().optional();
+/**
+* Resource limits configuration.
+*/
+const limitsSchema = z.object({
+	cpu_ms: z.number().optional(),
+	subrequests: z.number().optional()
+}).strict().optional();
+const rolloutStepPercentageSchema = z.union([z.number().int().positive(), z.array(z.number().int().positive()).min(1)]);
+/**
+* Cloudflare Containers configuration.
+*
+* Devflare authors this in camelCase and compiles to Wrangler's top-level
+* `containers` array. Runtime launch/testing is handled by the local
+* container test shim, not by Miniflare itself.
+*/
+const containerConfigSchema = z.object({
+	className: z.string().min(1),
+	image: z.string().min(1),
+	maxInstances: z.number().int().positive().optional(),
+	instanceType: z.string().min(1).optional(),
+	name: z.string().min(1).optional(),
+	imageBuildContext: z.string().min(1).optional(),
+	imageVars: z.record(z.string(), z.string()).optional(),
+	rolloutActiveGracePeriod: z.number().int().nonnegative().optional(),
+	rolloutStepPercentage: rolloutStepPercentageSchema.optional()
+}).strict();
+const containersConfigSchema = z.array(containerConfigSchema).optional();
+/**
+* Module rules for non-JavaScript Worker modules and imported assets.
+*
+* Wrangler also exposes Python-specific rule types while Python Workers are in
+* beta. Devflare keeps those behind `wrangler.passthrough` until the local
+* Python Worker toolchain has a stable Devflare integration point.
+*/
+const moduleRuleSchema = z.object({
+	type: z.enum([
+		"ESModule",
+		"CommonJS",
+		"CompiledWasm",
+		"Text",
+		"Data"
+	]),
+	globs: z.array(z.string()).min(1),
+	fallthrough: z.boolean().optional()
+}).strict();
+const moduleRulesSchema = z.array(moduleRuleSchema).optional();
+/**
+* Durable Object migration configuration.
+*/
+const renamedClassMigrationSchema = z.object({
+	from: z.string(),
+	to: z.string()
+}).strict();
+const migrationSchema = z.object({
+	tag: z.string(),
+	new_classes: z.array(z.string()).optional(),
+	renamed_classes: z.array(renamedClassMigrationSchema).optional(),
+	deleted_classes: z.array(z.string()).optional(),
+	new_sqlite_classes: z.array(z.string()).optional()
+}).strict();
+/**
+* Wrangler configuration passthrough.
+*/
+const wranglerConfigSchema = z.object({ passthrough: z.record(z.string(), z.unknown()).optional() }).optional();
+//#endregion
+//#region src/config/schema.ts
+/** Helper to get current date in YYYY-MM-DD format */
+function getCurrentDate() {
+	return (/* @__PURE__ */ new Date()).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: z.ZodIssueCode.custom,
+		path: [
+			...pathPrefix,
+			"bindings",
+			"secretsStore",
+			bindingName
+		],
+		message: `Secrets Store binding "${bindingName}" uses shorthand and requires top-level secretsStoreId.`
+	});
+}
+const varValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.custom(isEnvVarDescriptor),
+	z.array(varValueSchema),
+	z.record(z.string(), varValueSchema)
+]));
+/**
+* Raw Zod shape of the root devflare configuration (excluding the `env` field,
+* which references back into this shape via the environment override schema).
+*
+* Exported so `schema-env.ts` can derive the environment override schema from
+* the single source of truth without hand-listing every field.
+*/
+const rootConfigShape = {
+	name: z.string({ required_error: "Worker name is required" }),
+	accountId: z.string().optional(),
+	secretsStoreId: z.string().min(1).optional(),
+	compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
+	compatibilityFlags: z.array(z.string()).optional().transform((flags = []) => normalizeCompatibilityFlags(flags)),
+	previews: previewsConfigSchema,
+	server: serverConfigSchema,
+	files: filesSchema,
+	bindings: bindingsSchema,
+	triggers: triggersSchema,
+	rules: moduleRulesSchema,
+	findAdditionalModules: z.boolean().optional(),
+	baseDir: z.string().optional(),
+	preserveFileNames: z.boolean().optional(),
+	logpush: z.boolean().optional(),
+	uploadSourceMaps: z.boolean().optional(),
+	keepVars: z.boolean().optional(),
+	tailConsumers: z.array(tailConsumerSchema).optional(),
+	vars: z.record(z.string(), varValueSchema).optional(),
+	secrets: z.record(z.string(), secretConfigSchema).optional(),
+	routes: z.array(routeConfigSchema).optional(),
+	wsRoutes: z.array(wsRouteConfigSchema).optional(),
+	assets: assetsConfigSchema,
+	containers: containersConfigSchema,
+	placement: placementSchema,
+	limits: limitsSchema,
+	observability: observabilitySchema,
+	migrations: z.array(migrationSchema).optional(),
+	rolldown: rolldownConfigSchema,
+	vite: viteConfigSchema,
+	wrangler: wranglerConfigSchema
+};
+const configSchema = z.object({
+	...rootConfigShape,
+	env: z.record(z.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]);
+});
+//#endregion
+//#region 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 === void 0) 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 withNormalizedCompatibilityFlags(config) {
+	return {
+		...config,
+		compatibilityFlags: normalizeCompatibilityFlags(config.compatibilityFlags)
+	};
+}
+function mergeConfigForEnvironment(config, environment) {
+	if (!environment || !config.env?.[environment]) return withNormalizedCompatibilityFlags(config);
+	return withNormalizedCompatibilityFlags(mergeEnvironmentValue(config, config.env[environment]));
+}
+/**
+* @internal Prefer the unified `resolveResources(config, { phase: 'build' })`
+* facade for the env-merge + preview-materialize pipeline. This lower-level
+* helper remains exported as the implementation that the seam and the
+* build-time compiler delegate to; it is not part of the recommended public
+* surface.
+*/
+function resolveConfigForEnvironment(config, environment) {
+	return materializePreviewScopedConfig(mergeConfigForEnvironment(config, environment), { environment });
+}
+//#endregion
+//#region src/config/framework-providers.ts
+const 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;
+}
+const frameworkProviders = [{
+	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"
+				}
+			}
+		};
+	}
+}];
+function hasFrameworkInferenceGap(config) {
+	return config.files?.fetch === void 0 || config.assets?.directory === void 0 || config.assets?.binding === void 0;
+}
+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;
+}
+//#endregion
+//#region 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(", ");
+}
+//#endregion
+//#region src/config/deploy-resources.ts
+const defaultDeployResourcePreparationApi = {
+	getPrimaryAccount,
+	getEffectiveAccountId,
+	listKVNamespaces,
+	createKVNamespace,
+	listD1Databases,
+	createD1Database,
+	listR2Buckets,
+	createR2Bucket,
+	listQueues,
+	createQueue,
+	listHyperdrives,
+	listVectorizeIndexes
+};
+function createEmptyDeployResourceNames() {
+	return {
+		kv: [],
+		d1: [],
+		r2: [],
+		queues: [],
+		vectorize: [],
+		hyperdrive: []
+	};
+}
+/**
+* C13 — surface partial-progress orphans on a failed deploy preparation.
+*
+* If any resource was already created before the throw, attach a clear
+* footer to the error message listing what was created so the user can
+* decide whether to keep, delete, or rerun. Auto-deletion is intentionally
+* not performed: deletion is irreversible, has cross-binding side effects
+* (DBs may have data, queues may be inflight), and the deploy may simply
+* be retried after fixing the underlying error.
+*/
+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 = `\n\nDeploy preparation failed AFTER provisioning the following Cloudflare resources, which were left in your account:\n  - ${summaryParts.join("\n  - ")}\nRe-run \`devflare deploy\` after fixing the error to reuse them, or delete them manually if abandoning the deploy.`;
+	const decorated = /* @__PURE__ */ new Error(`${base.message}${orphanFooter}`);
+	if ("cause" in base && base.cause !== void 0) decorated.cause = base.cause;
+	else decorated.cause = base;
+	return decorated;
+}
+function resolveDeployResourcePreparationApi(overrides) {
+	return {
+		...defaultDeployResourcePreparationApi,
+		...overrides ?? {}
+	};
+}
+function resolveUniqueNames(values) {
+	const names = /* @__PURE__ */ 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 ?? {}).map((producer) => normalizeQueueProducer(producer).queue), ...(queues.consumers ?? []).flatMap((consumer) => [consumer.queue, consumer.deadLetterQueue])]);
+}
+function collectVectorizeIndexNames(config) {
+	return resolveUniqueNames(Object.values(config.bindings?.vectorize ?? {}).map((binding) => binding.indexName));
+}
+function resolveUniquePendingBindings(pendingBindings) {
+	return [...new Map(pendingBindings.map((binding) => [binding.resourceName, binding])).values()];
+}
+async function resolveLookupAccountId$1(config, options, cloudflareApi) {
+	const envAccountId = typeof process !== "undefined" ? process.env?.CLOUDFLARE_ACCOUNT_ID?.trim() : void 0;
+	const explicitAccountId = options.accountId ?? config.accountId ?? (envAccountId || void 0);
+	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: /* @__PURE__ */ 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 ?? {}).map((bucket) => normalizeR2Binding(bucket).bucketName));
+	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) : void 0,
+			d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : void 0,
+			hyperdrive: materializeHyperdriveIdBindings(hyperdriveBindings)
+		})),
+		created,
+		existing,
+		warnings
+	};
+	const cloudflareApi = resolveDeployResourcePreparationApi(options.cloudflare);
+	const accountId = await resolveLookupAccountId$1(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);
+		return {
+			config: brandAsDeployConfig(withResolvedIdBindings(resolvedConfig, {
+				kv: kvBindings ? pendingKVNameBindings.length > 0 ? materializeResolvedNameBindings(kvBindings, normalizeKVNameBinding, namespaceIdsByName.idsByName) : materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : void 0,
+				d1: d1Bindings ? pendingD1NameBindings.length > 0 ? materializeResolvedNameBindings(d1Bindings, normalizeD1NameBinding, databaseIdsByName.idsByName) : materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : void 0,
+				hyperdrive: hyperdriveBindings ? pendingHyperdriveNameBindings.length > 0 ? materializeHyperdriveIdBindings(hyperdriveBindings, hyperdriveIdsByName.idsByName) : materializeHyperdriveIdBindings(hyperdriveBindings) : void 0
+			})),
+			created,
+			existing,
+			warnings
+		};
+	} catch (err) {
+		throw decorateOrphanError(err, created);
+	}
+}
+async function prepareConfigResourcesForDeploy(config, options = {}) {
+	return prepareMaterializedConfigResourcesForDeploy(await resolveResources(config, {
+		phase: "build",
+		environment: options.environment,
+		preview: {
+			environment: options.environment,
+			env: options.env,
+			identifier: options.identifier
+		}
+	}), {
+		accountId: options.accountId,
+		cloudflare: options.cloudflare,
+		describeOnly: options.describeOnly
+	});
+}
+//#endregion
+//#region src/config/resolve-phased.ts
+/**
+* Cast helper used at the resolve-phase boundaries. The brand is a phantom
+* intersection so this is a zero-cost reinterpretation.
+*/
+function brandAsLocalConfig(config) {
+	return config;
+}
+/**
+* Cast helper used at the resolve-phase boundaries. The brand is a phantom
+* intersection so this is a zero-cost reinterpretation.
+*/
+function brandAsDeployConfig(config) {
+	return config;
+}
+/**
+* Unified phase-discriminated resource resolver. Facade over the legacy
+* per-phase helpers; stamps the appropriate phase brand on the returned
+* config so callers can narrow at the type layer.
+*/
+async function resolveResources(config, options) {
+	const previewMerged = materializePreviewScopedConfig(mergeConfigForEnvironment(config, options.environment), {
+		environment: options.environment,
+		...options.preview
+	});
+	switch (options.phase) {
+		case "build": return previewMerged;
+		case "local": return resolveConfigForLocalRuntime(previewMerged, void 0);
+		case "deploy":
+			if (options.provision) return (await prepareMaterializedConfigResourcesForDeploy(previewMerged, options.preparation ?? {
+				accountId: options.accountId,
+				cloudflare: options.cloudflare
+			})).config;
+			return await resolveMaterializedConfigResources(previewMerged, {
+				accountId: options.accountId,
+				cloudflare: options.cloudflare
+			});
+	}
+}
+//#endregion
+//#region src/config/resource-resolution.ts
+const defaultCloudflareApi = {
+	getPrimaryAccount,
+	getEffectiveAccountId,
+	listKVNamespaces,
+	listD1Databases,
+	listHyperdrives
+};
+var ConfigResourceResolutionError = class extends Error {
+	code = "CONFIG_RESOURCE_RESOLUTION_ERROR";
+	constructor(message, cause) {
+		super(message);
+		this.name = "ConfigResourceResolutionError";
+		if (cause !== void 0) 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 /* @__PURE__ */ 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;
+}
+/**
+* Resolve environment overrides and normalize KV/D1/Hyperdrive bindings for purely local runtimes.
+*
+* Local Miniflare/workerd flows can use either an explicit resource ID or the
+* stable resource name as the backing identifier, so this path avoids requiring
+* Cloudflare auth for local development and tests.
+*
+* @internal Prefer the unified `resolveResources(config, { phase: 'local' })`
+* facade. This lower-level helper remains exported for backwards compatibility
+* and as the implementation that the seam delegates to; it is not part of the
+* recommended public surface and may be removed in a future major release.
+*/
+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);
+	collectPendingNameBindings(kvBindings, normalizeKVNameBinding);
+	return brandAsLocalConfig(withResolvedIdBindings(resolvedConfig, {
+		kv: kvBindings ? materializeIdBindings(kvBindings, getLocalKVNamespaceIdentifier) : void 0,
+		d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : void 0,
+		hyperdrive: materializeHyperdriveIdBindings(hyperdriveBindings)
+	}));
+}
+/**
+* Resolve Cloudflare-backed resource references such as KV/D1/Hyperdrive
+* name bindings into concrete IDs.
+*
+* Used by the deploy path and by automation/programmatic consumers that need
+* fully-resolved bindings against a live Cloudflare account. The build path
+* intentionally does NOT call this — `compileBuildConfig({ preserveNamedBindings: true })`
+* keeps name-only bindings symbolic in the build artifact so builds remain
+* reproducible offline. Pick this helper only when ID resolution is desired.
+*
+* @internal Prefer the unified `resolveResources(config, { phase: 'deploy' })`
+* facade. This lower-level helper remains exported as the implementation the
+* seam delegates to; it is not part of the recommended public surface.
+*/
+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) : void 0,
+		d1: d1Bindings ? materializeIdBindings(d1Bindings, getLocalD1DatabaseIdentifier) : void 0,
+		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)
+	}));
+}
+/**
+* Resolve Cloudflare-backed resource references such as KV/D1/Hyperdrive name bindings into
+* concrete IDs for build, deploy, and automation workflows.
+*
+* @internal Prefer the unified `resolveResources(config, { phase: 'deploy' })`
+* facade. This wrapper is now a thin shim over the seam, retained for
+* backwards compatibility with existing callers (`loadResolvedConfig`, etc.).
+*/
+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
+	});
+}
+/**
+* Load devflare.config.* and resolve any Cloudflare-backed resource references.
+*
+* This is the public Node-side API for external automation that needs the same
+* resolved values Devflare build/deploy flows use.
+*/
+async function loadResolvedConfig(options = {}) {
+	return resolveConfigResources(await loadConfig(options), options);
+}
+//#endregion
+//#region src/config/loader.ts
+/**
+* Config file names to search for, in order of priority
+*/
+const CONFIG_FILES = [
+	"devflare.config.ts",
+	"devflare.config.mts",
+	"devflare.config.js",
+	"devflare.config.mjs"
+];
+function resolveC12Module(cwd) {
+	const requireFromCwd = createRequire(join(cwd, "__devflare__.cjs"));
+	try {
+		return requireFromCwd("c12");
+	} catch {
+		return createRequire(import.meta.url)("c12");
+	}
+}
+async function resolveConfigDotenvDirectory(cwd, configFile) {
+	const explicitConfigPath = resolve(cwd, configFile);
+	if (existsSync(explicitConfigPath)) return dirname(explicitConfigPath);
+	const discoveredConfigPath = await resolveConfigPath(cwd);
+	return discoveredConfigPath ? dirname(discoveredConfigPath) : cwd;
+}
+/**
+* Resolve the config file path in a directory
+*
+* @param cwd - Directory to search in
+* @returns Path to config file or undefined
+*/
+async function resolveConfigPath(cwd) {
+	for (const file of CONFIG_FILES) {
+		const path = join(cwd, file);
+		if (existsSync(path)) return path;
+	}
+}
+/**
+* Load and validate devflare configuration
+*
+* @param options - Loading options
+* @returns Validated DevflareConfig
+* @throws When config file not found or validation fails
+*/
+async function loadConfig(options = {}) {
+	const cwd = resolve(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: void 0,
+		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
+	});
+}
+/**
+* Error thrown when config file is not found
+*/
+var ConfigNotFoundError = class extends Error {
+	code = "CONFIG_NOT_FOUND";
+	constructor(cwd, configFile) {
+		super(`Config file not found in ${cwd}.\nExpected one of: ${CONFIG_FILES.join(", ")}\nRun 'devflare init' to create a new config.`);
+		this.cwd = cwd;
+		this.configFile = configFile;
+		this.name = "ConfigNotFoundError";
+	}
+};
+/**
+* Error thrown when config validation fails
+*/
+var ConfigValidationError = class extends Error {
+	code = "CONFIG_VALIDATION_ERROR";
+	constructor(issues, configFile) {
+		const issueMessages = issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+		super(`Invalid config in ${configFile}:\n${issueMessages}`);
+		this.issues = issues;
+		this.configFile = configFile;
+		this.name = "ConfigValidationError";
+	}
+};
+//#endregion
+export { ConfigResourceResolutionError as a, prepareConfigResourcesForDeploy as c, configSchema as d, assertValidCronExpression as f, resolveConfigPath as i, mergeConfigForEnvironment as l, ConfigValidationError as n, loadResolvedConfig as o, normalizeCompatibilityFlags as p, loadConfig as r, resolveResources as s, ConfigNotFoundError as t, resolveConfigForEnvironment as u };