create-better-fullstack 2.0.0 → 2.0.2

package/dist/bts-config-Bg1Qea9Y.mjs

@@ -0,0 +1,737 @@
+#!/usr/bin/env node
+import { t as __reExport } from "./chunk-CCII7kTE.mjs";
+import fs from "fs-extra";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createCliDefaultProjectConfigBase } from "@better-fullstack/types";
+import * as JSONC from "jsonc-parser";
+
+//#region src/utils/get-package-manager.ts
+const getUserPkgManager = () => {
+	const userAgent = process.env.npm_config_user_agent;
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("yarn")) return "yarn";
+	return "npm";
+};
+
+//#endregion
+//#region src/constants.ts
+const __filename = fileURLToPath(import.meta.url);
+const distPath = path.dirname(__filename);
+const PKG_ROOT = path.join(distPath, "../");
+const DEFAULT_CONFIG_BASE = createCliDefaultProjectConfigBase(getUserPkgManager());
+function getDefaultConfig() {
+	return {
+		...DEFAULT_CONFIG_BASE,
+		projectDir: path.resolve(process.cwd(), DEFAULT_CONFIG_BASE.projectName),
+		packageManager: getUserPkgManager(),
+		frontend: [...DEFAULT_CONFIG_BASE.frontend],
+		addons: [...DEFAULT_CONFIG_BASE.addons],
+		examples: [...DEFAULT_CONFIG_BASE.examples],
+		rustLibraries: [...DEFAULT_CONFIG_BASE.rustLibraries],
+		pythonAi: [...DEFAULT_CONFIG_BASE.pythonAi],
+		javaLibraries: [...DEFAULT_CONFIG_BASE.javaLibraries],
+		javaTestingLibraries: [...DEFAULT_CONFIG_BASE.javaTestingLibraries],
+		aiDocs: [...DEFAULT_CONFIG_BASE.aiDocs]
+	};
+}
+const DEFAULT_CONFIG = getDefaultConfig();
+/**
+* Default UI library for each frontend framework
+* Falls back based on what's compatible
+*/
+const DEFAULT_UI_LIBRARY_BY_FRONTEND = {
+	"tanstack-router": "shadcn-ui",
+	"react-router": "shadcn-ui",
+	"react-vite": "shadcn-ui",
+	"tanstack-start": "shadcn-ui",
+	next: "shadcn-ui",
+	vinext: "shadcn-ui",
+	nuxt: "daisyui",
+	svelte: "daisyui",
+	solid: "daisyui",
+	"solid-start": "daisyui",
+	astro: "daisyui",
+	qwik: "daisyui",
+	angular: "daisyui",
+	redwood: "daisyui",
+	fresh: "daisyui",
+	"native-bare": "none",
+	"native-uniwind": "none",
+	"native-unistyles": "none",
+	none: "none"
+};
+
+//#endregion
+//#region src/utils/get-latest-cli-version.ts
+const getLatestCLIVersion = () => {
+	const packageJsonPath = path.join(PKG_ROOT, "package.json");
+	return fs.readJSONSync(packageJsonPath).version ?? "1.0.0";
+};
+
+//#endregion
+//#region src/types.ts
+var types_exports = {};
+import * as import__better_fullstack_types from "@better-fullstack/types";
+__reExport(types_exports, import__better_fullstack_types);
+
+//#endregion
+//#region src/utils/graph-summary.ts
+const FRONTEND_LABELS = {
+	next: "Next.js web app",
+	astro: "Astro web app",
+	"react-vite": "React + Vite app",
+	"react-router": "React Router app",
+	"tanstack-router": "TanStack Router app",
+	"tanstack-start": "TanStack Start app",
+	nuxt: "Nuxt app",
+	svelte: "SvelteKit app",
+	solid: "Solid app",
+	"solid-start": "SolidStart app",
+	qwik: "Qwik app",
+	angular: "Angular app",
+	redwood: "RedwoodJS app",
+	fresh: "Fresh app"
+};
+const BACKEND_LABELS = {
+	"rust:axum": "Rust Axum API",
+	"rust:actix-web": "Rust Actix Web API",
+	"rust:rocket": "Rust Rocket API",
+	"rust:warp": "Rust Warp API",
+	"rust:poem": "Rust Poem API",
+	"rust:salvo": "Rust Salvo API",
+	"python:fastapi": "Python FastAPI API",
+	"python:django": "Python Django API",
+	"python:flask": "Python Flask API",
+	"python:litestar": "Python Litestar API",
+	"go:gin": "Go Gin API",
+	"go:echo": "Go Echo API",
+	"go:fiber": "Go Fiber API",
+	"go:chi": "Go Chi API",
+	"java:spring-boot": "Java Spring Boot API",
+	"java:quarkus": "Java Quarkus API",
+	"elixir:phoenix": "Elixir Phoenix API",
+	"elixir:phoenix-live-view": "Elixir Phoenix LiveView API"
+};
+const TOOL_LABELS = {
+	postgres: "Postgres",
+	sqlite: "SQLite",
+	mysql: "MySQL",
+	mongodb: "MongoDB",
+	redis: "Redis",
+	edgedb: "EdgeDB",
+	gorm: "GORM",
+	sqlc: "sqlc",
+	ent: "Ent",
+	"ecto-sql": "Ecto SQL",
+	ecto: "Ecto",
+	sqlx: "SQLx",
+	"sea-orm": "SeaORM",
+	sqlalchemy: "SQLAlchemy",
+	sqlmodel: "SQLModel",
+	"django-orm": "Django ORM",
+	"spring-data-jpa": "Spring Data JPA"
+};
+function getSelectedGraphParts(config) {
+	return (config.stackParts ?? []).filter((part) => part.source !== "provided");
+}
+function getGraphPart(config, role, ecosystem) {
+	return getSelectedGraphParts(config).find((part) => part.role === role && (!ecosystem || part.ecosystem === ecosystem));
+}
+function hasGraphPart(config, role, ecosystem) {
+	return Boolean(getGraphPart(config, role, ecosystem));
+}
+function getPrimaryGraphPart(config, role, ecosystem) {
+	return getSelectedGraphParts(config).find((part) => part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+}
+function getGraphBackendUrl(config) {
+	switch (getPrimaryGraphPart(config, "backend")?.ecosystem) {
+		case "elixir": return "http://localhost:4000";
+		case "rust": return "http://localhost:3000";
+		case "python": return "http://localhost:8000";
+		case "go":
+		case "java": return "http://localhost:8080";
+		default: return null;
+	}
+}
+function getEffectiveStack(config) {
+	const effectiveStack = {};
+	const parts = getSelectedGraphParts(config);
+	const partsById = new Map(parts.map((part) => [part.id, part]));
+	for (const part of parts) {
+		const owner = part.ownerPartId ? partsById.get(part.ownerPartId) : void 0;
+		const key = owner ? `${owner.role}.${part.role}` : part.role;
+		effectiveStack[key] = `${part.ecosystem}:${part.toolId}`;
+	}
+	return effectiveStack;
+}
+function labelFor(part) {
+	if (!part) return null;
+	if (part.role === "frontend" && part.ecosystem === "typescript") return FRONTEND_LABELS[part.toolId] ?? `${part.toolId} web app`;
+	if (part.role === "backend") return BACKEND_LABELS[`${part.ecosystem}:${part.toolId}`] ?? `${part.ecosystem} ${part.toolId} API`;
+	return TOOL_LABELS[part.toolId] ?? part.toolId;
+}
+function getGraphSummary(config) {
+	const selectedParts = getSelectedGraphParts(config);
+	if (selectedParts.length === 0) return null;
+	const frontend = getPrimaryGraphPart(config, "frontend");
+	const backend = getPrimaryGraphPart(config, "backend");
+	const database = getPrimaryGraphPart(config, "database");
+	const orm = selectedParts.find((part) => part.role === "orm");
+	const segments = [labelFor(frontend), labelFor(backend)].filter(Boolean);
+	const databaseLabel = backend?.ecosystem === "java" && orm?.toolId === "spring-data-jpa" ? "H2 dev database" : labelFor(database);
+	const dataLabel = [labelFor(orm), databaseLabel].filter(Boolean).join("/");
+	if (dataLabel) segments.push(dataLabel);
+	return segments.length > 0 ? segments.join(" + ") : selectedParts.map((part) => (0, types_exports.formatStackPartSpec)(part, selectedParts)).join(" + ");
+}
+function getGraphBackendDeployInstructions(config) {
+	const backend = getPrimaryGraphPart(config, "backend");
+	if (!backend || config.serverDeploy === "none") return "";
+	const targetPath = backend.targetPath ?? "apps/server";
+	const backendLabel = labelFor(backend) ?? `${backend.ecosystem}:${backend.toolId}`;
+	switch (config.serverDeploy) {
+		case "railway": return [
+			"Server deployment with Railway:",
+			`* Backend: ${backendLabel}`,
+			`* Config: ${targetPath}/railway.toml`,
+			`* Deploy: cd ${targetPath} && railway up`
+		].join("\n");
+		case "docker": return [
+			"Server deployment with Docker:",
+			`* Backend: ${backendLabel}`,
+			`* Build: cd ${targetPath} && docker build -t better-fullstack-server .`
+		].join("\n");
+		case "fly": return [
+			"Server deployment with Fly:",
+			`* Backend: ${backendLabel}`,
+			`* Deploy: cd ${targetPath} && fly launch`
+		].join("\n");
+		case "vercel": return [
+			"Server deployment with Vercel:",
+			`* Backend: ${backendLabel}`,
+			`* Deploy from: ${targetPath}`
+		].join("\n");
+		case "netlify": return [
+			"Server deployment with Netlify Functions:",
+			`* Backend: ${backendLabel}`,
+			`* Config: ${targetPath}/netlify.toml`,
+			`* Functions: ${targetPath}/netlify/functions`
+		].join("\n");
+		case "cloudflare":
+		case "sst": return [
+			`Server deployment with ${config.serverDeploy}:`,
+			`* Backend: ${backendLabel}`,
+			`* Review generated files in ${targetPath}`
+		].join("\n");
+		default: return "";
+	}
+}
+
+//#endregion
+//#region src/utils/bts-config.ts
+const BTS_CONFIG_FILE = "bts.jsonc";
+function normalizeGraphConfigForPersistence(projectConfig, stackParts) {
+	if (!stackParts) return projectConfig;
+	const legacyConfig = (0, types_exports.stackPartsToLegacyProjectConfigPartial)(stackParts);
+	const selectedEcosystems = new Set(stackParts.filter((part) => part.source !== "provided").map((part) => part.ecosystem));
+	const normalized = {
+		...projectConfig,
+		...legacyConfig
+	};
+	if (!selectedEcosystems.has("rust")) {
+		normalized.rustWebFramework = "none";
+		normalized.rustFrontend = "none";
+		normalized.rustOrm = "none";
+		normalized.rustApi = "none";
+		normalized.rustCli = "none";
+		normalized.rustLibraries = [];
+		normalized.rustLogging = "none";
+		normalized.rustErrorHandling = "none";
+		normalized.rustCaching = "none";
+		normalized.rustAuth = "none";
+		normalized.rustRealtime = "none";
+		normalized.rustMessageQueue = "none";
+		normalized.rustObservability = "none";
+		normalized.rustTemplating = "none";
+	}
+	if (!selectedEcosystems.has("python")) {
+		normalized.pythonWebFramework = "none";
+		normalized.pythonOrm = "none";
+		normalized.pythonValidation = "none";
+		normalized.pythonAi = [];
+		normalized.pythonAuth = "none";
+		normalized.pythonApi = "none";
+		normalized.pythonTaskQueue = "none";
+		normalized.pythonGraphql = "none";
+		normalized.pythonQuality = "none";
+		normalized.pythonTesting = [];
+		normalized.pythonCaching = "none";
+		normalized.pythonRealtime = "none";
+		normalized.pythonObservability = "none";
+		normalized.pythonCli = [];
+	}
+	if (!selectedEcosystems.has("go")) {
+		normalized.goWebFramework = "none";
+		normalized.goOrm = "none";
+		normalized.goApi = "none";
+		normalized.goCli = "none";
+		normalized.goLogging = "none";
+		normalized.goAuth = "none";
+		normalized.goTesting = [];
+		normalized.goRealtime = "none";
+		normalized.goMessageQueue = "none";
+		normalized.goCaching = "none";
+		normalized.goConfig = "none";
+		normalized.goObservability = "none";
+	}
+	if (!selectedEcosystems.has("java")) {
+		normalized.javaWebFramework = "none";
+		normalized.javaBuildTool = "none";
+		normalized.javaOrm = "none";
+		normalized.javaAuth = "none";
+		normalized.javaApi = "none";
+		normalized.javaLogging = "none";
+		normalized.javaLibraries = [];
+		normalized.javaTestingLibraries = [];
+	}
+	if (!selectedEcosystems.has("dotnet")) {
+		normalized.dotnetWebFramework = "none";
+		normalized.dotnetOrm = "none";
+		normalized.dotnetAuth = "none";
+		normalized.dotnetApi = "none";
+		normalized.dotnetTesting = [];
+		normalized.dotnetJobQueue = "none";
+		normalized.dotnetRealtime = "none";
+		normalized.dotnetObservability = [];
+		normalized.dotnetValidation = "none";
+		normalized.dotnetCaching = "none";
+		normalized.dotnetDeploy = "none";
+	}
+	if (!selectedEcosystems.has("elixir")) {
+		normalized.elixirWebFramework = "none";
+		normalized.elixirOrm = "none";
+		normalized.elixirAuth = "none";
+		normalized.elixirApi = "none";
+		normalized.elixirRealtime = "none";
+		normalized.elixirJobs = "none";
+		normalized.elixirValidation = "none";
+		normalized.elixirHttp = "none";
+		normalized.elixirJson = "none";
+		normalized.elixirEmail = "none";
+		normalized.elixirCaching = "none";
+		normalized.elixirObservability = "none";
+		normalized.elixirTesting = "none";
+		normalized.elixirQuality = "none";
+		normalized.elixirDeploy = "none";
+		normalized.elixirLibraries = [];
+	}
+	if (!selectedEcosystems.has("react-native")) {
+		normalized.mobileNavigation = "none";
+		normalized.mobileUI = "none";
+		normalized.mobileStorage = "none";
+		normalized.mobileTesting = "none";
+		normalized.mobilePush = "none";
+		normalized.mobileOTA = "none";
+		normalized.mobileDeepLinking = "none";
+	}
+	return normalized;
+}
+function findSelectedPrimaryPart(stackParts, role, ecosystem) {
+	return stackParts.find((part) => part.source !== "provided" && part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+}
+function isAddonGraphPart(part) {
+	const binding = (0, types_exports.getAddonStackPartBinding)(part.toolId);
+	return binding !== void 0 && part.role === binding.role && part.ecosystem === binding.ecosystem;
+}
+function hasMatchingStackPart(stackParts, part) {
+	return stackParts.some((candidate) => candidate.source !== "provided" && candidate.role === part.role && candidate.ecosystem === part.ecosystem && candidate.toolId === part.toolId && candidate.ownerPartId === part.ownerPartId);
+}
+function syncAddonStackParts(stackParts, addons) {
+	const addonSet = new Set(addons.filter((addon) => addon !== "none"));
+	const frontend = findSelectedPrimaryPart(stackParts, "frontend", "typescript");
+	const next = stackParts.filter((part) => part.source === "provided" || !isAddonGraphPart(part) || addonSet.has(part.toolId));
+	for (const addon of addonSet) {
+		const binding = (0, types_exports.getAddonStackPartBinding)(addon);
+		if (!binding) continue;
+		const ownerPartId = binding.ownerRole === "frontend" ? frontend?.id : void 0;
+		if (binding.ownerRole === "frontend" && !ownerPartId) continue;
+		const part = (0, types_exports.createStackPart)({
+			role: binding.role,
+			ecosystem: binding.ecosystem,
+			toolId: addon,
+			ownerPartId,
+			source: "selected"
+		});
+		if (!hasMatchingStackPart(next, part)) next.push(part);
+	}
+	return next;
+}
+function syncOwnedDeployStackPart(stackParts, ownerRole, deployValue) {
+	if (deployValue === void 0) return [...stackParts];
+	const owner = findSelectedPrimaryPart(stackParts, ownerRole, "typescript");
+	const next = stackParts.filter((part) => part.source === "provided" || part.role !== "deploy" || part.ecosystem !== "typescript" || part.ownerPartId !== owner?.id);
+	if (!owner || deployValue === "none") return next;
+	next.push((0, types_exports.createStackPart)({
+		role: "deploy",
+		ecosystem: "typescript",
+		toolId: deployValue,
+		ownerPartId: owner.id,
+		source: "selected"
+	}));
+	return next;
+}
+function syncUpdatedStackParts(stackParts, updates) {
+	if (!stackParts) return void 0;
+	let next = [...stackParts];
+	if (updates.addons) next = syncAddonStackParts(next, updates.addons);
+	next = syncOwnedDeployStackPart(next, "frontend", updates.webDeploy);
+	next = syncOwnedDeployStackPart(next, "backend", updates.serverDeploy);
+	return next;
+}
+function buildBtsConfigForPersistence(projectConfig, metadata = {}) {
+	const stackParts = projectConfig.stackParts ?? (0, types_exports.legacyProjectConfigToStackParts)(projectConfig);
+	const persistedConfig = normalizeGraphConfigForPersistence(projectConfig, stackParts);
+	const graphSummary = stackParts.length > 0 ? getGraphSummary({ stackParts }) : null;
+	const effectiveStack = stackParts.length > 0 ? getEffectiveStack({ stackParts }) : void 0;
+	return {
+		version: metadata.version ?? getLatestCLIVersion(),
+		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		...graphSummary ? {
+			graphSummary,
+			effectiveStack
+		} : {},
+		ecosystem: persistedConfig.ecosystem,
+		database: persistedConfig.database,
+		orm: persistedConfig.orm,
+		backend: persistedConfig.backend,
+		runtime: persistedConfig.runtime,
+		frontend: persistedConfig.frontend,
+		addons: persistedConfig.addons,
+		examples: persistedConfig.examples,
+		auth: persistedConfig.auth,
+		payments: persistedConfig.payments,
+		email: persistedConfig.email,
+		fileUpload: persistedConfig.fileUpload,
+		effect: persistedConfig.effect,
+		ai: persistedConfig.ai,
+		stateManagement: persistedConfig.stateManagement,
+		validation: persistedConfig.validation,
+		forms: persistedConfig.forms,
+		testing: persistedConfig.testing,
+		packageManager: persistedConfig.packageManager,
+		versionChannel: persistedConfig.versionChannel,
+		dbSetup: persistedConfig.dbSetup,
+		api: persistedConfig.api,
+		webDeploy: persistedConfig.webDeploy,
+		serverDeploy: persistedConfig.serverDeploy,
+		cssFramework: persistedConfig.cssFramework,
+		uiLibrary: persistedConfig.uiLibrary,
+		realtime: persistedConfig.realtime,
+		jobQueue: persistedConfig.jobQueue,
+		animation: persistedConfig.animation,
+		logging: persistedConfig.logging,
+		observability: persistedConfig.observability,
+		featureFlags: persistedConfig.featureFlags,
+		analytics: persistedConfig.analytics,
+		mobileNavigation: persistedConfig.mobileNavigation,
+		mobileUI: persistedConfig.mobileUI,
+		mobileStorage: persistedConfig.mobileStorage,
+		mobileTesting: persistedConfig.mobileTesting,
+		mobilePush: persistedConfig.mobilePush,
+		mobileOTA: persistedConfig.mobileOTA,
+		mobileDeepLinking: persistedConfig.mobileDeepLinking,
+		cms: persistedConfig.cms,
+		caching: persistedConfig.caching,
+		rateLimit: persistedConfig.rateLimit,
+		i18n: persistedConfig.i18n,
+		search: persistedConfig.search,
+		fileStorage: persistedConfig.fileStorage,
+		rustWebFramework: persistedConfig.rustWebFramework,
+		rustFrontend: persistedConfig.rustFrontend,
+		rustOrm: persistedConfig.rustOrm,
+		rustApi: persistedConfig.rustApi,
+		rustCli: persistedConfig.rustCli,
+		rustLibraries: persistedConfig.rustLibraries,
+		rustLogging: persistedConfig.rustLogging,
+		rustErrorHandling: persistedConfig.rustErrorHandling,
+		rustCaching: persistedConfig.rustCaching,
+		rustAuth: persistedConfig.rustAuth,
+		rustRealtime: persistedConfig.rustRealtime,
+		rustMessageQueue: persistedConfig.rustMessageQueue,
+		rustObservability: persistedConfig.rustObservability,
+		rustTemplating: persistedConfig.rustTemplating,
+		pythonWebFramework: persistedConfig.pythonWebFramework,
+		pythonOrm: persistedConfig.pythonOrm,
+		pythonValidation: persistedConfig.pythonValidation,
+		pythonAi: persistedConfig.pythonAi,
+		pythonAuth: persistedConfig.pythonAuth,
+		pythonApi: persistedConfig.pythonApi,
+		pythonTaskQueue: persistedConfig.pythonTaskQueue,
+		pythonGraphql: persistedConfig.pythonGraphql,
+		pythonQuality: persistedConfig.pythonQuality,
+		pythonTesting: persistedConfig.pythonTesting,
+		pythonCaching: persistedConfig.pythonCaching,
+		pythonRealtime: persistedConfig.pythonRealtime,
+		pythonObservability: persistedConfig.pythonObservability,
+		pythonCli: persistedConfig.pythonCli,
+		goWebFramework: persistedConfig.goWebFramework,
+		goOrm: persistedConfig.goOrm,
+		goApi: persistedConfig.goApi,
+		goCli: persistedConfig.goCli,
+		goLogging: persistedConfig.goLogging,
+		goAuth: persistedConfig.goAuth,
+		goTesting: persistedConfig.goTesting,
+		goRealtime: persistedConfig.goRealtime,
+		goMessageQueue: persistedConfig.goMessageQueue,
+		goCaching: persistedConfig.goCaching,
+		goConfig: persistedConfig.goConfig,
+		goObservability: persistedConfig.goObservability,
+		javaWebFramework: persistedConfig.javaWebFramework,
+		javaBuildTool: persistedConfig.javaBuildTool,
+		javaOrm: persistedConfig.javaOrm,
+		javaAuth: persistedConfig.javaAuth,
+		javaApi: persistedConfig.javaApi,
+		javaLogging: persistedConfig.javaLogging,
+		javaLibraries: persistedConfig.javaLibraries,
+		javaTestingLibraries: persistedConfig.javaTestingLibraries,
+		dotnetWebFramework: persistedConfig.dotnetWebFramework,
+		dotnetOrm: persistedConfig.dotnetOrm,
+		dotnetAuth: persistedConfig.dotnetAuth,
+		dotnetApi: persistedConfig.dotnetApi,
+		dotnetTesting: persistedConfig.dotnetTesting,
+		dotnetJobQueue: persistedConfig.dotnetJobQueue,
+		dotnetRealtime: persistedConfig.dotnetRealtime,
+		dotnetObservability: persistedConfig.dotnetObservability,
+		dotnetValidation: persistedConfig.dotnetValidation,
+		dotnetCaching: persistedConfig.dotnetCaching,
+		dotnetDeploy: persistedConfig.dotnetDeploy,
+		elixirWebFramework: persistedConfig.elixirWebFramework,
+		elixirOrm: persistedConfig.elixirOrm,
+		elixirAuth: persistedConfig.elixirAuth,
+		elixirApi: persistedConfig.elixirApi,
+		elixirRealtime: persistedConfig.elixirRealtime,
+		elixirJobs: persistedConfig.elixirJobs,
+		elixirValidation: persistedConfig.elixirValidation,
+		elixirHttp: persistedConfig.elixirHttp,
+		elixirJson: persistedConfig.elixirJson,
+		elixirEmail: persistedConfig.elixirEmail,
+		elixirCaching: persistedConfig.elixirCaching,
+		elixirObservability: persistedConfig.elixirObservability,
+		elixirTesting: persistedConfig.elixirTesting,
+		elixirQuality: persistedConfig.elixirQuality,
+		elixirDeploy: persistedConfig.elixirDeploy,
+		elixirLibraries: persistedConfig.elixirLibraries,
+		aiDocs: persistedConfig.aiDocs,
+		stackParts
+	};
+}
+function previewBtsConfigUpdate(currentConfig, updates) {
+	const updatedStackParts = syncUpdatedStackParts(currentConfig.stackParts, updates);
+	return buildBtsConfigForPersistence({
+		...currentConfig,
+		...updates,
+		...updatedStackParts ? { stackParts: updatedStackParts } : {}
+	}, {
+		version: currentConfig.version,
+		createdAt: currentConfig.createdAt
+	});
+}
+async function writeBtsConfig(projectConfig) {
+	const btsConfig = buildBtsConfigForPersistence(projectConfig);
+	const baseContent = {
+		$schema: "https://better-fullstack-web.vercel.app/schema.json",
+		version: btsConfig.version,
+		createdAt: btsConfig.createdAt,
+		...btsConfig.graphSummary ? {
+			graphSummary: btsConfig.graphSummary,
+			effectiveStack: btsConfig.effectiveStack
+		} : {},
+		ecosystem: btsConfig.ecosystem,
+		database: btsConfig.database,
+		orm: btsConfig.orm,
+		backend: btsConfig.backend,
+		runtime: btsConfig.runtime,
+		frontend: btsConfig.frontend,
+		addons: btsConfig.addons,
+		examples: btsConfig.examples,
+		auth: btsConfig.auth,
+		payments: btsConfig.payments,
+		email: btsConfig.email,
+		fileUpload: btsConfig.fileUpload,
+		effect: btsConfig.effect,
+		ai: btsConfig.ai,
+		stateManagement: btsConfig.stateManagement,
+		validation: btsConfig.validation,
+		forms: btsConfig.forms,
+		testing: btsConfig.testing,
+		packageManager: btsConfig.packageManager,
+		versionChannel: btsConfig.versionChannel,
+		dbSetup: btsConfig.dbSetup,
+		api: btsConfig.api,
+		webDeploy: btsConfig.webDeploy,
+		serverDeploy: btsConfig.serverDeploy,
+		cssFramework: btsConfig.cssFramework,
+		uiLibrary: btsConfig.uiLibrary,
+		realtime: btsConfig.realtime,
+		jobQueue: btsConfig.jobQueue,
+		animation: btsConfig.animation,
+		logging: btsConfig.logging,
+		observability: btsConfig.observability,
+		featureFlags: btsConfig.featureFlags,
+		analytics: btsConfig.analytics,
+		mobileNavigation: btsConfig.mobileNavigation,
+		mobileUI: btsConfig.mobileUI,
+		mobileStorage: btsConfig.mobileStorage,
+		mobileTesting: btsConfig.mobileTesting,
+		mobilePush: btsConfig.mobilePush,
+		mobileOTA: btsConfig.mobileOTA,
+		mobileDeepLinking: btsConfig.mobileDeepLinking,
+		cms: btsConfig.cms,
+		caching: btsConfig.caching,
+		rateLimit: btsConfig.rateLimit,
+		i18n: btsConfig.i18n,
+		search: btsConfig.search,
+		fileStorage: btsConfig.fileStorage,
+		rustWebFramework: btsConfig.rustWebFramework,
+		rustFrontend: btsConfig.rustFrontend,
+		rustOrm: btsConfig.rustOrm,
+		rustApi: btsConfig.rustApi,
+		rustCli: btsConfig.rustCli,
+		rustLibraries: btsConfig.rustLibraries,
+		rustLogging: btsConfig.rustLogging,
+		rustErrorHandling: btsConfig.rustErrorHandling,
+		rustCaching: btsConfig.rustCaching,
+		rustAuth: btsConfig.rustAuth,
+		rustRealtime: btsConfig.rustRealtime,
+		rustMessageQueue: btsConfig.rustMessageQueue,
+		rustObservability: btsConfig.rustObservability,
+		rustTemplating: btsConfig.rustTemplating,
+		pythonWebFramework: btsConfig.pythonWebFramework,
+		pythonOrm: btsConfig.pythonOrm,
+		pythonValidation: btsConfig.pythonValidation,
+		pythonAi: btsConfig.pythonAi,
+		pythonAuth: btsConfig.pythonAuth,
+		pythonApi: btsConfig.pythonApi ?? "none",
+		pythonTaskQueue: btsConfig.pythonTaskQueue,
+		pythonGraphql: btsConfig.pythonGraphql,
+		pythonQuality: btsConfig.pythonQuality,
+		pythonTesting: btsConfig.pythonTesting,
+		pythonCaching: btsConfig.pythonCaching,
+		pythonRealtime: btsConfig.pythonRealtime,
+		pythonObservability: btsConfig.pythonObservability,
+		pythonCli: btsConfig.pythonCli,
+		goWebFramework: btsConfig.goWebFramework,
+		goOrm: btsConfig.goOrm,
+		goApi: btsConfig.goApi,
+		goCli: btsConfig.goCli,
+		goLogging: btsConfig.goLogging,
+		goAuth: btsConfig.goAuth,
+		goTesting: btsConfig.goTesting,
+		goRealtime: btsConfig.goRealtime,
+		goMessageQueue: btsConfig.goMessageQueue,
+		goCaching: btsConfig.goCaching,
+		goConfig: btsConfig.goConfig,
+		goObservability: btsConfig.goObservability,
+		javaWebFramework: btsConfig.javaWebFramework,
+		javaBuildTool: btsConfig.javaBuildTool,
+		javaOrm: btsConfig.javaOrm,
+		javaAuth: btsConfig.javaAuth,
+		javaApi: btsConfig.javaApi,
+		javaLogging: btsConfig.javaLogging,
+		javaLibraries: btsConfig.javaLibraries,
+		javaTestingLibraries: btsConfig.javaTestingLibraries,
+		dotnetWebFramework: btsConfig.dotnetWebFramework,
+		dotnetOrm: btsConfig.dotnetOrm,
+		dotnetAuth: btsConfig.dotnetAuth,
+		dotnetApi: btsConfig.dotnetApi,
+		dotnetTesting: btsConfig.dotnetTesting,
+		dotnetJobQueue: btsConfig.dotnetJobQueue,
+		dotnetRealtime: btsConfig.dotnetRealtime,
+		dotnetObservability: btsConfig.dotnetObservability,
+		dotnetValidation: btsConfig.dotnetValidation,
+		dotnetCaching: btsConfig.dotnetCaching,
+		dotnetDeploy: btsConfig.dotnetDeploy,
+		elixirWebFramework: btsConfig.elixirWebFramework,
+		elixirOrm: btsConfig.elixirOrm,
+		elixirAuth: btsConfig.elixirAuth,
+		elixirApi: btsConfig.elixirApi,
+		elixirRealtime: btsConfig.elixirRealtime,
+		elixirJobs: btsConfig.elixirJobs,
+		elixirValidation: btsConfig.elixirValidation,
+		elixirHttp: btsConfig.elixirHttp,
+		elixirJson: btsConfig.elixirJson,
+		elixirEmail: btsConfig.elixirEmail,
+		elixirCaching: btsConfig.elixirCaching,
+		elixirObservability: btsConfig.elixirObservability,
+		elixirTesting: btsConfig.elixirTesting,
+		elixirQuality: btsConfig.elixirQuality,
+		elixirDeploy: btsConfig.elixirDeploy,
+		elixirLibraries: btsConfig.elixirLibraries,
+		aiDocs: btsConfig.aiDocs,
+		stackParts: btsConfig.stackParts
+	};
+	let configContent = JSON.stringify(baseContent);
+	const formatResult = JSONC.format(configContent, void 0, {
+		tabSize: 2,
+		insertSpaces: true,
+		eol: "\n"
+	});
+	configContent = JSONC.applyEdits(configContent, formatResult);
+	const finalContent = `// Better Fullstack configuration file
+// safe to delete
+${btsConfig.stackParts?.length ? "// stackParts is the source of truth; graphSummary/effectiveStack summarize it for humans and tools.\n// Top-level option fields are a derived compatibility cache for older integrations.\n" : ""}
+
+${configContent}`;
+	const configPath = path.join(projectConfig.projectDir, BTS_CONFIG_FILE);
+	await fs.writeFile(configPath, finalContent, "utf-8");
+}
+async function readBtsConfig(projectDir) {
+	try {
+		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return null;
+		const configContent = await fs.readFile(configPath, "utf-8");
+		const errors = [];
+		const config = JSONC.parse(configContent, errors, {
+			allowTrailingComma: true,
+			disallowComments: false
+		});
+		if (errors.length > 0) {
+			console.warn("Warning: Found errors parsing bts.jsonc:", errors);
+			return null;
+		}
+		return buildBtsConfigForPersistence(config, {
+			version: config.version,
+			createdAt: config.createdAt
+		});
+	} catch {
+		return null;
+	}
+}
+async function updateBtsConfig(projectDir, updates) {
+	try {
+		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return;
+		const configContent = await fs.readFile(configPath, "utf-8");
+		const errors = [];
+		const currentConfig = JSONC.parse(configContent, errors, {
+			allowTrailingComma: true,
+			disallowComments: false
+		});
+		let modifiedContent = configContent;
+		const nextConfig = errors.length === 0 ? previewBtsConfigUpdate(currentConfig, updates) : void 0;
+		const persistedUpdates = nextConfig ? Object.fromEntries(Object.entries(nextConfig).filter(([key]) => key !== "version" && key !== "createdAt")) : updates;
+		for (const [key, value] of Object.entries(persistedUpdates)) {
+			const editResult = JSONC.modify(modifiedContent, [key], value, { formattingOptions: {
+				tabSize: 2,
+				insertSpaces: true,
+				eol: "\n"
+			} });
+			modifiedContent = JSONC.applyEdits(modifiedContent, editResult);
+		}
+		await fs.writeFile(configPath, modifiedContent, "utf-8");
+	} catch {}
+}
+
+//#endregion
+export { getUserPkgManager as _, getEffectiveStack as a, getGraphPart as c, hasGraphPart as d, types_exports as f, getDefaultConfig as g, DEFAULT_UI_LIBRARY_BY_FRONTEND as h, writeBtsConfig as i, getGraphSummary as l, DEFAULT_CONFIG as m, readBtsConfig as n, getGraphBackendDeployInstructions as o, getLatestCLIVersion as p, updateBtsConfig as r, getGraphBackendUrl as s, previewBtsConfigUpdate as t, getPrimaryGraphPart as u };