create-better-fullstack 2.1.2 → 2.1.4

package/dist/{config-validation-C4glouQh.mjs → file-formatter-B3dsev2l.mjs}

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
-import { A as types_exports, c as isSilent, i as exitWithError, k as hasGraphPart } from "./errors-D9yiiGVq.mjs";
-import { C as validateWebDeployFrontendTemplates, D as incompatibilityError, E as constraintError, O as missingRequirementError, S as validateUILibraryFrontendCompatibility, T as validateWorkersCompatibility, _ as validateExamplesCompatibility, b as validateServerDeployRequiresBackend, g as validateApiFrontendCompatibility, h as validateAddonsAgainstFrontends, n as ensureSingleWebAndNative, p as validateAIFrontendCompatibility, u as isWebFrontend, v as validatePaymentsCompatibility, w as validateWebDeployRequiresWebFrontend, x as validateUILibraryCSSFrameworkCompatibility, y as validateSelfBackendCompatibility } from "./compatibility-rules-D7zYNVjC.mjs";
+import { A as types_exports, c as isSilent, i as exitWithError, t as CLIError } from "./errors-Cyol8zbN.mjs";
 import pc from "picocolors";
 import z from "zod";
+import fs from "fs-extra";
+import path from "node:path";
+import { allowedApisForFrontends, getAIFrontendCompatibilityIssue, getApiFrontendCompatibilityIssue, getCompatibleAddons, getCompatibleCSSFrameworks, getCompatibleUILibraries, getUnsupportedWebDeployFrontend, hasDockerComposeCompatibleFrontend, hasWebStyling, isBackendUtilsCompatibleBackend, isExampleAIAllowed, isExampleChatSdkAllowed, isFrontendAllowedWithBackend, isWebFrontend, requiresChatSdkVercelAIForSelection, splitFrontends, validateAddonCompatibility } from "@better-fullstack/types";
 import consola from "consola";
+import { format } from "oxfmt";
 
 //#region src/create-command-input.ts
 const CreateCommandOptionsSchema = z.object({
@@ -157,488 +160,368 @@ const CreateCommandOptionsSchema = z.object({
 const CreateCommandInputSchema = z.tuple([types_exports.ProjectNameSchema.optional(), CreateCommandOptionsSchema]);
 
 //#endregion
-//#region src/utils/generate-reproducible-command.ts
-function getBaseCommand(packageManager) {
-	switch (packageManager) {
-		case "bun": return "bun create better-fullstack@latest";
-		case "pnpm": return "pnpm create better-fullstack@latest";
-		case "yarn": return "yarn create better-fullstack@latest";
-		case "npm":
-		default: return "npx create-better-fullstack@latest";
+//#region src/utils/error-formatter.ts
+function getCategoryTitle(category) {
+	return {
+		incompatibility: "Incompatible Options",
+		"invalid-selection": "Invalid Selection",
+		"missing-requirement": "Missing Requirement",
+		constraint: "Constraint Violation"
+	}[category];
+}
+function displayStructuredError(error) {
+	if (isSilent()) throw new CLIError(error.message);
+	const lines = [];
+	lines.push(pc.bold(pc.red(getCategoryTitle(error.category))));
+	lines.push("");
+	lines.push(error.message);
+	if (error.provided && Object.keys(error.provided).length > 0) {
+		lines.push("");
+		lines.push(pc.dim("You provided:"));
+		for (const [key, value] of Object.entries(error.provided)) {
+			const displayValue = Array.isArray(value) ? value.join(", ") : value;
+			lines.push(`  ${pc.cyan("--" + key)} ${displayValue}`);
+		}
+	}
+	if (error.suggestions.length > 0) {
+		lines.push("");
+		lines.push(pc.dim("Suggestions:"));
+		for (const suggestion of error.suggestions) lines.push(`  ${pc.green("•")} ${suggestion}`);
 	}
+	consola.box({
+		title: pc.red("Error"),
+		message: lines.join("\n"),
+		style: { borderColor: "red" }
+	});
+	process.exit(1);
 }
-function formatArrayFlag(flag, values) {
-	const normalizedValues = values.filter((value) => value !== "none");
-	if (normalizedValues.length === 0) return `--${flag} none`;
-	return `--${flag} ${normalizedValues.join(" ")}`;
+function incompatibilityError(opts) {
+	return displayStructuredError({
+		category: "incompatibility",
+		...opts
+	});
 }
-function appendCommonFlags(flags, config) {
-	if (config.aiDocs && config.aiDocs.length > 0) flags.push(formatArrayFlag("ai-docs", config.aiDocs));
-	else flags.push("--ai-docs none");
-	flags.push(config.git ? "--git" : "--no-git");
-	flags.push(`--package-manager ${config.packageManager}`);
-	if (config.versionChannel !== "stable") flags.push(`--version-channel ${config.versionChannel}`);
-	flags.push(config.install ? "--install" : "--no-install");
+function invalidSelectionError(opts) {
+	return displayStructuredError({
+		category: "invalid-selection",
+		...opts
+	});
 }
-function hasGraphPrimaryPart(config, role, ecosystem) {
-	return config.stackParts?.some((part) => part.source !== "provided" && part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+function missingRequirementError(opts) {
+	return displayStructuredError({
+		category: "missing-requirement",
+		...opts
+	});
 }
-function hasOwnedGraphPart(config, ownerRole, role, ecosystem, toolId) {
-	const owner = config.stackParts?.find((part) => part.source !== "provided" && part.role === ownerRole && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
-	if (!owner) return false;
-	return Boolean(config.stackParts?.some((part) => part.source !== "provided" && part.role === role && part.ownerPartId === owner.id && (!ecosystem || part.ecosystem === ecosystem) && (!toolId || part.toolId === toolId)));
+function constraintError(opts) {
+	return displayStructuredError({
+		category: "constraint",
+		...opts
+	});
 }
-function hasGraphAddonPart(config, addon) {
-	const binding = (0, types_exports.getAddonStackPartBinding)(addon);
-	if (!binding) return false;
-	if (!binding.ownerRole) return Boolean(config.stackParts?.some((part) => part.source !== "provided" && part.role === binding.role && part.ecosystem === binding.ecosystem && part.toolId === addon && !part.ownerPartId));
-	const owner = config.stackParts?.find((part) => part.source !== "provided" && part.role === binding.ownerRole && !part.ownerPartId && part.ecosystem === binding.ecosystem);
-	if (!owner) return false;
-	return Boolean(config.stackParts?.some((part) => part.source !== "provided" && part.role === binding.role && part.ecosystem === binding.ecosystem && part.toolId === addon && part.ownerPartId === owner.id));
+
+//#endregion
+//#region src/utils/compatibility-rules.ts
+function isWebFrontend$1(value) {
+	return isWebFrontend(value);
 }
-function hasGraphExamplePart(config, example) {
-	return Boolean(config.stackParts?.some((part) => part.source !== "provided" && part.role === "examples" && part.ecosystem === "universal" && part.toolId === example && !part.ownerPartId));
+function splitFrontends$1(values = []) {
+	return splitFrontends(values);
 }
-function hasGraphArrayParts(config, values, hasPart) {
-	const normalizedValues = values.filter((value) => value !== "none");
-	return normalizedValues.length > 0 && normalizedValues.every((value) => hasPart(config, value));
+function ensureSingleWebAndNative(frontends) {
+	const { web, native } = splitFrontends$1(frontends);
+	if (web.length > 1) invalidSelectionError({
+		message: "Only one web framework can be selected per project.",
+		provided: { frontend: web },
+		suggestions: ["Keep one web framework and remove the others", "Use separate projects for multiple web frameworks"]
+	});
+	if (native.length > 1) invalidSelectionError({
+		message: "Only one native framework can be selected per project.",
+		provided: { frontend: native },
+		suggestions: ["Keep one native framework and remove the others", "Choose: native-bare, native-uniwind, or native-unistyles"]
+	});
 }
-function appendChangedStringFlag(flags, flag, value, defaultValue) {
-	if (value !== defaultValue) flags.push(`--${flag} ${value}`);
+const FULLSTACK_FRONTENDS = [
+	"next",
+	"vinext",
+	"tanstack-start",
+	"astro",
+	"nuxt",
+	"svelte",
+	"solid-start"
+];
+function validateSelfBackendCompatibility(providedFlags, options, config) {
+	const backend = config.backend || options.backend;
+	const frontends = config.frontend || options.frontend || [];
+	if (backend === "self") {
+		const { web, native } = splitFrontends$1(frontends);
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS.includes(web[0]))) exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, or --frontend solid-start.");
+		if (native.length > 1) exitWithError("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
+	}
+	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS.includes(f));
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, --frontend solid-start, or choose a different backend.");
 }
-function appendChangedGraphStringFlag(flags, config, role, ecosystem, flag, value, defaultValue) {
-	if (hasGraphPart(config, role, ecosystem)) return;
-	appendChangedStringFlag(flags, flag, value, defaultValue);
+const WORKERS_COMPATIBLE_BACKENDS = [
+	"hono",
+	"nitro",
+	"fets"
+];
+function validateWorkersCompatibility(providedFlags, options, config) {
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend)) incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently supported only with compatible backends (Hono, Nitro, or Fets).",
+		provided: {
+			runtime: "workers",
+			backend: config.backend
+		},
+		suggestions: [
+			"Use --backend hono",
+			"Use --backend nitro",
+			"Use --backend fets",
+			"Choose a different runtime (node, bun)"
+		]
+	});
+	if (providedFlags.has("backend") && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend) && config.runtime === "workers") incompatibilityError({
+		message: `In Better-Fullstack, backend '${config.backend}' is currently not available with Cloudflare Workers runtime.`,
+		provided: {
+			backend: config.backend,
+			runtime: "workers"
+		},
+		suggestions: ["Use --backend hono, --backend nitro, or --backend fets", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.database === "mongodb") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with MongoDB.",
+		provided: {
+			runtime: "workers",
+			database: "mongodb"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.dbSetup === "docker") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with Docker database setup.",
+		provided: {
+			runtime: "workers",
+			"db-setup": "docker"
+		},
+		suggestions: ["Use --db-setup d1 for SQLite", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") incompatibilityError({
+		message: "In Better-Fullstack, MongoDB is currently not available with Cloudflare Workers runtime.",
+		provided: {
+			database: "mongodb",
+			runtime: "workers"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
 }
-function appendChangedOwnedGraphStringFlag(flags, config, ownerRole, role, ecosystem, flag, value, defaultValue) {
-	if (hasOwnedGraphPart(config, ownerRole, role, ecosystem, value)) return;
-	appendChangedStringFlag(flags, flag, value, defaultValue);
+function validateApiFrontendCompatibility(api, frontends = [], astroIntegration) {
+	const issue = getApiFrontendCompatibilityIssue(api, frontends, astroIntegration);
+	if (!issue) return;
+	incompatibilityError({
+		message: issue.message,
+		provided: issue.provided ?? {},
+		suggestions: issue.suggestions ?? []
+	});
 }
-function hasOwnedGraphArrayParts(config, ownerRole, role, ecosystem, values) {
-	const normalizedValues = values.filter((value) => value !== "none");
-	if (normalizedValues.length === 0) return false;
-	return normalizedValues.every((value) => hasOwnedGraphPart(config, ownerRole, role, ecosystem, value));
+function isFrontendAllowedWithBackend$1(frontend, backend, auth) {
+	return isFrontendAllowedWithBackend(frontend, backend, auth);
 }
-function appendChangedOwnedGraphArrayFlag(flags, config, ownerRole, role, ecosystem, flag, values, defaultValues) {
-	if (hasOwnedGraphArrayParts(config, ownerRole, role, ecosystem, values)) return;
-	appendChangedArrayFlag(flags, flag, values, defaultValues);
+function allowedApisForFrontends$1(frontends = [], astroIntegration) {
+	return allowedApisForFrontends(frontends, astroIntegration);
 }
-function appendChangedArrayFlag(flags, flag, values, defaultValues) {
-	if (values.length !== defaultValues.length || values.some((value, index) => value !== defaultValues[index])) flags.push(formatArrayFlag(flag, values));
+function isExampleAIAllowed$1(backend, frontends = []) {
+	return isExampleAIAllowed(backend, frontends);
 }
-function appendAstroIntegrationFlag(flags, config) {
-	if (config.frontend.includes("astro") && config.astroIntegration !== "none") flags.push(`--astro-integration ${config.astroIntegration}`);
+function isExampleChatSdkAllowed$1(backend, frontends = [], runtime) {
+	return isExampleChatSdkAllowed(backend, frontends, runtime);
 }
-function appendGraphExtraFlags(flags, config) {
-	if (!hasGraphArrayParts(config, config.addons, hasGraphAddonPart)) appendChangedArrayFlag(flags, "addons", config.addons, ["turborepo"]);
-	if (!hasGraphArrayParts(config, config.examples, hasGraphExamplePart)) appendChangedArrayFlag(flags, "examples", config.examples, []);
-	if (hasGraphPrimaryPart(config, "database")) appendChangedOwnedGraphStringFlag(flags, config, "database", "dbSetup", "universal", "db-setup", config.dbSetup, "none");
-	else appendChangedStringFlag(flags, "db-setup", config.dbSetup, "none");
-	if (hasGraphPrimaryPart(config, "frontend", "typescript")) {
-		appendAstroIntegrationFlag(flags, config);
-		appendChangedOwnedGraphStringFlag(flags, config, "frontend", "deploy", "typescript", "web-deploy", config.webDeploy, "none");
-		appendChangedGraphStringFlag(flags, config, "css", "typescript", "css-framework", config.cssFramework, "tailwind");
-		appendChangedGraphStringFlag(flags, config, "ui", "typescript", "ui-library", config.uiLibrary, "shadcn-ui");
-		if (config.uiLibrary === "shadcn-ui") {
-			appendChangedStringFlag(flags, "shadcn-base", config.shadcnBase ?? "radix", "radix");
-			appendChangedStringFlag(flags, "shadcn-style", config.shadcnStyle ?? "nova", "nova");
-			appendChangedStringFlag(flags, "shadcn-icon-library", config.shadcnIconLibrary ?? "lucide", "lucide");
-			appendChangedStringFlag(flags, "shadcn-color-theme", config.shadcnColorTheme ?? "neutral", "neutral");
-			appendChangedStringFlag(flags, "shadcn-base-color", config.shadcnBaseColor ?? "neutral", "neutral");
-			appendChangedStringFlag(flags, "shadcn-font", config.shadcnFont ?? "inter", "inter");
-			appendChangedStringFlag(flags, "shadcn-radius", config.shadcnRadius ?? "default", "default");
-		}
-		appendChangedGraphStringFlag(flags, config, "stateManagement", "typescript", "state-management", config.stateManagement, "none");
-		appendChangedGraphStringFlag(flags, config, "forms", "typescript", "forms", config.forms, "react-hook-form");
-		appendChangedStringFlag(flags, "validation", config.validation, "zod");
-		appendChangedStringFlag(flags, "testing", config.testing, "vitest");
-		appendChangedGraphStringFlag(flags, config, "animation", "typescript", "animation", config.animation, "none");
-		appendChangedGraphStringFlag(flags, config, "fileUpload", "typescript", "file-upload", config.fileUpload, "none");
-		appendChangedGraphStringFlag(flags, config, "i18n", "typescript", "i18n", config.i18n, "none");
-		appendChangedGraphStringFlag(flags, config, "analytics", "typescript", "analytics", config.analytics, "none");
-	}
-	if (hasGraphPrimaryPart(config, "frontend", "typescript") || hasGraphPrimaryPart(config, "backend", "typescript")) {
-		if (hasGraphPrimaryPart(config, "backend", "typescript")) {
-			appendChangedOwnedGraphStringFlag(flags, config, "backend", "runtime", "typescript", "runtime", config.runtime, "bun");
-			appendChangedOwnedGraphStringFlag(flags, config, "backend", "deploy", "typescript", "server-deploy", config.serverDeploy, "none");
-		} else appendChangedStringFlag(flags, "server-deploy", config.serverDeploy, "none");
-		appendChangedGraphStringFlag(flags, config, "payments", "typescript", "payments", config.payments, "none");
-		appendChangedGraphStringFlag(flags, config, "email", "typescript", "email", config.email, "none");
-		appendChangedStringFlag(flags, "effect", config.effect, "none");
-		appendChangedGraphStringFlag(flags, config, "ai", "typescript", "ai", config.ai, "none");
-		appendChangedGraphStringFlag(flags, config, "realtime", "typescript", "realtime", config.realtime, "none");
-		appendChangedGraphStringFlag(flags, config, "jobQueue", "typescript", "job-queue", config.jobQueue, "none");
-		appendChangedGraphStringFlag(flags, config, "logging", "typescript", "logging", config.logging, "none");
-		appendChangedGraphStringFlag(flags, config, "observability", "typescript", "observability", config.observability, "none");
-		appendChangedGraphStringFlag(flags, config, "featureFlags", "typescript", "feature-flags", config.featureFlags, "none");
-		appendChangedGraphStringFlag(flags, config, "caching", "typescript", "caching", config.caching, "none");
-		appendChangedGraphStringFlag(flags, config, "rateLimit", "typescript", "rate-limit", config.rateLimit, "none");
-		appendChangedGraphStringFlag(flags, config, "cms", "typescript", "cms", config.cms, "none");
-		appendChangedGraphStringFlag(flags, config, "search", "typescript", "search", config.search, "none");
-		appendChangedGraphStringFlag(flags, config, "vectorDb", "typescript", "vectorDb", config.vectorDb, "none");
-		appendChangedGraphStringFlag(flags, config, "fileStorage", "typescript", "file-storage", config.fileStorage, "none");
+function requiresChatSdkVercelAI(backend, frontends = [], runtime) {
+	return requiresChatSdkVercelAIForSelection(backend, frontends, runtime);
+}
+function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
+	if (webDeploy && webDeploy !== "none" && !hasWebFrontendFlag) exitWithError("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
+}
+function validateWebDeployFrontendTemplates(webDeploy, frontends = []) {
+	const blocked = getUnsupportedWebDeployFrontend(webDeploy, frontends);
+	if (blocked) exitWithError(`${webDeploy === "render" ? "Render" : "Netlify"} deployment is not yet wired up for the '${blocked}' frontend. Choose a different web deploy target or frontend.`);
+}
+function validateServerDeployRequiresBackend(serverDeploy, backend, hasGraphBackend = false) {
+	if (serverDeploy && serverDeploy !== "none" && !hasGraphBackend && (!backend || backend === "none")) exitWithError("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
+}
+function validateAddonCompatibility$1(addon, frontend, _auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	const baseCompatibility = validateAddonCompatibility(addon, frontend, _auth);
+	if (!baseCompatibility.isCompatible) return baseCompatibility;
+	if (addon === "backend-utils") {
+		if (ecosystem !== void 0 && ecosystem !== "typescript") return {
+			isCompatible: false,
+			reason: "Backend Utils requires a TypeScript server stack"
+		};
+		if (backend !== void 0 && !isBackendUtilsCompatibleBackend(backend)) return {
+			isCompatible: false,
+			reason: "Backend Utils requires a Hono, Express, Fastify, Elysia, feTS, or NestJS backend"
+		};
 	}
-	if (hasGraphPrimaryPart(config, "mobile")) {
-		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "navigation", "react-native", "mobile-navigation", config.mobileNavigation, "expo-router");
-		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "ui", "react-native", "mobile-ui", config.mobileUI, "none");
-		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "storage", "react-native", "mobile-storage", config.mobileStorage, "none");
-		appendChangedOwnedGraphStringFlag(flags, config, "mobile", "testing", "react-native", "mobile-testing", config.mobileTesting, "none");
-		appendChangedStringFlag(flags, "mobile-push", config.mobilePush, "none");
-		appendChangedStringFlag(flags, "mobile-ota", config.mobileOTA, "none");
-		appendChangedStringFlag(flags, "mobile-deep-linking", config.mobileDeepLinking, "none");
+	if (addon === "docker-compose" || addon === "devcontainer") {
+		const label = addon === "devcontainer" ? "DevContainer" : "docker-compose";
+		const title = addon === "devcontainer" ? "DevContainer" : "Docker Compose";
+		if (backend === "convex") return {
+			isCompatible: false,
+			reason: `${label} is not compatible with Convex backend (managed service)`
+		};
+		if (runtime === "workers") return {
+			isCompatible: false,
+			reason: `${label} is not compatible with Cloudflare Workers runtime`
+		};
+		if (ecosystem !== void 0 && ![
+			"typescript",
+			"python",
+			"go",
+			"rust",
+			"java"
+		].includes(ecosystem)) return {
+			isCompatible: false,
+			reason: `${title} currently supports TypeScript, Python, Go, Rust, or Java projects`
+		};
+		if (ecosystem === "typescript" && !hasDockerComposeCompatibleFrontend(frontend)) return {
+			isCompatible: false,
+			reason: `${title} currently supports Next.js, Vinext, TanStack Router, React Router, React Vite, Solid, or Astro`
+		};
+		if (ecosystem === "typescript" && backend === "self" && !frontend.includes("next") && !frontend.includes("vinext")) return {
+			isCompatible: false,
+			reason: `${title} self-backend support currently requires Next.js or Vinext`
+		};
+		if (ecosystem === "rust" && rustFrontend && rustFrontend !== "none") return {
+			isCompatible: false,
+			reason: `${title} for Rust currently supports server-only projects`
+		};
+		if (ecosystem === "java" && javaWebFramework && javaWebFramework !== "spring-boot") return {
+			isCompatible: false,
+			reason: `${title} for Java currently requires Spring Boot`
+		};
+		if (ecosystem === "python" && database && database !== "none" && database !== "sqlite" && database !== "postgres") return {
+			isCompatible: false,
+			reason: `${title} for Python ORM projects currently supports SQLite defaults or Postgres`
+		};
 	}
-	if (hasGraphPrimaryPart(config, "frontend", "rust")) appendChangedStringFlag(flags, "rust-frontend", config.rustFrontend, "none");
-	if (hasGraphPrimaryPart(config, "backend", "rust")) {
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "cli", "rust", "rust-cli", config.rustCli, "none");
-		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "libraries", "rust", "rust-libraries", config.rustLibraries, []);
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "logging", "rust", "rust-logging", config.rustLogging, "tracing");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "errorHandling", "rust", "rust-error-handling", config.rustErrorHandling, "anyhow-thiserror");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "caching", "rust", "rust-caching", config.rustCaching, "none");
+	return { isCompatible: true };
+}
+function getCompatibleAddons$1(allAddons, frontend, existingAddons = [], auth, backend, runtime) {
+	return getCompatibleAddons(allAddons, frontend, existingAddons, auth).filter((addon) => {
+		const { isCompatible } = validateAddonCompatibility$1(addon, frontend, auth, backend, runtime);
+		return isCompatible;
+	});
+}
+function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	if (addons.includes("nx") && addons.includes("turborepo")) exitWithError("Nx and Turborepo are alternative workspace runners. Choose one addon.");
+	for (const addon of addons) {
+		if (addon === "none") continue;
+		const { isCompatible, reason } = validateAddonCompatibility$1(addon, frontends, auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database);
+		if (!isCompatible) exitWithError(`Incompatible addon/frontend combination: ${reason}`);
 	}
-	if (hasGraphPrimaryPart(config, "backend", "python")) {
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "validation", "python", "python-validation", config.pythonValidation, "none");
-		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "ai", "python", "python-ai", config.pythonAi, []);
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "jobQueue", "python", "python-task-queue", config.pythonTaskQueue, "none");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "api", "python", "python-graphql", config.pythonGraphql, "none");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "codeQuality", "python", "python-quality", config.pythonQuality, "none");
+}
+function validatePaymentsCompatibility(payments, auth, _backend, frontends = []) {
+	if (!payments || payments === "none") return;
+	if (payments === "dodo" && frontends.includes("react-vite")) exitWithError("Dodo Payments are not yet supported for React + Vite projects.");
+	if (payments === "polar") {
+		if (!auth || auth === "none" || auth !== "better-auth" && auth !== "better-auth-organizations") exitWithError("Polar payments requires Better Auth. Please use '--auth better-auth' or choose a different payments provider.");
+		const { web } = splitFrontends$1(frontends);
+		if (web.length === 0 && frontends.length > 0) exitWithError("Polar payments requires a web frontend or no frontend. Please select a web frontend or choose a different payments provider.");
 	}
-	if (hasGraphPrimaryPart(config, "backend", "go")) {
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "cli", "go", "go-cli", config.goCli, "none");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "logging", "go", "go-logging", config.goLogging, "none");
+}
+function validateExamplesCompatibility(examples, backend, frontend, runtime, ai) {
+	const examplesArr = examples ?? [];
+	if (examplesArr.length === 0 || examplesArr.includes("none")) return;
+	if (examplesArr.includes("tanstack-showcase")) {
+		const showcaseFrontends = ["tanstack-router", "tanstack-start"];
+		if (!(frontend ?? []).some((f) => showcaseFrontends.includes(f))) exitWithError("The 'tanstack-showcase' example requires TanStack Router or TanStack Start frontend.");
 	}
-	if (hasGraphPrimaryPart(config, "backend", "java")) {
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "buildTool", "java", "java-build-tool", config.javaBuildTool, "maven");
-		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "libraries", "java", "java-libraries", config.javaLibraries, []);
-		appendChangedOwnedGraphArrayFlag(flags, config, "backend", "testing", "java", "java-testing-libraries", config.javaTestingLibraries, ["junit5"]);
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid-start")) exitWithError("The 'ai' example is not compatible with the SolidStart frontend.");
+	if (examplesArr.includes("ai") && backend === "convex") {
+		const frontendArr = frontend ?? [];
+		const includesNuxt = frontendArr.includes("nuxt");
+		const includesSvelte = frontendArr.includes("svelte");
+		if (includesNuxt || includesSvelte) exitWithError("The 'ai' example with Convex backend only supports React-based frontends (Next.js, TanStack Router, TanStack Start, React Router, React + Vite). Svelte and Nuxt are not supported with Convex AI.");
 	}
-	if (hasGraphPrimaryPart(config, "backend", "elixir")) {
-		appendChangedGraphStringFlag(flags, config, "realtime", "elixir", "elixir-realtime", config.elixirRealtime, "channels");
-		appendChangedGraphStringFlag(flags, config, "jobQueue", "elixir", "elixir-jobs", config.elixirJobs, "none");
-		appendChangedGraphStringFlag(flags, config, "validation", "elixir", "elixir-validation", config.elixirValidation, "ecto-changesets");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "httpClient", "elixir", "elixir-http", config.elixirHttp, "req");
-		appendChangedStringFlag(flags, "elixir-json", config.elixirJson, "jason");
-		appendChangedGraphStringFlag(flags, config, "email", "elixir", "elixir-email", config.elixirEmail, "none");
-		appendChangedGraphStringFlag(flags, config, "caching", "elixir", "elixir-caching", config.elixirCaching, "none");
-		appendChangedGraphStringFlag(flags, config, "observability", "elixir", "elixir-observability", config.elixirObservability, "telemetry");
-		appendChangedGraphStringFlag(flags, config, "testing", "elixir", "elixir-testing", config.elixirTesting, "ex_unit");
-		appendChangedOwnedGraphStringFlag(flags, config, "backend", "codeQuality", "elixir", "elixir-quality", config.elixirQuality, "credo");
-		appendChangedGraphStringFlag(flags, config, "deploy", "elixir", "elixir-deploy", config.elixirDeploy, "none");
+	if (examplesArr.includes("chat-sdk")) {
+		const frontendArr = frontend ?? [];
+		if (frontendArr.includes("react-vite")) exitWithError("The 'chat-sdk' example is not yet supported for React + Vite projects.");
+		if (!isExampleChatSdkAllowed$1(backend, frontendArr, runtime)) {
+			if (backend === "none") exitWithError("The 'chat-sdk' example requires a backend.");
+			if (backend === "convex") exitWithError("The 'chat-sdk' example is not supported with the Convex backend in v1. Use self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime.");
+			if (backend === "self") exitWithError("The 'chat-sdk' example with self backend only supports Next.js, TanStack Start, or Nuxt frontends in v1.");
+			if (backend === "hono" && runtime !== "node") exitWithError("The 'chat-sdk' example with Hono requires '--runtime node' in v1 (Bun/Workers not supported yet).");
+			exitWithError("The 'chat-sdk' example is only supported with self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime in v1.");
+		}
+		if (requiresChatSdkVercelAI(backend, frontendArr, runtime) && ai && ai !== "vercel-ai") exitWithError("The 'chat-sdk' example requires '--ai vercel-ai' for the selected stack in v1 (Nuxt Discord and Hono GitHub profiles).");
 	}
 }
-function appendSharedNonTypeScriptFlags(flags, config) {
-	flags.push(`--email ${config.email}`);
-	flags.push(`--observability ${config.observability}`);
-	flags.push(`--caching ${config.caching}`);
-	flags.push(`--search ${config.search}`);
-	flags.push(formatArrayFlag("addons", config.addons));
-	flags.push(formatArrayFlag("examples", config.examples));
-	flags.push(`--db-setup ${config.dbSetup}`);
-	flags.push(`--web-deploy ${config.webDeploy}`);
-	flags.push(`--server-deploy ${config.serverDeploy}`);
+/**
+* Validates that TanStack AI is only used with compatible frontends (React or Solid).
+* Server-side @tanstack/ai core works anywhere, but client adapters only exist for React and Solid.
+*/
+function validateAIFrontendCompatibility(ai, frontends = []) {
+	const issue = getAIFrontendCompatibilityIssue(ai, frontends);
+	if (!issue) return;
+	exitWithError(issue.message);
 }
-function getTypeScriptFlags(config) {
-	const flags = [];
-	if (config.frontend && config.frontend.length > 0) flags.push(`--frontend ${config.frontend.join(" ")}`);
-	else flags.push("--frontend none");
-	appendAstroIntegrationFlag(flags, config);
-	flags.push(`--backend ${config.backend}`);
-	flags.push(`--runtime ${config.runtime}`);
-	flags.push(`--database ${config.database}`);
-	flags.push(`--orm ${config.orm}`);
-	flags.push(`--api ${config.api}`);
-	flags.push(`--auth ${config.auth}`);
-	flags.push(`--payments ${config.payments}`);
-	flags.push(`--email ${config.email}`);
-	flags.push(`--file-upload ${config.fileUpload}`);
-	flags.push(`--effect ${config.effect}`);
-	flags.push(`--css-framework ${config.cssFramework}`);
-	flags.push(`--ui-library ${config.uiLibrary}`);
-	if (config.uiLibrary === "shadcn-ui") {
-		flags.push(`--shadcn-base ${config.shadcnBase}`);
-		flags.push(`--shadcn-style ${config.shadcnStyle}`);
-		flags.push(`--shadcn-icon-library ${config.shadcnIconLibrary}`);
-		flags.push(`--shadcn-color-theme ${config.shadcnColorTheme}`);
-		flags.push(`--shadcn-base-color ${config.shadcnBaseColor}`);
-		flags.push(`--shadcn-font ${config.shadcnFont}`);
-		flags.push(`--shadcn-radius ${config.shadcnRadius}`);
+/**
+* Validates that a UI library is compatible with the selected frontend(s)
+*/
+function validateUILibraryFrontendCompatibility(uiLibrary, frontends = [], astroIntegration) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	const { web } = splitFrontends$1(frontends);
+	if (web.length === 0) return;
+	const compatible = getCompatibleUILibraries(frontends, astroIntegration);
+	if (!compatible.includes(uiLibrary)) {
+		const isAstroNonReact = web.includes("astro") && astroIntegration !== "react";
+		const supportsAstroReact = getCompatibleUILibraries(["astro"], "react").includes(uiLibrary);
+		if (isAstroNonReact && supportsAstroReact) {
+			incompatibilityError({
+				message: `UI library '${uiLibrary}' requires React.`,
+				provided: {
+					"ui-library": uiLibrary,
+					"astro-integration": astroIntegration || "none"
+				},
+				suggestions: ["Use --astro-integration react", "Choose a different UI library (daisyui, ark-ui)"]
+			});
+			return;
+		}
+		incompatibilityError({
+			message: `UI library '${uiLibrary}' is not compatible with the selected frontend.`,
+			provided: {
+				"ui-library": uiLibrary,
+				frontend: frontends
+			},
+			suggestions: [`Supported choices for this stack: ${compatible.join(", ")}`, "Choose a different UI library"]
+		});
 	}
-	flags.push(`--ai ${config.ai}`);
-	flags.push(`--state-management ${config.stateManagement}`);
-	flags.push(`--forms ${config.forms}`);
-	flags.push(`--validation ${config.validation}`);
-	flags.push(`--testing ${config.testing}`);
-	flags.push(`--animation ${config.animation}`);
-	flags.push(`--realtime ${config.realtime}`);
-	flags.push(`--job-queue ${config.jobQueue}`);
-	flags.push(`--logging ${config.logging}`);
-	flags.push(`--observability ${config.observability}`);
-	flags.push(`--feature-flags ${config.featureFlags}`);
-	flags.push(`--caching ${config.caching}`);
-	flags.push(`--rate-limit ${config.rateLimit}`);
-	flags.push(`--i18n ${config.i18n}`);
-	flags.push(`--cms ${config.cms}`);
-	flags.push(`--search ${config.search}`);
-	flags.push(`--vector-db ${config.vectorDb}`);
-	flags.push(`--file-storage ${config.fileStorage}`);
-	flags.push(`--mobile-navigation ${config.mobileNavigation}`);
-	flags.push(`--mobile-ui ${config.mobileUI}`);
-	flags.push(`--mobile-storage ${config.mobileStorage}`);
-	flags.push(`--mobile-testing ${config.mobileTesting}`);
-	flags.push(`--mobile-push ${config.mobilePush}`);
-	flags.push(`--mobile-ota ${config.mobileOTA}`);
-	flags.push(`--mobile-deep-linking ${config.mobileDeepLinking}`);
-	if (config.addons && config.addons.length > 0) flags.push(`--addons ${config.addons.join(" ")}`);
-	else flags.push("--addons none");
-	if (config.examples && config.examples.length > 0) flags.push(`--examples ${config.examples.join(" ")}`);
-	else flags.push("--examples none");
-	flags.push(`--db-setup ${config.dbSetup}`);
-	flags.push(`--web-deploy ${config.webDeploy}`);
-	flags.push(`--server-deploy ${config.serverDeploy}`);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getReactNativeFlags(config) {
-	const flags = ["--ecosystem react-native"];
-	if (config.frontend && config.frontend.length > 0) flags.push(`--frontend ${config.frontend.join(" ")}`);
-	else flags.push("--frontend native-bare");
-	flags.push(`--auth ${config.auth}`);
-	flags.push(`--mobile-navigation ${config.mobileNavigation}`);
-	flags.push(`--mobile-ui ${config.mobileUI}`);
-	flags.push(`--mobile-storage ${config.mobileStorage}`);
-	flags.push(`--mobile-testing ${config.mobileTesting}`);
-	flags.push(`--mobile-push ${config.mobilePush}`);
-	flags.push(`--mobile-ota ${config.mobileOTA}`);
-	flags.push(`--mobile-deep-linking ${config.mobileDeepLinking}`);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getRustFlags(config) {
-	const flags = ["--ecosystem rust"];
-	flags.push(`--rust-web-framework ${config.rustWebFramework}`);
-	flags.push(`--rust-frontend ${config.rustFrontend}`);
-	flags.push(`--rust-orm ${config.rustOrm}`);
-	flags.push(`--rust-api ${config.rustApi}`);
-	flags.push(`--rust-cli ${config.rustCli}`);
-	flags.push(formatArrayFlag("rust-libraries", config.rustLibraries));
-	flags.push(`--rust-logging ${config.rustLogging}`);
-	flags.push(`--rust-error-handling ${config.rustErrorHandling}`);
-	flags.push(`--rust-caching ${config.rustCaching}`);
-	flags.push(`--rust-auth ${config.rustAuth}`);
-	flags.push(`--rust-realtime ${config.rustRealtime}`);
-	flags.push(`--rust-message-queue ${config.rustMessageQueue}`);
-	flags.push(`--rust-observability ${config.rustObservability}`);
-	flags.push(`--rust-templating ${config.rustTemplating}`);
-	appendSharedNonTypeScriptFlags(flags, config);
-	appendCommonFlags(flags, config);
-	return flags;
 }
-function getPythonFlags(config) {
-	const flags = ["--ecosystem python"];
-	flags.push(`--python-web-framework ${config.pythonWebFramework}`);
-	flags.push(`--python-orm ${config.pythonOrm}`);
-	flags.push(`--python-validation ${config.pythonValidation}`);
-	flags.push(formatArrayFlag("python-ai", config.pythonAi));
-	flags.push(`--python-auth ${config.pythonAuth}`);
-	flags.push(`--python-api ${config.pythonApi}`);
-	flags.push(`--python-task-queue ${config.pythonTaskQueue}`);
-	flags.push(`--python-graphql ${config.pythonGraphql}`);
-	flags.push(`--python-quality ${config.pythonQuality}`);
-	flags.push(formatArrayFlag("python-testing", config.pythonTesting));
-	flags.push(`--python-caching ${config.pythonCaching}`);
-	flags.push(`--python-realtime ${config.pythonRealtime}`);
-	flags.push(`--python-observability ${config.pythonObservability}`);
-	flags.push(formatArrayFlag("python-cli", config.pythonCli));
-	appendSharedNonTypeScriptFlags(flags, config);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getGoFlags(config) {
-	const flags = ["--ecosystem go"];
-	flags.push(`--go-web-framework ${config.goWebFramework}`);
-	flags.push(`--go-orm ${config.goOrm}`);
-	flags.push(`--go-api ${config.goApi}`);
-	flags.push(`--go-cli ${config.goCli}`);
-	flags.push(`--go-logging ${config.goLogging}`);
-	flags.push(`--go-auth ${config.goAuth}`);
-	flags.push(formatArrayFlag("go-testing", config.goTesting));
-	flags.push(`--go-realtime ${config.goRealtime}`);
-	flags.push(`--go-message-queue ${config.goMessageQueue}`);
-	flags.push(`--go-caching ${config.goCaching}`);
-	flags.push(`--go-config ${config.goConfig}`);
-	flags.push(`--go-observability ${config.goObservability}`);
-	flags.push(`--auth ${config.auth}`);
-	appendSharedNonTypeScriptFlags(flags, config);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getJavaFlags(config) {
-	const flags = ["--ecosystem java"];
-	flags.push(`--java-web-framework ${config.javaWebFramework}`);
-	flags.push(`--java-build-tool ${config.javaBuildTool}`);
-	flags.push(`--java-orm ${config.javaOrm}`);
-	flags.push(`--java-auth ${config.javaAuth}`);
-	flags.push(`--java-api ${config.javaApi}`);
-	flags.push(`--java-logging ${config.javaLogging}`);
-	flags.push(formatArrayFlag("java-libraries", config.javaLibraries));
-	flags.push(formatArrayFlag("java-testing-libraries", config.javaTestingLibraries));
-	appendSharedNonTypeScriptFlags(flags, config);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getDotnetFlags(config) {
-	const flags = ["--ecosystem dotnet"];
-	flags.push(`--dotnet-web-framework ${config.dotnetWebFramework}`);
-	flags.push(`--dotnet-orm ${config.dotnetOrm}`);
-	flags.push(`--dotnet-auth ${config.dotnetAuth}`);
-	flags.push(`--dotnet-api ${config.dotnetApi}`);
-	flags.push(formatArrayFlag("dotnet-testing", config.dotnetTesting));
-	flags.push(`--dotnet-job-queue ${config.dotnetJobQueue}`);
-	flags.push(`--dotnet-realtime ${config.dotnetRealtime}`);
-	flags.push(formatArrayFlag("dotnet-observability", config.dotnetObservability));
-	flags.push(`--dotnet-validation ${config.dotnetValidation}`);
-	flags.push(`--dotnet-caching ${config.dotnetCaching}`);
-	flags.push(`--dotnet-deploy ${config.dotnetDeploy}`);
-	appendCommonFlags(flags, config);
-	return flags;
-}
-function getElixirFlags(config) {
-	const flags = ["--ecosystem elixir"];
-	flags.push(`--elixir-web-framework ${config.elixirWebFramework}`);
-	flags.push(`--elixir-orm ${config.elixirOrm}`);
-	flags.push(`--elixir-auth ${config.elixirAuth}`);
-	flags.push(`--elixir-api ${config.elixirApi}`);
-	flags.push(`--elixir-realtime ${config.elixirRealtime}`);
-	flags.push(`--elixir-jobs ${config.elixirJobs}`);
-	flags.push(`--elixir-validation ${config.elixirValidation}`);
-	flags.push(`--elixir-http ${config.elixirHttp}`);
-	flags.push(`--elixir-json ${config.elixirJson}`);
-	flags.push(`--elixir-email ${config.elixirEmail}`);
-	flags.push(`--elixir-caching ${config.elixirCaching}`);
-	flags.push(`--elixir-observability ${config.elixirObservability}`);
-	flags.push(`--elixir-testing ${config.elixirTesting}`);
-	flags.push(`--elixir-quality ${config.elixirQuality}`);
-	flags.push(`--elixir-deploy ${config.elixirDeploy}`);
-	flags.push(formatArrayFlag("elixir-libraries", config.elixirLibraries));
-	appendCommonFlags(flags, config);
-	return flags;
+/**
+* Validates that a UI library is compatible with the selected CSS framework
+*/
+function validateUILibraryCSSFrameworkCompatibility(uiLibrary, cssFramework) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	if (!cssFramework) return;
+	const supported = getCompatibleCSSFrameworks(uiLibrary);
+	if (!supported.includes(cssFramework)) exitWithError(`UI library '${uiLibrary}' is not compatible with '${cssFramework}' CSS framework. Supported CSS frameworks: ${supported.join(", ")}`);
 }
-function generateReproducibleCommand(config) {
-	let flags;
-	if (config.stackParts && config.stackParts.length > 0) {
-		flags = config.stackParts.filter((part) => part.source !== "provided").map((part) => `--part ${(0, types_exports.formatStackPartSpec)(part, config.stackParts ?? [])}`);
-		appendGraphExtraFlags(flags, config);
-		appendCommonFlags(flags, config);
-		return `${getBaseCommand(config.packageManager)}${config.relativePath ? ` ${config.relativePath}` : ""} ${flags.join(" ")}`;
-	}
-	switch (config.ecosystem) {
-		case "react-native":
-			flags = getReactNativeFlags(config);
-			break;
-		case "rust":
-			flags = getRustFlags(config);
-			break;
-		case "python":
-			flags = getPythonFlags(config);
-			break;
-		case "go":
-			flags = getGoFlags(config);
-			break;
-		case "java":
-			flags = getJavaFlags(config);
-			break;
-		case "dotnet":
-			flags = getDotnetFlags(config);
-			break;
-		case "elixir":
-			flags = getElixirFlags(config);
-			break;
-		case "typescript":
-		default:
-			flags = getTypeScriptFlags(config);
-			break;
-	}
-	return `${getBaseCommand(config.packageManager)}${config.relativePath ? ` ${config.relativePath}` : ""} ${flags.join(" ")}`;
+/**
+* Gets list of UI libraries compatible with the selected frontend(s)
+*/
+function getCompatibleUILibraries$1(frontends = [], astroIntegration) {
+	return getCompatibleUILibraries(frontends, astroIntegration);
 }
-
-//#endregion
-//#region src/utils/templates.ts
-const TEMPLATE_PRESETS = {
-	mern: {
-		database: "mongodb",
-		orm: "mongoose",
-		backend: "express",
-		runtime: "node",
-		frontend: ["react-router"],
-		api: "orpc",
-		auth: "better-auth",
-		payments: "none",
-		addons: ["turborepo"],
-		examples: ["none"],
-		dbSetup: "mongodb-atlas",
-		webDeploy: "none",
-		serverDeploy: "none"
-	},
-	pern: {
-		database: "postgres",
-		orm: "drizzle",
-		backend: "express",
-		runtime: "node",
-		frontend: ["tanstack-router"],
-		api: "trpc",
-		auth: "better-auth",
-		payments: "none",
-		addons: ["turborepo"],
-		examples: ["none"],
-		dbSetup: "none",
-		webDeploy: "none",
-		serverDeploy: "none"
-	},
-	t3: {
-		database: "postgres",
-		orm: "prisma",
-		backend: "self",
-		runtime: "none",
-		frontend: ["next"],
-		api: "trpc",
-		auth: "better-auth",
-		payments: "none",
-		addons: ["biome", "turborepo"],
-		examples: ["none"],
-		dbSetup: "none",
-		webDeploy: "none",
-		serverDeploy: "none"
-	},
-	uniwind: {
-		database: "none",
-		orm: "none",
-		backend: "none",
-		runtime: "none",
-		frontend: ["native-uniwind"],
-		api: "none",
-		auth: "none",
-		payments: "none",
-		addons: ["none"],
-		examples: ["none"],
-		dbSetup: "none",
-		webDeploy: "none",
-		serverDeploy: "none"
-	},
-	none: null
-};
-function getTemplateConfig(template) {
-	if (template === "none" || !template) return null;
-	const config = TEMPLATE_PRESETS[template];
-	if (!config) throw new Error(`Unknown template: ${template}`);
-	return config;
+/**
+* Gets list of CSS frameworks compatible with the selected UI library
+*/
+function getCompatibleCSSFrameworks$1(uiLibrary) {
+	return getCompatibleCSSFrameworks(uiLibrary);
 }
-function getTemplateDescription(template) {
-	return {
-		mern: "MongoDB + Express + React + Node.js - Classic MERN stack",
-		pern: "PostgreSQL + Express + React + Node.js - Popular PERN stack",
-		t3: "T3 Stack - Next.js + tRPC + Prisma + PostgreSQL + Better Auth",
-		uniwind: "Expo + Uniwind native app with no backend services",
-		none: "No template - Full customization"
-	}[template] || "";
+/**
+* Checks if a frontend has web styling (excludes native-only frontends)
+*/
+function hasWebStyling$1(frontends = []) {
+	return hasWebStyling(frontends);
 }
 
 //#endregion
@@ -1110,7 +993,7 @@ function validateFrontendConstraints(config, providedFlags) {
 		ensureSingleWebAndNative(frontend);
 		if (providedFlags.has("api") && providedFlags.has("frontend") && config.api) validateApiFrontendCompatibility(config.api, frontend, config.astroIntegration);
 	}
-	const hasWebFrontendFlag = (frontend ?? []).some((f) => isWebFrontend(f));
+	const hasWebFrontendFlag = (frontend ?? []).some((f) => isWebFrontend$1(f));
 	validateWebDeployRequiresWebFrontend(config.webDeploy, hasWebFrontendFlag);
 	validateWebDeployFrontendTemplates(config.webDeploy, frontend);
 }
@@ -1509,4 +1392,37 @@ function validateConfigForProgrammaticUse(config) {
 }
 
 //#endregion
-export { generateReproducibleCommand as a, getTemplateDescription as i, validateFullConfig as n, CreateCommandInputSchema as o, getTemplateConfig as r, CreateCommandOptionsSchema as s, validateConfigForProgrammaticUse as t };
+//#region src/utils/file-formatter.ts
+const formatOptions = {
+	experimentalSortPackageJson: true,
+	experimentalSortImports: { order: "asc" }
+};
+async function formatCode(filePath, content) {
+	try {
+		const result = await format(path.basename(filePath), content, formatOptions);
+		if (result.errors && result.errors.length > 0) return null;
+		return result.code;
+	} catch {
+		return null;
+	}
+}
+async function formatProject(projectDir) {
+	async function formatDirectory(dir) {
+		const denoConfigPath = path.join(dir, "deno.json");
+		if (await fs.pathExists(denoConfigPath)) return;
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		await Promise.all(entries.map(async (entry) => {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) await formatDirectory(fullPath);
+			else if (entry.isFile()) try {
+				const content = await fs.readFile(fullPath, "utf-8");
+				const formatted = await formatCode(fullPath, content);
+				if (formatted && formatted !== content) await fs.writeFile(fullPath, formatted, "utf-8");
+			} catch {}
+		}));
+	}
+	await formatDirectory(projectDir);
+}
+
+//#endregion
+export { CreateCommandInputSchema as _, allowedApisForFrontends$1 as a, getCompatibleUILibraries$1 as c, isExampleChatSdkAllowed$1 as d, isFrontendAllowedWithBackend$1 as f, validateAddonCompatibility$1 as g, splitFrontends$1 as h, validateFullConfig as i, hasWebStyling$1 as l, requiresChatSdkVercelAI as m, formatProject as n, getCompatibleAddons$1 as o, isWebFrontend$1 as p, validateConfigForProgrammaticUse as r, getCompatibleCSSFrameworks$1 as s, formatCode as t, isExampleAIAllowed$1 as u, CreateCommandOptionsSchema as v };