devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/_chunks/compiler-BtLp9T9N.js

@@ -0,0 +1,500 @@
+import { p as normalizeCompatibilityFlags, u as resolveConfigForEnvironment } from "./loader-OQ2AWpqm.js";
+import { C as browserBindingSchema, _ as normalizeSecretsStoreBinding, a as normalizeD1Binding, b as normalizeVpcServiceBinding, c as normalizeFlagshipBinding, d as normalizeKVBinding, f as normalizeMediaBinding, g as normalizeR2Binding, h as normalizeQueueProducer, i as normalizeArtifactsBinding, l as normalizeHyperdriveBinding, m as normalizePipelineBinding, o as normalizeDOBinding, p as normalizeMtlsCertificateBinding, r as getSingleBrowserBindingName, s as normalizeDispatchNamespaceBinding, u as normalizeImagesBinding, v as normalizeStreamBinding, x as normalizeWorkflowBinding, y as normalizeVpcNetworkBinding } from "./schema-normalization-GjhTATHL.js";
+import { n as toWranglerSecretsConfig } from "./local-dev-vars-CTSa-wvF.js";
+import { basename, isAbsolute, relative, resolve } from "pathe";
+//#region src/config/compiler/bindings.ts
+function getWranglerD1DatabaseBinding(bindingName, bindingConfig, options = {}) {
+	const normalized = normalizeD1Binding(bindingConfig);
+	const extras = {
+		...normalized.previewDatabaseId !== void 0 && { preview_database_id: normalized.previewDatabaseId },
+		...normalized.migrationsTable !== void 0 && { migrations_table: normalized.migrationsTable },
+		...normalized.migrationsDir !== void 0 && { migrations_dir: normalized.migrationsDir },
+		...normalized.remote !== void 0 && { remote: normalized.remote }
+	};
+	if (normalized.databaseId) return {
+		binding: bindingName,
+		database_id: normalized.databaseId,
+		...extras
+	};
+	if (options.preserveNamedBindings && normalized.name) return {
+		binding: bindingName,
+		database_name: normalized.name,
+		...extras
+	};
+	throw new Error(`D1 binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerKVNamespaceBinding(bindingName, bindingConfig, options = {}) {
+	const normalized = normalizeKVBinding(bindingConfig);
+	const extras = {
+		...normalized.previewId !== void 0 && { preview_id: normalized.previewId },
+		...normalized.remote !== void 0 && { remote: normalized.remote }
+	};
+	if (normalized.namespaceId) return {
+		binding: bindingName,
+		id: normalized.namespaceId,
+		...extras
+	};
+	if (options.preserveNamedBindings && normalized.name) return {
+		binding: bindingName,
+		name: normalized.name,
+		...extras
+	};
+	throw new Error(`KV binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerHyperdriveBinding(bindingName, bindingConfig, options = {}) {
+	const normalized = normalizeHyperdriveBinding(bindingConfig);
+	if (normalized.configurationId) return {
+		binding: bindingName,
+		id: normalized.configurationId,
+		...normalized.localConnectionString && { localConnectionString: normalized.localConnectionString }
+	};
+	if (options.preserveNamedBindings && normalized.name) return {
+		binding: bindingName,
+		name: normalized.name,
+		...normalized.localConnectionString && { localConnectionString: normalized.localConnectionString }
+	};
+	throw new Error(`Hyperdrive binding "${bindingName}" is configured by name (${normalized.name}) and must be resolved before compiling Wrangler config. Use loadResolvedConfig() or resolveConfigResources() for build/deploy/automation flows.`);
+}
+function getWranglerBrowserBinding(browserBindings) {
+	if (!browserBindings) return;
+	const parsed = browserBindingSchema.parse(browserBindings);
+	const bindingName = getSingleBrowserBindingName(parsed);
+	if (!bindingName) return;
+	const bindingConfig = parsed[bindingName];
+	return {
+		binding: bindingName,
+		...typeof bindingConfig === "object" && bindingConfig.remote !== void 0 && { remote: bindingConfig.remote }
+	};
+}
+/**
+* Compile bindings from devflare format to wrangler format
+*/
+function compileBindings(bindings, result, options = {}, defaultSecretsStoreId) {
+	if (bindings.kv) result.kv_namespaces = Object.entries(bindings.kv).map(([binding, namespace]) => {
+		return getWranglerKVNamespaceBinding(binding, namespace, options);
+	});
+	if (bindings.d1) result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => {
+		return getWranglerD1DatabaseBinding(binding, database_id, options);
+	});
+	if (bindings.r2) result.r2_buckets = Object.entries(bindings.r2).map(([binding, config]) => {
+		const normalized = normalizeR2Binding(config);
+		return {
+			binding,
+			bucket_name: normalized.bucketName,
+			...normalized.previewBucketName !== void 0 && { preview_bucket_name: normalized.previewBucketName },
+			...normalized.jurisdiction !== void 0 && { jurisdiction: normalized.jurisdiction },
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.durableObjects) result.durable_objects = { bindings: Object.entries(bindings.durableObjects).map(([name, config]) => {
+		const normalized = normalizeDOBinding(config);
+		const binding = {
+			name,
+			class_name: normalized.className
+		};
+		if (normalized.kind === "cross-worker" && normalized.scriptName) binding.script_name = normalized.scriptName;
+		return binding;
+	}) };
+	if (bindings.queues) {
+		result.queues = {};
+		if (bindings.queues.producers) result.queues.producers = Object.entries(bindings.queues.producers).map(([binding, config]) => {
+			const normalized = normalizeQueueProducer(config);
+			return {
+				binding,
+				queue: normalized.queue,
+				...normalized.remote !== void 0 && { remote: normalized.remote },
+				...normalized.deliveryDelay !== void 0 && { delivery_delay: normalized.deliveryDelay }
+			};
+		});
+		if (bindings.queues.consumers) result.queues.consumers = bindings.queues.consumers.map((consumer) => ({
+			queue: consumer.queue,
+			...consumer.maxBatchSize && { max_batch_size: consumer.maxBatchSize },
+			...consumer.maxBatchTimeout && { max_batch_timeout: consumer.maxBatchTimeout },
+			...consumer.maxRetries && { max_retries: consumer.maxRetries },
+			...consumer.deadLetterQueue && { dead_letter_queue: consumer.deadLetterQueue },
+			...consumer.maxConcurrency && { max_concurrency: consumer.maxConcurrency },
+			...consumer.retryDelay && { retry_delay: consumer.retryDelay },
+			...consumer.visibilityTimeoutMs && { visibility_timeout_ms: consumer.visibilityTimeoutMs }
+		}));
+	}
+	if (bindings.rateLimits) result.ratelimits = Object.entries(bindings.rateLimits).map(([name, config]) => ({
+		name,
+		namespace_id: config.namespaceId,
+		simple: {
+			limit: config.simple.limit,
+			period: config.simple.period
+		}
+	}));
+	if (bindings.versionMetadata) result.version_metadata = { binding: bindings.versionMetadata.binding };
+	if (bindings.workerLoaders) result.worker_loaders = Object.keys(bindings.workerLoaders).map((binding) => ({ binding }));
+	if (bindings.mtlsCertificates) result.mtls_certificates = Object.entries(bindings.mtlsCertificates).map(([binding, config]) => {
+		const normalized = normalizeMtlsCertificateBinding(config);
+		return {
+			binding,
+			certificate_id: normalized.certificateId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.dispatchNamespaces) result.dispatch_namespaces = Object.entries(bindings.dispatchNamespaces).map(([binding, config]) => {
+		const normalized = normalizeDispatchNamespaceBinding(config);
+		return {
+			binding,
+			namespace: normalized.namespace,
+			...normalized.outbound && { outbound: normalized.outbound },
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.workflows) result.workflows = Object.entries(bindings.workflows).map(([binding, config]) => {
+		const normalized = normalizeWorkflowBinding(config);
+		return {
+			binding,
+			name: normalized.name,
+			class_name: normalized.className,
+			...normalized.scriptName && { script_name: normalized.scriptName },
+			...normalized.remote !== void 0 && { remote: normalized.remote },
+			...normalized.limits && { limits: normalized.limits }
+		};
+	});
+	if (bindings.pipelines) result.pipelines = Object.entries(bindings.pipelines).map(([binding, config]) => {
+		const normalized = normalizePipelineBinding(config);
+		return {
+			binding,
+			pipeline: normalized.pipeline,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.images) {
+		const [entry] = Object.entries(bindings.images);
+		if (entry) {
+			const [binding, config] = entry;
+			const normalized = normalizeImagesBinding(binding, config);
+			result.images = {
+				binding: normalized.binding,
+				...normalized.remote !== void 0 && { remote: normalized.remote }
+			};
+		}
+	}
+	if (bindings.media) {
+		const [entry] = Object.entries(bindings.media);
+		if (entry) {
+			const [binding, config] = entry;
+			const normalized = normalizeMediaBinding(binding, config);
+			result.media = {
+				binding: normalized.binding,
+				...normalized.remote !== void 0 && { remote: normalized.remote }
+			};
+		}
+	}
+	if (bindings.artifacts) result.artifacts = Object.entries(bindings.artifacts).map(([binding, config]) => {
+		const normalized = normalizeArtifactsBinding(config);
+		return {
+			binding,
+			namespace: normalized.namespace,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.stream) {
+		const [entry] = Object.entries(bindings.stream);
+		if (entry) {
+			const [binding, config] = entry;
+			const normalized = normalizeStreamBinding(binding, config);
+			result.stream = {
+				binding: normalized.binding,
+				...normalized.remote !== void 0 && { remote: normalized.remote }
+			};
+		}
+	}
+	if (bindings.vpcServices) result.vpc_services = Object.entries(bindings.vpcServices).map(([binding, config]) => {
+		const normalized = normalizeVpcServiceBinding(config);
+		return {
+			binding,
+			service_id: normalized.serviceId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.vpcNetworks) result.vpc_networks = Object.entries(bindings.vpcNetworks).map(([binding, config]) => {
+		const normalized = normalizeVpcNetworkBinding(config);
+		if (normalized.tunnelId !== void 0) return {
+			binding,
+			tunnel_id: normalized.tunnelId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+		return {
+			binding,
+			network_id: normalized.networkId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.flagship) result.flagship = Object.entries(bindings.flagship).map(([binding, config]) => {
+		const normalized = normalizeFlagshipBinding(config);
+		return {
+			binding,
+			app_id: normalized.appId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		};
+	});
+	if (bindings.secretsStore) result.secrets_store_secrets = Object.entries(bindings.secretsStore).map(([binding, config]) => {
+		const normalized = normalizeSecretsStoreBinding(config, defaultSecretsStoreId, binding);
+		return {
+			binding,
+			store_id: normalized.storeId,
+			secret_name: normalized.secretName
+		};
+	});
+	if (bindings.services) result.services = Object.entries(bindings.services).map(([binding, config]) => ({
+		binding,
+		service: config.service,
+		...config.entrypoint && { entrypoint: config.entrypoint },
+		...config.environment && { environment: config.environment },
+		...config.remote !== void 0 && { remote: config.remote },
+		...config.props !== void 0 && { props: config.props }
+	}));
+	if (bindings.ai?.binding) result.ai = {
+		binding: bindings.ai.binding,
+		...bindings.ai.remote !== void 0 && { remote: bindings.ai.remote },
+		...bindings.ai.staging !== void 0 && { staging: bindings.ai.staging }
+	};
+	if (bindings.aiSearchNamespaces) result.ai_search_namespaces = Object.entries(bindings.aiSearchNamespaces).map(([binding, config]) => ({
+		binding,
+		namespace: config.namespace,
+		...config.remote !== void 0 && { remote: config.remote }
+	}));
+	if (bindings.aiSearch) result.ai_search = Object.entries(bindings.aiSearch).map(([binding, config]) => ({
+		binding,
+		instance_name: config.instanceName,
+		...config.remote !== void 0 && { remote: config.remote }
+	}));
+	if (bindings.vectorize) result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
+		binding,
+		index_name: config.indexName,
+		...config.remote !== void 0 && { remote: config.remote }
+	}));
+	if (bindings.hyperdrive) result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => {
+		return getWranglerHyperdriveBinding(binding, config, options);
+	});
+	const browserBinding = getWranglerBrowserBinding(bindings.browser);
+	if (browserBinding) result.browser = browserBinding;
+	if (bindings.analyticsEngine) result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
+		binding,
+		dataset: config.dataset
+	}));
+	if (bindings.sendEmail) result.send_email = Object.entries(bindings.sendEmail).map(([name, config]) => ({
+		name,
+		...config.destinationAddress && { destination_address: config.destinationAddress },
+		...config.allowedDestinationAddresses && { allowed_destination_addresses: config.allowedDestinationAddresses },
+		...config.allowedSenderAddresses && { allowed_sender_addresses: config.allowedSenderAddresses },
+		...config.remote !== void 0 && { remote: config.remote }
+	}));
+}
+//#endregion
+//#region src/config/compiler/core-helpers.ts
+function compileWranglerMigrations(migrations) {
+	return migrations.map((migration) => ({
+		tag: migration.tag,
+		...migration.new_classes && { new_classes: migration.new_classes },
+		...migration.renamed_classes && { renamed_classes: migration.renamed_classes.map((renamedClass) => ({
+			from: renamedClass.from,
+			to: renamedClass.to
+		})) },
+		...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
+		...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
+	}));
+}
+function compileModuleOptions(config, result) {
+	if (config.rules && config.rules.length > 0) result.rules = config.rules;
+	if (config.findAdditionalModules !== void 0) result.find_additional_modules = config.findAdditionalModules;
+	if (config.baseDir) result.base_dir = config.baseDir;
+	if (config.preserveFileNames !== void 0) result.preserve_file_names = config.preserveFileNames;
+	if (config.logpush !== void 0) result.logpush = config.logpush;
+	if (config.uploadSourceMaps !== void 0) result.upload_source_maps = config.uploadSourceMaps;
+	if (config.keepVars !== void 0) result.keep_vars = config.keepVars;
+}
+function compileContainers(config, result) {
+	if (!config.containers || config.containers.length === 0) return;
+	result.containers = config.containers.map((container) => ({
+		class_name: container.className,
+		image: container.image,
+		...container.maxInstances !== void 0 && { max_instances: container.maxInstances },
+		...container.instanceType && { instance_type: container.instanceType },
+		...container.name && { name: container.name },
+		...container.imageBuildContext && { image_build_context: container.imageBuildContext },
+		...container.imageVars && { image_vars: container.imageVars },
+		...container.rolloutActiveGracePeriod !== void 0 && { rollout_active_grace_period: container.rolloutActiveGracePeriod },
+		...container.rolloutStepPercentage !== void 0 && { rollout_step_percentage: container.rolloutStepPercentage }
+	}));
+}
+//#endregion
+//#region src/config/compiler/paths.ts
+/**
+* Convert WranglerConfig to JSONC string with comments
+*/
+function stringifyConfig(config) {
+	return `// Generated by devflare — Do not edit directly
+// Edit devflare.config.ts instead
+
+` + JSON.stringify(config, null, "	");
+}
+function rebasePathForConfigDir(projectRoot, configDir, pathValue) {
+	return relative(configDir, isAbsolute(pathValue) ? pathValue : resolve(projectRoot, pathValue)).replace(/\\/g, "/");
+}
+function isLocalContainerPath(pathValue) {
+	return pathValue === "Dockerfile" || pathValue.startsWith(".") || pathValue.startsWith("/") || pathValue.startsWith("\\") || isAbsolute(pathValue) || pathValue.endsWith("/Dockerfile") || pathValue.endsWith("\\Dockerfile");
+}
+function pathIsInsideDirectory(directoryPath, candidatePath) {
+	const normalizedDirectoryPath = directoryPath.replace(/\\/g, "/");
+	const normalizedCandidatePath = candidatePath.replace(/\\/g, "/");
+	return normalizedCandidatePath === normalizedDirectoryPath || normalizedCandidatePath.startsWith(`${normalizedDirectoryPath}/`);
+}
+function isolateViteBuildOutputPaths(projectRoot, config) {
+	const assetsDirectory = config.assets?.directory;
+	if (!assetsDirectory) return config;
+	const isolatedAssetsDirectoryPath = resolve(projectRoot, ".devflare", "vite-build-output", basename(assetsDirectory));
+	const isolatedAssetsDirectory = relative(projectRoot, isolatedAssetsDirectoryPath).replace(/\\/g, "/");
+	const isolatedConfig = {
+		...config,
+		assets: config.assets ? {
+			...config.assets,
+			directory: isolatedAssetsDirectory
+		} : config.assets
+	};
+	if (!config.main) return isolatedConfig;
+	const originalAssetsDirectoryPath = resolve(projectRoot, assetsDirectory);
+	const originalMainEntryPath = resolve(projectRoot, config.main);
+	if (!pathIsInsideDirectory(originalAssetsDirectoryPath, originalMainEntryPath)) return isolatedConfig;
+	const isolatedMainEntryPath = resolve(isolatedAssetsDirectoryPath, relative(originalAssetsDirectoryPath, originalMainEntryPath));
+	return {
+		...isolatedConfig,
+		main: relative(projectRoot, isolatedMainEntryPath).replace(/\\/g, "/")
+	};
+}
+function rebaseWranglerConfigPaths(projectRoot, configDir, config) {
+	return {
+		...config,
+		...config.main ? { main: rebasePathForConfigDir(projectRoot, configDir, config.main) } : {},
+		...config.assets?.directory ? { assets: {
+			...config.assets,
+			directory: rebasePathForConfigDir(projectRoot, configDir, config.assets.directory)
+		} } : {},
+		...config.containers ? { containers: config.containers.map((container) => ({
+			...container,
+			image: isLocalContainerPath(container.image) ? rebasePathForConfigDir(projectRoot, configDir, container.image) : container.image,
+			...container.image_build_context && { image_build_context: rebasePathForConfigDir(projectRoot, configDir, container.image_build_context) }
+		})) } : {}
+	};
+}
+/**
+* Write wrangler.jsonc file to the specified directory
+*
+* @param cwd - Working directory to write to
+* @param config - Wrangler configuration to write
+* @param filename - Optional filename (default: 'wrangler.jsonc')
+* @returns Path to the written file
+*/
+async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
+	const { resolve } = await import("pathe");
+	const fs = await import("node:fs/promises");
+	try {
+		await fs.mkdir(cwd, { recursive: true });
+	} catch {}
+	const content = stringifyConfig(config);
+	const wranglerPath = resolve(cwd, filename);
+	await fs.writeFile(wranglerPath, content, "utf-8");
+	return wranglerPath;
+}
+async function readWranglerConfig(filePath) {
+	const fs = await import("node:fs/promises");
+	const { parse } = await import("jsonc-parser");
+	const parsedConfig = parse(await fs.readFile(filePath, "utf-8"));
+	if (!parsedConfig || typeof parsedConfig !== "object") throw new Error(`Could not parse Wrangler config at ${filePath}.`);
+	return parsedConfig;
+}
+//#endregion
+//#region src/config/compiler.ts
+/**
+* Compile a phase-resolved DevflareConfig to WranglerConfig.
+*
+* R1 step 3: input is type-narrowed to `ResolvedConfig` (`LocalConfig | DeployConfig`)
+* so callers cannot accidentally pass a raw `DevflareConfig` whose KV/D1/Hyperdrive
+* bindings might still be name-only. The runtime throw remains as a defense-in-depth
+* guard for callers that bypass the type system.
+*
+* @param config - A phase-resolved devflare configuration (`LocalConfig` or `DeployConfig`)
+* @param environment - Optional environment name for env-specific overrides
+* @returns Wrangler-compatible configuration object
+*/
+function compileConfig(config, environment) {
+	return compileConfigInternal(config, environment);
+}
+function compileBuildConfig(config, environment, options = {}) {
+	return compileConfigInternal(config, environment, {
+		preserveNamedBindings: true,
+		alreadyResolved: options.alreadyResolved
+	});
+}
+function compileConfigInternal(config, environment, options = {}) {
+	const resolvedConfig = options.alreadyResolved ? config : resolveConfigForEnvironment(config, environment);
+	const mergedConfig = {
+		...resolvedConfig,
+		compatibilityFlags: normalizeCompatibilityFlags(resolvedConfig.compatibilityFlags)
+	};
+	const result = {
+		name: mergedConfig.name,
+		compatibility_date: mergedConfig.compatibilityDate,
+		preview_urls: true,
+		workers_dev: mergedConfig.workersDev ?? true,
+		...mergedConfig.complianceRegion !== void 0 && { compliance_region: mergedConfig.complianceRegion }
+	};
+	if (mergedConfig.accountId) result.account_id = mergedConfig.accountId;
+	const mainEntry = mergedConfig.files?.fetch;
+	if (typeof mainEntry === "string") result.main = mainEntry;
+	compileModuleOptions(mergedConfig, result);
+	if (mergedConfig.compatibilityFlags && mergedConfig.compatibilityFlags.length > 0) result.compatibility_flags = mergedConfig.compatibilityFlags;
+	if (mergedConfig.bindings) compileBindings(mergedConfig.bindings, result, options, mergedConfig.secretsStoreId);
+	if (mergedConfig.triggers?.crons && mergedConfig.triggers.crons.length > 0) result.triggers = { crons: mergedConfig.triggers.crons };
+	if (mergedConfig.tailConsumers && mergedConfig.tailConsumers.length > 0) result.tail_consumers = mergedConfig.tailConsumers.map((consumer) => typeof consumer === "string" ? { service: consumer } : {
+		service: consumer.service,
+		...consumer.environment && { environment: consumer.environment }
+	});
+	if (mergedConfig.streamingTailConsumers && mergedConfig.streamingTailConsumers.length > 0) result.streaming_tail_consumers = mergedConfig.streamingTailConsumers.map((consumer) => typeof consumer === "string" ? { service: consumer } : {
+		service: consumer.service,
+		...consumer.environment && { environment: consumer.environment }
+	});
+	if (mergedConfig.vars && Object.keys(mergedConfig.vars).length > 0) result.vars = mergedConfig.vars;
+	const secrets = toWranglerSecretsConfig(mergedConfig.secrets);
+	if (secrets) result.secrets = secrets;
+	if (mergedConfig.routes && mergedConfig.routes.length > 0) result.routes = mergedConfig.routes.map((route) => ({
+		pattern: route.pattern,
+		...route.zone_name && { zone_name: route.zone_name },
+		...route.zone_id && { zone_id: route.zone_id },
+		...route.custom_domain !== void 0 && { custom_domain: route.custom_domain },
+		...route.enabled !== void 0 && { enabled: route.enabled },
+		...route.previews_enabled !== void 0 && { previews_enabled: route.previews_enabled }
+	}));
+	if (mergedConfig.assets?.directory) result.assets = {
+		directory: mergedConfig.assets.directory,
+		...mergedConfig.assets.binding && { binding: mergedConfig.assets.binding },
+		...mergedConfig.assets.html_handling && { html_handling: mergedConfig.assets.html_handling },
+		...mergedConfig.assets.not_found_handling && { not_found_handling: mergedConfig.assets.not_found_handling },
+		...mergedConfig.assets.run_worker_first !== void 0 && { run_worker_first: mergedConfig.assets.run_worker_first }
+	};
+	if (mergedConfig.placement) result.placement = mergedConfig.placement;
+	if (mergedConfig.observability) result.observability = mergedConfig.observability;
+	if (mergedConfig.limits) result.limits = mergedConfig.limits;
+	compileContainers(mergedConfig, result);
+	if (mergedConfig.migrations && mergedConfig.migrations.length > 0) result.migrations = compileWranglerMigrations(mergedConfig.migrations);
+	if (mergedConfig.wrangler?.passthrough) Object.assign(result, mergedConfig.wrangler.passthrough);
+	return result;
+}
+/**
+* Compile DevflareConfig to programmatic config for @cloudflare/vite-plugin.
+* This is used instead of wrangler.jsonc in dev mode.
+*
+* @param config - The devflare configuration
+* @param environment - Optional environment name for env-specific overrides
+* @returns Config object compatible with cloudflare({ config: ... })
+*/
+function compileToProgrammaticConfig(config, environment, options = {}) {
+	return options.preserveNamedBindings ? compileBuildConfig(config, environment) : compileConfig(config, environment);
+}
+//#endregion
+export { readWranglerConfig as a, writeWranglerConfig as c, isolateViteBuildOutputPaths as i, compileConfig as n, rebaseWranglerConfigPaths as o, compileToProgrammaticConfig as r, stringifyConfig as s, compileBuildConfig as t };

package/dist/_chunks/config-QU8UEWmA.js

@@ -0,0 +1,78 @@
+import { d as resolveConfigEnvVars } from "./preview-C3Cdr8an.js";
+import { a as ConfigResourceResolutionError, o as loadResolvedConfig, r as loadConfig, s as resolveResources } from "./loader-OQ2AWpqm.js";
+import { n as compileConfig, t as compileBuildConfig } from "./compiler-BtLp9T9N.js";
+//#region src/cli/commands/config.ts
+function isSupportedFormat(value) {
+	return value === "devflare" || value === "wrangler";
+}
+function isSupportedPhase(value) {
+	return value === "build" || value === "local" || value === "deploy";
+}
+async function loadConfigForPhase(options) {
+	if (options.phase === "deploy") return await resolveConfigEnvVars(await loadResolvedConfig({
+		cwd: options.cwd,
+		configFile: options.configPath,
+		environment: options.environment
+	}), {
+		cwd: options.cwd,
+		configPath: options.configPath,
+		mode: "build"
+	});
+	return await resolveConfigEnvVars(await resolveResources(await loadConfig({
+		cwd: options.cwd,
+		configFile: options.configPath
+	}), {
+		phase: options.phase,
+		environment: options.environment
+	}), {
+		cwd: options.cwd,
+		configPath: options.configPath,
+		mode: options.phase === "local" ? "dev" : "build"
+	});
+}
+async function runConfigCommand(parsed, logger, options) {
+	const cwd = options.cwd || process.cwd();
+	const configPath = parsed.options.config;
+	const environment = parsed.options.env;
+	const subcommand = parsed.args[0] ?? "print";
+	const format = parsed.options.format ?? "devflare";
+	const phaseOption = parsed.options.local === true ? "local" : parsed.options.phase ?? "deploy";
+	if (subcommand !== "print") {
+		logger.error(`Unknown config subcommand: ${subcommand}`);
+		logger.info("Supported subcommands: print");
+		return { exitCode: 1 };
+	}
+	if (!isSupportedFormat(format)) {
+		logger.error(`Unsupported config format: ${format}`);
+		logger.info("Supported formats: devflare, wrangler");
+		return { exitCode: 1 };
+	}
+	if (!isSupportedPhase(phaseOption)) {
+		logger.error(`Unsupported config phase: ${phaseOption}`);
+		logger.info("Supported phases: build, local, deploy");
+		return { exitCode: 1 };
+	}
+	try {
+		const resolvedConfig = await loadConfigForPhase({
+			cwd,
+			configPath,
+			environment,
+			phase: phaseOption
+		});
+		const output = format === "wrangler" ? phaseOption === "build" ? compileBuildConfig(resolvedConfig, void 0, { alreadyResolved: true }) : compileConfig(resolvedConfig) : resolvedConfig;
+		const text = JSON.stringify(output, null, "	");
+		if (!options.silent) process.stdout.write(`${text}\n`);
+		return {
+			exitCode: 0,
+			output: text
+		};
+	} catch (error) {
+		if (error instanceof Error) {
+			logger.error("Config command failed:", error.message);
+			if (error instanceof ConfigResourceResolutionError) logger.info("For offline inspection, run `devflare config --phase local` or `devflare config --phase build --format wrangler`.");
+		}
+		return { exitCode: 1 };
+	}
+}
+//#endregion
+export { runConfigCommand };

package/dist/_chunks/config-path-1yI7BiDU.js

@@ -0,0 +1,42 @@
+import { i as resolveConfigPath } from "./loader-OQ2AWpqm.js";
+import { i as findFiles } from "./glob-CmQOvunB.js";
+import { stat } from "node:fs/promises";
+//#region src/cli/config-path.ts
+const CONFIG_FILE_EXTENSIONS = [
+	".ts",
+	".mts",
+	".js",
+	".mjs"
+];
+const SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
+function hasKnownConfigExtension(filePath) {
+	return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function getExistingFilePath(filePath) {
+	try {
+		return (await stat(filePath)).isFile() ? filePath : null;
+	} catch {
+		return null;
+	}
+}
+async function resolveConfigCandidatePath(candidatePath) {
+	const candidates = [candidatePath];
+	if (!hasKnownConfigExtension(candidatePath)) for (const extension of CONFIG_FILE_EXTENSIONS) candidates.push(`${candidatePath}${extension}`);
+	for (const candidate of candidates) {
+		const existingFilePath = await getExistingFilePath(candidate);
+		if (existingFilePath) return existingFilePath;
+	}
+	return await resolveConfigPath(candidatePath) ?? null;
+}
+async function findConfigPathsUnderDirectory(rootDir) {
+	const matches = await findFiles([...SUPPORTED_CONFIG_FILENAMES, ...SUPPORTED_CONFIG_FILENAMES.map((filename) => `**/${filename}`)], {
+		cwd: rootDir,
+		absolute: true
+	});
+	return [...new Set(matches)].sort((left, right) => left.localeCompare(right));
+}
+function formatSupportedConfigFilenames() {
+	return SUPPORTED_CONFIG_FILENAMES.join(", ");
+}
+//#endregion
+export { formatSupportedConfigFilenames as n, resolveConfigCandidatePath as r, findConfigPathsUnderDirectory as t };