devflare 1.0.0-next.4 → 1.0.0-next.41

package/dist/_chunks/cloudflare-BaloqI3H.js

@@ -0,0 +1,157 @@
+import { g as isAuthenticated, h as hasWranglerConfig, m as getWranglerAuth, p as getApiToken } from "./api-TzdliH-6.js";
+import { a as setGlobalDefaultAccountId, d as getPrimaryAccount, i as getWorkspaceAccountId, l as getAccountById, n as getEffectiveAccountId, o as setWorkspaceAccountId, r as getGlobalDefaultAccountId, t as clearGlobalDefaultAccountId, u as getAccounts } from "./preferences-BKp_7XJx.js";
+import { C as deleteWorker, D as listWorkerVersions, E as listWorkerDeployments, O as listWorkers, S as DEVFLARE_PREVIEW_REGISTRY_DATABASE, T as getWorkersSubdomain, a as listTrackedPreviewRecords, c as reconcilePreviewRegistry, i as listTrackedDeploymentRecords, k as renameWorker, l as retirePreviewRegistry, n as ensurePreviewRegistry, o as listTrackedPreviewScopeRecords, r as getPreviewRegistryContext, s as listTrackedRegistryState, t as cleanupPreviewRegistry, w as getWorkerVersionDetail } from "./preview-registry-ClAbLTHH.js";
+import { _ as listR2Buckets, b as rawD1DatabaseQuery, f as listAIModels, h as listKVNamespaces, m as listHyperdrives, p as listD1Databases, t as createD1Database, v as listVectorizeIndexes, y as queryD1Database } from "./account-resources-CsmVowJp.js";
+import { a as getUsageSummary, c as recordUsage, d as setLimitsEnabled, f as shouldSkip, i as getUsage, l as resetUsage, n as getAllUsageSummaries, o as isWithinLimits, r as getLimits, s as recordTestUsage, t as canProceedWithTest, u as setLimits } from "./usage-BBTGzjon.js";
+import { a as listAccountTokenPermissionGroups, i as listAccountOwnedAPITokens, n as deleteAccountOwnedAPIToken, o as normalizeDevflareTokenName, t as createAccountOwnedAPIToken } from "./tokens-iVcgNXi-.js";
+//#region src/cloudflare/account-status.ts
+const SERVICE_STATUS_TIMEOUT_MS = 1e4;
+const serviceInventoryFetchers = {
+	workers: listWorkers,
+	kv: listKVNamespaces,
+	d1: listD1Databases,
+	hyperdrive: listHyperdrives,
+	r2: listR2Buckets,
+	vectorize: listVectorizeIndexes,
+	ai: listAIModels
+};
+async function withServiceTimeout(operation) {
+	let timeoutId = null;
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("timeout")), SERVICE_STATUS_TIMEOUT_MS);
+	});
+	try {
+		return await Promise.race([operation, timeoutPromise]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+function createAvailableServiceStatus(service, count) {
+	return {
+		service,
+		available: service === "ai" ? count > 0 : true,
+		count
+	};
+}
+async function getServiceStatus(accountId, service) {
+	const fetchInventory = serviceInventoryFetchers[service];
+	if (!fetchInventory) return {
+		service,
+		available: false
+	};
+	try {
+		return createAvailableServiceStatus(service, (await withServiceTimeout(fetchInventory(accountId))).length);
+	} catch {
+		return {
+			service,
+			available: false
+		};
+	}
+}
+async function getAllServiceStatus(accountId) {
+	return Promise.all([
+		"workers",
+		"kv",
+		"d1",
+		"hyperdrive",
+		"r2",
+		"vectorize",
+		"ai"
+	].map((service) => getServiceStatus(accountId, service)));
+}
+async function hasService(accountId, service) {
+	return (await getServiceStatus(accountId, service)).available;
+}
+async function getAccountSummary(accountId) {
+	const account = await getAccountById(accountId);
+	if (!account) return null;
+	return {
+		account,
+		services: await getAllServiceStatus(accountId)
+	};
+}
+//#endregion
+//#region src/cloudflare/index.ts
+/**
+* Main account API object
+*
+* Usage:
+* ```ts
+* import { account } from 'devflare/cloudflare'
+*
+* // Check authentication
+* const isLoggedIn = await account.isAuthenticated()
+*
+* // Get primary account
+* const primary = await account.getPrimaryAccount()
+*
+* // List resources (requires accountId)
+* const workers = await account.workers(accountId)
+*
+* // Check usage limits before testing
+* const { allowed } = await account.canProceedWithTest(accountId, 'ai')
+* ```
+*/
+const account = {
+	isAuthenticated,
+	hasWranglerConfig,
+	getApiToken,
+	getWranglerAuth,
+	getAccounts,
+	getPrimaryAccount,
+	getAccountById,
+	getAccountSummary,
+	workers: listWorkers,
+	renameWorker,
+	deleteWorker,
+	workerVersions: listWorkerVersions,
+	workerVersion: getWorkerVersionDetail,
+	workerDeployments: listWorkerDeployments,
+	workersSubdomain: getWorkersSubdomain,
+	kv: listKVNamespaces,
+	d1: listD1Databases,
+	createD1Database,
+	queryD1Database,
+	rawD1DatabaseQuery,
+	r2: listR2Buckets,
+	vectorize: listVectorizeIndexes,
+	ai: listAIModels,
+	getServiceStatus,
+	getAllServiceStatus,
+	hasService,
+	getUsage,
+	recordUsage,
+	resetUsage,
+	getAllUsageSummaries,
+	getUsageSummary,
+	getLimits,
+	setLimits,
+	setLimitsEnabled,
+	isWithinLimits,
+	canProceedWithTest,
+	recordTestUsage,
+	shouldSkip,
+	getGlobalDefaultAccountId,
+	setGlobalDefaultAccountId,
+	getWorkspaceAccountId,
+	setWorkspaceAccountId,
+	getEffectiveAccountId,
+	clearGlobalDefaultAccountId,
+	listAccountTokenPermissionGroups,
+	listAccountOwnedAPITokens,
+	createAccountOwnedAPIToken,
+	deleteAccountOwnedAPIToken,
+	normalizeDevflareTokenName,
+	previewRegistryDatabase: DEVFLARE_PREVIEW_REGISTRY_DATABASE,
+	ensurePreviewRegistry,
+	getPreviewRegistryContext,
+	listTrackedPreviewRecords,
+	listTrackedRegistryState,
+	listTrackedPreviewScopeRecords,
+	listTrackedDeploymentRecords,
+	reconcilePreviewRegistry,
+	cleanupPreviewRegistry,
+	retirePreviewRegistry
+};
+//#endregion
+export { account as t };

package/dist/_chunks/colors-DiK6wPJ5.js

@@ -0,0 +1,13 @@
+//#region src/cli/colors.ts
+const BOLD = "\x1B[1m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+const CYAN = "\x1B[36m";
+const CYAN_BOLD = "\x1B[1;36m";
+const WHITE = "\x1B[97m";
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const BG_BLUE = "\x1B[44m";
+//#endregion
+export { DIM as a, RESET as c, CYAN_BOLD as i, WHITE as l, BOLD as n, GREEN as o, CYAN as r, RED as s, BG_BLUE as t, YELLOW as u };

package/dist/_chunks/command-utils-BsfkmTqh.js

@@ -0,0 +1,45 @@
+import { i as resolveConfigPath, r as loadConfig } from "./loader-DLXO60RO.js";
+import { d as getPrimaryAccount, i as getWorkspaceAccountId, n as getEffectiveAccountId } from "./preferences-BKp_7XJx.js";
+//#region src/cli/command-utils.ts
+function asOptionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveNamedSelection(options) {
+	if (options.explicitValue) return {
+		value: options.explicitValue,
+		source: "option"
+	};
+	if (options.fallbackValue) return {
+		value: options.fallbackValue,
+		source: "arg"
+	};
+	if (options.configuredValue) return {
+		value: options.configuredValue,
+		source: "config"
+	};
+	return {
+		value: void 0,
+		source: "none"
+	};
+}
+async function getConfiguredAccountId(cwd) {
+	const workspaceAccountId = getWorkspaceAccountId();
+	if (workspaceAccountId) return workspaceAccountId;
+	const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+	if (envAccountId) return envAccountId;
+	if (!await resolveConfigPath(cwd)) return;
+	try {
+		return (await loadConfig({ cwd })).accountId;
+	} catch {
+		return;
+	}
+}
+async function resolveCloudflareAccountId(options) {
+	if (options.explicitAccountId) return options.explicitAccountId;
+	if (options.configuredAccountId) return options.configuredAccountId;
+	const primaryAccount = await getPrimaryAccount(options.apiOptions);
+	if (!primaryAccount) return;
+	return (await getEffectiveAccountId(primaryAccount.id)).accountId;
+}
+//#endregion
+export { resolveNamedSelection as i, getConfiguredAccountId as n, resolveCloudflareAccountId as r, asOptionalString as t };

package/dist/_chunks/compiler-uoyAQ8zW.js

@@ -0,0 +1,424 @@
+import { f as normalizeCompatibilityFlags, u as resolveConfigForEnvironment } from "./loader-DLXO60RO.js";
+import { _ as browserBindingSchema, a as normalizeD1Binding, c as normalizeHyperdriveBinding, d as normalizeMediaBinding, f as normalizeMtlsCertificateBinding, h as normalizeWorkflowBinding, i as normalizeArtifactsBinding, l as normalizeImagesBinding, m as normalizeSecretsStoreBinding, o as normalizeDOBinding, p as normalizePipelineBinding, r as getSingleBrowserBindingName, s as normalizeDispatchNamespaceBinding, u as normalizeKVBinding } from "./schema-normalization-DWVleVxo.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);
+	if (normalized.databaseId) return {
+		binding: bindingName,
+		database_id: normalized.databaseId
+	};
+	if (options.preserveNamedBindings && normalized.name) return {
+		binding: bindingName,
+		database_name: normalized.name
+	};
+	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);
+	if (normalized.namespaceId) return {
+		binding: bindingName,
+		id: normalized.namespaceId
+	};
+	if (options.preserveNamedBindings && normalized.name) return {
+		binding: bindingName,
+		name: normalized.name
+	};
+	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, bucket_name]) => ({
+		binding,
+		bucket_name
+	}));
+	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, queue]) => ({
+			binding,
+			queue
+		}));
+		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 }
+		}));
+	}
+	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.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 }
+	}));
+	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 }
+	}));
+}
+//#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: true
+	};
+	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.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 }
+	}));
+	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 };