create-better-fullstack 2.0.3 → 2.1.1

package/dist/config-validation-C4glouQh.mjs

@@ -0,0 +1,1512 @@
+#!/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 pc from "picocolors";
+import z from "zod";
+import consola from "consola";
+
+//#region src/create-command-input.ts
+const CreateCommandOptionsSchema = z.object({
+	template: types_exports.TemplateSchema.optional().describe("Use a predefined template"),
+	fromHistory: z.number().optional().describe("Replay the stack of the Nth most-recent project from history (1 = most recent)"),
+	config: z.string().optional().describe("Path to a bts.jsonc/JSON config file to use as the base stack"),
+	yes: z.boolean().optional().default(false).describe("Use default configuration"),
+	yolo: z.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
+	part: z.array(z.string()).optional().describe("Stack graph part binding, e.g. frontend:typescript:next or backend.orm:go:gorm"),
+	verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
+	dryRun: z.boolean().optional().default(false).describe("Preview generated file tree without writing to disk"),
+	verify: z.boolean().optional().default(false).describe("Run generated project checks after scaffolding without starting dev servers"),
+	ecosystem: types_exports.EcosystemSchema.optional().describe("Language ecosystem (typescript, react-native, rust, python, go, java, or elixir)"),
+	database: types_exports.DatabaseSchema.optional(),
+	orm: types_exports.ORMSchema.optional(),
+	auth: types_exports.AuthSchema.optional(),
+	payments: types_exports.PaymentsSchema.optional(),
+	email: types_exports.EmailSchema.optional(),
+	fileUpload: types_exports.FileUploadSchema.optional(),
+	effect: types_exports.EffectSchema.optional(),
+	stateManagement: types_exports.StateManagementSchema.optional(),
+	validation: types_exports.ValidationSchema.optional(),
+	forms: types_exports.FormsSchema.optional(),
+	testing: types_exports.TestingSchema.optional(),
+	ai: types_exports.AISchema.optional(),
+	realtime: types_exports.RealtimeSchema.optional(),
+	jobQueue: types_exports.JobQueueSchema.optional(),
+	animation: types_exports.AnimationSchema.optional(),
+	logging: types_exports.LoggingSchema.optional(),
+	observability: types_exports.ObservabilitySchema.optional(),
+	featureFlags: types_exports.FeatureFlagsSchema.optional().describe("Feature flags provider"),
+	analytics: types_exports.AnalyticsSchema.optional().describe("Privacy-focused analytics"),
+	cms: types_exports.CMSSchema.optional().describe("Headless CMS solution"),
+	caching: types_exports.CachingSchema.optional().describe("Caching solution"),
+	rateLimit: types_exports.RateLimitSchema.optional().describe("Rate limiting solution"),
+	i18n: types_exports.I18nSchema.optional().describe("Internationalization (i18n) library"),
+	search: types_exports.SearchSchema.optional().describe("Search engine solution"),
+	vectorDb: types_exports.VectorDbSchema.optional().describe("Vector database for AI embeddings (pgvector, qdrant, chroma, pinecone)"),
+	fileStorage: types_exports.FileStorageSchema.optional().describe("File storage solution (S3, R2)"),
+	mobileNavigation: types_exports.MobileNavigationSchema.optional().describe("Mobile navigation (expo-router, react-navigation)"),
+	mobileUI: types_exports.MobileUISchema.optional().describe("Mobile UI (tamagui, gluestack-ui, uniwind, unistyles)"),
+	mobileStorage: types_exports.MobileStorageSchema.optional().describe("Mobile storage (mmkv)"),
+	mobileTesting: types_exports.MobileTestingSchema.optional().describe("Mobile testing (maestro, react-native-testing-library)"),
+	mobilePush: types_exports.MobilePushSchema.optional().describe("Mobile push notifications (expo-notifications)"),
+	mobileOTA: types_exports.MobileOTASchema.optional().describe("Mobile OTA updates (expo-updates)"),
+	mobileDeepLinking: types_exports.MobileDeepLinkingSchema.optional().describe("Mobile deep linking (expo-linking)"),
+	frontend: z.array(types_exports.FrontendSchema).optional(),
+	astroIntegration: types_exports.AstroIntegrationSchema.optional().describe("Astro UI framework integration (react, vue, svelte, solid)"),
+	addons: z.array(types_exports.AddonsSchema).optional(),
+	examples: z.array(types_exports.ExamplesSchema).optional(),
+	git: z.boolean().optional(),
+	packageManager: types_exports.PackageManagerSchema.optional(),
+	install: z.boolean().optional(),
+	versionChannel: types_exports.VersionChannelSchema.optional().describe("Dependency version channel (stable, latest, beta)"),
+	dbSetup: types_exports.DatabaseSetupSchema.optional(),
+	backend: types_exports.BackendSchema.optional(),
+	runtime: types_exports.RuntimeSchema.optional(),
+	api: types_exports.APISchema.optional(),
+	cssFramework: types_exports.CSSFrameworkSchema.optional(),
+	uiLibrary: types_exports.UILibrarySchema.optional(),
+	shadcnBase: types_exports.ShadcnBaseSchema.optional().describe("shadcn/ui headless library (radix, base)"),
+	shadcnStyle: types_exports.ShadcnStyleSchema.optional().describe("shadcn/ui visual style (vega, nova, maia, lyra, mira)"),
+	shadcnIconLibrary: types_exports.ShadcnIconLibrarySchema.optional().describe("shadcn/ui icon library (lucide, tabler, hugeicons, phosphor, remixicon)"),
+	shadcnColorTheme: types_exports.ShadcnColorThemeSchema.optional().describe("shadcn/ui color theme (neutral, blue, violet, etc.)"),
+	shadcnBaseColor: types_exports.ShadcnBaseColorSchema.optional().describe("shadcn/ui base neutral color (neutral, stone, zinc, gray)"),
+	shadcnFont: types_exports.ShadcnFontSchema.optional().describe("shadcn/ui font (inter, geist, figtree, etc.)"),
+	shadcnRadius: types_exports.ShadcnRadiusSchema.optional().describe("shadcn/ui border radius (default, none, small, medium, large)"),
+	webDeploy: types_exports.WebDeploySchema.optional(),
+	serverDeploy: types_exports.ServerDeploySchema.optional(),
+	directoryConflict: types_exports.DirectoryConflictSchema.optional(),
+	renderTitle: z.boolean().optional(),
+	disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
+	manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup"),
+	rustWebFramework: types_exports.RustWebFrameworkSchema.optional().describe("Rust web framework (axum, actix-web)"),
+	rustFrontend: types_exports.RustFrontendSchema.optional().describe("Rust WASM frontend (leptos, dioxus)"),
+	rustOrm: types_exports.RustOrmSchema.optional().describe("Rust ORM/database (sea-orm, sqlx)"),
+	rustApi: types_exports.RustApiSchema.optional().describe("Rust API layer (tonic, async-graphql)"),
+	rustCli: types_exports.RustCliSchema.optional().describe("Rust CLI tools (clap, ratatui)"),
+	rustLibraries: z.array(types_exports.RustLibrariesSchema).optional().describe("Rust core libraries"),
+	rustLogging: types_exports.RustLoggingSchema.optional().describe("Rust logging (tracing, env-logger)"),
+	rustErrorHandling: types_exports.RustErrorHandlingSchema.optional().describe("Rust error handling (anyhow-thiserror, eyre)"),
+	rustCaching: types_exports.RustCachingSchema.optional().describe("Rust caching (moka, redis)"),
+	rustAuth: types_exports.RustAuthSchema.optional().describe("Rust auth (oauth2)"),
+	rustRealtime: types_exports.RustRealtimeSchema.optional().describe("Rust realtime (tokio-tungstenite)"),
+	rustMessageQueue: types_exports.RustMessageQueueSchema.optional().describe("Rust message queue (lapin)"),
+	rustObservability: types_exports.RustObservabilitySchema.optional().describe("Rust observability (opentelemetry)"),
+	rustTemplating: types_exports.RustTemplatingSchema.optional().describe("Rust templating (askama, tera)"),
+	pythonWebFramework: types_exports.PythonWebFrameworkSchema.optional().describe("Python web framework (fastapi, django)"),
+	pythonOrm: types_exports.PythonOrmSchema.optional().describe("Python ORM/database (sqlalchemy, sqlmodel)"),
+	pythonValidation: types_exports.PythonValidationSchema.optional().describe("Python validation (pydantic)"),
+	pythonAi: z.array(types_exports.PythonAiSchema).optional().describe("Python AI/ML frameworks"),
+	pythonAuth: types_exports.PythonAuthSchema.optional().describe("Python auth library (authlib, jwt)"),
+	pythonApi: types_exports.PythonApiSchema.optional().describe("Python API framework (django-rest-framework, django-ninja)"),
+	pythonTaskQueue: types_exports.PythonTaskQueueSchema.optional().describe("Python task queue (celery)"),
+	pythonGraphql: types_exports.PythonGraphqlSchema.optional().describe("Python GraphQL framework (strawberry)"),
+	pythonQuality: types_exports.PythonQualitySchema.optional().describe("Python code quality (ruff, mypy, pyright)"),
+	pythonTesting: z.array(types_exports.PythonTestingSchema).optional().describe("Python testing libraries (pytest, hypothesis)"),
+	pythonCaching: types_exports.PythonCachingSchema.optional().describe("Python caching (redis, aiocache)"),
+	pythonRealtime: types_exports.PythonRealtimeSchema.optional().describe("Python realtime (python-socketio, websockets)"),
+	pythonObservability: types_exports.PythonObservabilitySchema.optional().describe("Python observability (opentelemetry)"),
+	pythonCli: z.array(types_exports.PythonCliSchema).optional().describe("Python CLI tooling (typer, click, rich)"),
+	goWebFramework: types_exports.GoWebFrameworkSchema.optional().describe("Go web framework (gin, echo, fiber)"),
+	goOrm: types_exports.GoOrmSchema.optional().describe("Go ORM/database (gorm, sqlc)"),
+	goApi: types_exports.GoApiSchema.optional().describe("Go API layer (grpc-go)"),
+	goCli: types_exports.GoCliSchema.optional().describe("Go CLI tools (cobra, bubbletea, urfave-cli)"),
+	goLogging: types_exports.GoLoggingSchema.optional().describe("Go logging (zap, zerolog, slog)"),
+	goAuth: types_exports.GoAuthSchema.optional().describe("Go auth (casbin, jwt, goth)"),
+	goTesting: z.array(types_exports.GoTestingSchema).optional().describe("Go testing libraries (testify, gomock)"),
+	goRealtime: types_exports.GoRealtimeSchema.optional().describe("Go realtime library (gorilla-websocket, centrifuge)"),
+	goMessageQueue: types_exports.GoMessageQueueSchema.optional().describe("Go message queue (nats, watermill)"),
+	goCaching: types_exports.GoCachingSchema.optional().describe("Go caching library (redis, ristretto)"),
+	goConfig: types_exports.GoConfigSchema.optional().describe("Go config management (viper, koanf)"),
+	goObservability: types_exports.GoObservabilitySchema.optional().describe("Go observability (opentelemetry)"),
+	javaWebFramework: types_exports.JavaWebFrameworkSchema.optional().describe("Java web framework (spring-boot, quarkus, none)"),
+	javaBuildTool: types_exports.JavaBuildToolSchema.optional().describe("Java build tool (maven, gradle, none)"),
+	javaOrm: types_exports.JavaOrmSchema.optional().describe("Java ORM/database (spring-data-jpa)"),
+	javaAuth: types_exports.JavaAuthSchema.optional().describe("Java auth (spring-security)"),
+	javaApi: types_exports.JavaApiSchema.optional().describe("Java API layer (spring-graphql)"),
+	javaLogging: types_exports.JavaLoggingSchema.optional().describe("Java logging (logback, log4j2)"),
+	javaLibraries: z.array(types_exports.JavaLibrariesSchema).optional().describe("Java application libraries"),
+	javaTestingLibraries: z.array(types_exports.JavaTestingLibrariesSchema).optional().describe("Java testing libraries"),
+	dotnetWebFramework: types_exports.DotnetWebFrameworkSchema.optional().describe(".NET web framework (aspnet-minimal, aspnet-mvc, aspnet-blazor, none)"),
+	dotnetOrm: types_exports.DotnetOrmSchema.optional().describe(".NET data access (ef-core, dapper, linq2db)"),
+	dotnetAuth: types_exports.DotnetAuthSchema.optional().describe(".NET auth (aspnet-identity, duende-identityserver, auth0-aspnet, none)"),
+	dotnetApi: types_exports.DotnetApiSchema.optional().describe(".NET API style (minimal-api, graphql-hotchocolate, grpc-dotnet, none)"),
+	dotnetTesting: z.array(types_exports.DotnetTestingSchema).optional().describe(".NET testing libraries"),
+	dotnetJobQueue: types_exports.DotnetJobQueueSchema.optional().describe(".NET jobs (hangfire, quartz-net, hosted-services, none)"),
+	dotnetRealtime: types_exports.DotnetRealtimeSchema.optional().describe(".NET realtime (signalr, none)"),
+	dotnetObservability: z.array(types_exports.DotnetObservabilitySchema).optional().describe(".NET observability/logging libraries"),
+	dotnetValidation: types_exports.DotnetValidationSchema.optional().describe(".NET validation (fluentvalidation, data-annotations)"),
+	dotnetCaching: types_exports.DotnetCachingSchema.optional().describe(".NET caching (redis, memory-cache, none)"),
+	dotnetDeploy: types_exports.DotnetDeploySchema.optional().describe(".NET deploy target (docker, azure, aws, none)"),
+	elixirWebFramework: types_exports.ElixirWebFrameworkSchema.optional().describe("Elixir web framework (phoenix, phoenix-live-view, none)"),
+	elixirOrm: types_exports.ElixirOrmSchema.optional().describe("Elixir ORM/database (ecto, ecto-sql, none)"),
+	elixirAuth: types_exports.ElixirAuthSchema.optional().describe("Elixir auth (phx-gen-auth, ueberauth, guardian, none)"),
+	elixirApi: types_exports.ElixirApiSchema.optional().describe("Elixir API layer (rest, absinthe, none)"),
+	elixirRealtime: types_exports.ElixirRealtimeSchema.optional().describe("Elixir realtime (channels, presence, pubsub, live-view-streams, none)"),
+	elixirJobs: types_exports.ElixirJobsSchema.optional().describe("Elixir jobs (oban, quantum, none)"),
+	elixirValidation: types_exports.ElixirValidationSchema.optional().describe("Elixir validation (ecto-changesets, nimble-options, none)"),
+	elixirHttp: types_exports.ElixirHttpSchema.optional().describe("Elixir HTTP client (req, finch, none)"),
+	elixirJson: types_exports.ElixirJsonSchema.optional().describe("Elixir JSON library (jason, none)"),
+	elixirEmail: types_exports.ElixirEmailSchema.optional().describe("Elixir email library (swoosh, none)"),
+	elixirCaching: types_exports.ElixirCachingSchema.optional().describe("Elixir caching (cachex, nebulex, none)"),
+	elixirObservability: types_exports.ElixirObservabilitySchema.optional().describe("Elixir observability (telemetry, opentelemetry, prom_ex, none)"),
+	elixirTesting: types_exports.ElixirTestingSchema.optional().describe("Elixir testing (ex_unit, mox, bypass, wallaby, none)"),
+	elixirQuality: types_exports.ElixirQualitySchema.optional().describe("Elixir code quality (credo, dialyxir, sobelow, none)"),
+	elixirDeploy: types_exports.ElixirDeploySchema.optional().describe("Elixir deploy target (docker, fly, gigalixir, mix-release, none)"),
+	elixirLibraries: z.array(types_exports.ElixirLibrariesSchema).optional().describe("Elixir libraries (broadway, nx)"),
+	aiDocs: z.array(types_exports.AiDocsSchema).optional().describe("AI documentation files (claude-md, agents-md, cursorrules)")
+});
+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";
+	}
+}
+function formatArrayFlag(flag, values) {
+	const normalizedValues = values.filter((value) => value !== "none");
+	if (normalizedValues.length === 0) return `--${flag} none`;
+	return `--${flag} ${normalizedValues.join(" ")}`;
+}
+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 hasGraphPrimaryPart(config, role, ecosystem) {
+	return config.stackParts?.some((part) => part.source !== "provided" && part.role === role && !part.ownerPartId && (!ecosystem || part.ecosystem === ecosystem));
+}
+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 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));
+}
+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 hasGraphArrayParts(config, values, hasPart) {
+	const normalizedValues = values.filter((value) => value !== "none");
+	return normalizedValues.length > 0 && normalizedValues.every((value) => hasPart(config, value));
+}
+function appendChangedStringFlag(flags, flag, value, defaultValue) {
+	if (value !== defaultValue) flags.push(`--${flag} ${value}`);
+}
+function appendChangedGraphStringFlag(flags, config, role, ecosystem, flag, value, defaultValue) {
+	if (hasGraphPart(config, role, ecosystem)) return;
+	appendChangedStringFlag(flags, flag, value, defaultValue);
+}
+function appendChangedOwnedGraphStringFlag(flags, config, ownerRole, role, ecosystem, flag, value, defaultValue) {
+	if (hasOwnedGraphPart(config, ownerRole, role, ecosystem, value)) return;
+	appendChangedStringFlag(flags, flag, value, defaultValue);
+}
+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 appendChangedOwnedGraphArrayFlag(flags, config, ownerRole, role, ecosystem, flag, values, defaultValues) {
+	if (hasOwnedGraphArrayParts(config, ownerRole, role, ecosystem, values)) return;
+	appendChangedArrayFlag(flags, flag, values, defaultValues);
+}
+function appendChangedArrayFlag(flags, flag, values, defaultValues) {
+	if (values.length !== defaultValues.length || values.some((value, index) => value !== defaultValues[index])) flags.push(formatArrayFlag(flag, values));
+}
+function appendAstroIntegrationFlag(flags, config) {
+	if (config.frontend.includes("astro") && config.astroIntegration !== "none") flags.push(`--astro-integration ${config.astroIntegration}`);
+}
+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");
+	}
+	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 (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");
+	}
+	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");
+	}
+	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");
+	}
+	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 (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");
+	}
+}
+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}`);
+}
+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}`);
+	}
+	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;
+}
+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(" ")}`;
+}
+
+//#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;
+}
+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] || "";
+}
+
+//#endregion
+//#region src/utils/peer-dependency-conflicts.ts
+/**
+* Known peer dependency conflicts.
+*
+* Add new conflicts here as they are discovered.
+* The validator will check these against the user's selected options.
+*/
+const PEER_DEPENDENCY_CONFLICTS = [
+	{
+		id: "redux-toolkit-react19",
+		description: "redux-toolkit with React 19 may have peer dependency warnings",
+		packages: ["@reduxjs/toolkit", "react-redux"],
+		severity: "warning",
+		resolution: "Consider using zustand or jotai for React 19 projects, or ensure react-redux v9+",
+		triggeredBy: [{
+			optionKey: "stateManagement",
+			values: ["redux-toolkit"]
+		}],
+		conflictsWithOptions: [{
+			optionKey: "frontend",
+			values: ["next", "vinext"]
+		}]
+	},
+	{
+		id: "effect-schema-zod-overlap",
+		description: "effect/Schema (built into effect) and zod both provide validation - may cause confusion",
+		packages: ["effect", "zod"],
+		severity: "warning",
+		resolution: "Use --validation effect-schema with Effect, or --effect none with Zod",
+		triggeredBy: [{
+			optionKey: "effect",
+			values: ["effect-full"]
+		}],
+		conflictsWithOptions: [{
+			optionKey: "validation",
+			values: ["zod"]
+		}]
+	},
+	{
+		id: "prisma-d1-version",
+		description: "Prisma with D1 requires Prisma 5.x+ and specific adapter setup",
+		packages: ["prisma", "@prisma/adapter-d1"],
+		severity: "warning",
+		resolution: "Consider Drizzle ORM for simpler D1 integration",
+		triggeredBy: [{
+			optionKey: "orm",
+			values: ["prisma"]
+		}],
+		conflictsWithOptions: [{
+			optionKey: "dbSetup",
+			values: ["d1"]
+		}]
+	},
+	{
+		id: "biome-linting-overlap",
+		description: "Biome includes linting/formatting - other linting addons are redundant",
+		packages: [
+			"@biomejs/biome",
+			"eslint",
+			"prettier"
+		],
+		severity: "warning",
+		resolution: "Choose either Biome (all-in-one) or other linting tools, not both",
+		triggeredBy: [{
+			optionKey: "addons",
+			values: ["biome"]
+		}],
+		conflictsWithOptions: [{
+			optionKey: "addons",
+			values: ["ultracite", "oxlint"]
+		}]
+	},
+	{
+		id: "framer-motion-react19",
+		description: "framer-motion versions <12 may have React 19 issues",
+		packages: ["framer-motion"],
+		severity: "warning",
+		resolution: "The CLI uses motion (framer-motion v12+) which supports React 19",
+		triggeredBy: [{
+			optionKey: "animation",
+			values: ["framer-motion"]
+		}],
+		conflictsWithOptions: [{
+			optionKey: "frontend",
+			values: ["next", "vinext"]
+		}]
+	}
+];
+
+//#endregion
+//#region src/utils/peer-dependency-validator.ts
+/**
+* Peer dependency conflict validator.
+*
+* Checks project configuration against known conflicts and provides
+* warnings or errors before project creation begins.
+*/
+/**
+* Checks if a config value matches any of the specified values.
+*/
+function matchesValue(configValue, values) {
+	if (configValue === void 0 || configValue === null) return false;
+	if (Array.isArray(configValue)) return values.some((v) => configValue.includes(v));
+	return values.includes(configValue);
+}
+/**
+* Checks the configuration against known peer dependency conflicts.
+*/
+function checkPeerDependencyConflicts(config) {
+	const errors = [];
+	const warnings = [];
+	for (const conflict of PEER_DEPENDENCY_CONFLICTS) {
+		if (!conflict.triggeredBy.some((trigger) => {
+			const configValue = config[trigger.optionKey];
+			return matchesValue(configValue, trigger.values);
+		})) continue;
+		if (conflict.conflictsWithOptions.some((opt) => {
+			const configValue = config[opt.optionKey];
+			return matchesValue(configValue, opt.values);
+		})) if (conflict.severity === "error") errors.push(conflict);
+		else warnings.push(conflict);
+	}
+	return {
+		errors,
+		warnings
+	};
+}
+/**
+* Prints a warning message for a dependency conflict.
+*/
+function warnDependencyConflict(message, resolution) {
+	if (isSilent()) return;
+	consola.warn(pc.yellow(`Peer Dependency Warning: ${message}`));
+	consola.log(pc.dim(`   → ${resolution}`));
+}
+/**
+* Handles conflict results by printing warnings and exiting on errors.
+*/
+function handleConflictResult(result) {
+	for (const warning of result.warnings) warnDependencyConflict(warning.description, warning.resolution);
+	if (result.errors.length > 0) exitWithError(`Peer Dependency Conflict:\n${result.errors.map((e) => `${e.description}\n   → ${e.resolution}`).join("\n\n")}`);
+}
+/**
+* Validates peer dependencies for the given configuration.
+* Prints warnings and exits on errors.
+*/
+function validatePeerDependencies(config) {
+	handleConflictResult(checkPeerDependencyConflicts(config));
+}
+
+//#endregion
+//#region src/utils/config-validation.ts
+function validateDatabaseOrmAuth(cfg, flags) {
+	const db = cfg.database;
+	const orm = cfg.orm;
+	const has = (k) => flags ? flags.has(k) : true;
+	const hasGraphOrm = cfg.stackParts?.some((part) => part.role === "orm" && part.source !== "provided");
+	const ecosystemOrm = getEcosystemOrm(cfg);
+	const hasEcosystemOrm = ecosystemOrm !== void 0 && ecosystemOrm !== "none";
+	const isNonTypeScriptSqliteDefault = cfg.ecosystem !== void 0 && cfg.ecosystem !== "typescript" && cfg.ecosystem !== "react-native" && db === "sqlite" && !hasEcosystemOrm;
+	if (has("orm") && has("database") && orm === "mongoose" && db !== "mongodb") incompatibilityError({
+		message: "Mongoose ORM requires MongoDB database.",
+		provided: {
+			orm: "mongoose",
+			database: db || "none"
+		},
+		suggestions: ["Use --database mongodb", "Choose a different ORM (drizzle, prisma)"]
+	});
+	if (has("orm") && has("database") && orm === "drizzle" && db === "mongodb") incompatibilityError({
+		message: "Drizzle ORM does not support MongoDB.",
+		provided: {
+			orm: "drizzle",
+			database: "mongodb"
+		},
+		suggestions: ["Use --orm mongoose or --orm prisma for MongoDB", "Choose a different database (postgres, sqlite, mysql)"]
+	});
+	if (has("orm") && has("database") && orm === "typeorm" && db === "mongodb") incompatibilityError({
+		message: "TypeORM does not support MongoDB in Better Fullstack.",
+		provided: {
+			orm: "typeorm",
+			database: "mongodb"
+		},
+		suggestions: ["Use --orm mongoose or --orm prisma for MongoDB", "Choose a different database (postgres, sqlite, mysql)"]
+	});
+	if (has("orm") && has("database") && orm === "kysely" && db === "mongodb") incompatibilityError({
+		message: "Kysely does not support MongoDB.",
+		provided: {
+			orm: "kysely",
+			database: "mongodb"
+		},
+		suggestions: ["Use --orm mongoose or --orm prisma for MongoDB", "Choose a different database (postgres, sqlite, mysql)"]
+	});
+	if (has("orm") && has("database") && orm === "mikroorm" && db === "mongodb") incompatibilityError({
+		message: "MikroORM does not support MongoDB in Better Fullstack.",
+		provided: {
+			orm: "mikroorm",
+			database: "mongodb"
+		},
+		suggestions: ["Use --orm mongoose or --orm prisma for MongoDB", "Choose a different database (postgres, sqlite, mysql)"]
+	});
+	if (has("orm") && has("database") && orm === "sequelize" && db === "mongodb") incompatibilityError({
+		message: "Sequelize does not support MongoDB.",
+		provided: {
+			orm: "sequelize",
+			database: "mongodb"
+		},
+		suggestions: ["Use --orm mongoose or --orm prisma for MongoDB", "Choose a different database (postgres, sqlite, mysql)"]
+	});
+	if (has("database") && has("orm") && db === "mongodb" && orm && orm !== "mongoose" && orm !== "prisma" && orm !== "none") incompatibilityError({
+		message: "In Better-Fullstack, MongoDB is currently supported only with Mongoose or Prisma ORM.",
+		provided: {
+			database: "mongodb",
+			orm
+		},
+		suggestions: ["Use --orm mongoose", "Use --orm prisma"]
+	});
+	if (has("database") && has("orm") && db && db !== "none" && db !== "edgedb" && db !== "redis" && orm === "none" && !hasGraphOrm && !hasEcosystemOrm && !isNonTypeScriptSqliteDefault) missingRequirementError({
+		message: "Database selection requires an ORM.",
+		provided: {
+			database: db,
+			orm: "none"
+		},
+		suggestions: [
+			"Use --orm drizzle (recommended)",
+			"Use --orm prisma",
+			"Use --orm mongoose (MongoDB only)"
+		]
+	});
+	if (has("database") && has("orm") && db === "edgedb" && orm && orm !== "none") incompatibilityError({
+		message: "EdgeDB has its own built-in query builder and does not require an ORM.",
+		provided: {
+			database: "edgedb",
+			orm
+		},
+		suggestions: ["Use --orm none with EdgeDB", "Choose a different database if you want to use an ORM"]
+	});
+	if (has("database") && has("orm") && db === "redis" && orm && orm !== "none") incompatibilityError({
+		message: "Redis is a key-value store and does not require an ORM.",
+		provided: {
+			database: "redis",
+			orm
+		},
+		suggestions: ["Use --orm none with Redis", "Choose a different database if you want to use an ORM"]
+	});
+	if (has("orm") && has("database") && orm && orm !== "none" && db === "none") missingRequirementError({
+		message: "ORM selection requires a database.",
+		provided: {
+			orm,
+			database: "none"
+		},
+		suggestions: [
+			"Use --database postgres",
+			"Use --database sqlite",
+			"Use --database mysql",
+			"Set --orm none"
+		]
+	});
+}
+function getEcosystemOrm(cfg) {
+	switch (cfg.ecosystem) {
+		case "rust": return cfg.rustOrm;
+		case "python": return cfg.pythonOrm;
+		case "go": return cfg.goOrm;
+		case "java": return cfg.javaOrm;
+		case "dotnet": return cfg.dotnetOrm;
+		case "elixir": return cfg.elixirOrm;
+		default: return;
+	}
+}
+function getEcosystemBackend(cfg) {
+	switch (cfg.ecosystem) {
+		case "rust": return cfg.rustWebFramework && cfg.rustWebFramework !== "none" ? cfg.rustWebFramework : void 0;
+		case "python": return cfg.pythonWebFramework && cfg.pythonWebFramework !== "none" ? cfg.pythonWebFramework : void 0;
+		case "go": return cfg.goWebFramework && cfg.goWebFramework !== "none" ? cfg.goWebFramework : void 0;
+		case "java": return cfg.javaWebFramework && cfg.javaWebFramework !== "none" ? cfg.javaWebFramework : void 0;
+		case "dotnet": return cfg.dotnetWebFramework && cfg.dotnetWebFramework !== "none" ? cfg.dotnetWebFramework : void 0;
+		case "elixir": return cfg.elixirWebFramework && cfg.elixirWebFramework !== "none" ? cfg.elixirWebFramework : void 0;
+		default: return;
+	}
+}
+function validateDatabaseSetup(config, providedFlags) {
+	const { dbSetup, database, runtime } = config;
+	if (providedFlags.has("dbSetup") && providedFlags.has("database") && dbSetup && dbSetup !== "none" && database === "none") exitWithError("Database setup requires a database. Please choose a database or set '--db-setup none'.");
+	const setupValidations = {
+		turso: {
+			database: "sqlite",
+			errorMessage: "Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup."
+		},
+		neon: {
+			database: "postgres",
+			errorMessage: "Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		"prisma-postgres": {
+			database: "postgres",
+			errorMessage: "Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		planetscale: { errorMessage: "PlanetScale setup requires PostgreSQL or MySQL database. Please use '--database postgres' or '--database mysql' or choose a different setup." },
+		"mongodb-atlas": {
+			database: "mongodb",
+			errorMessage: "MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup."
+		},
+		upstash: {
+			database: "redis",
+			errorMessage: "Upstash setup requires Redis database. Please use '--database redis' or choose a different setup."
+		},
+		supabase: {
+			database: "postgres",
+			errorMessage: "Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		d1: {
+			database: "sqlite",
+			runtime: "workers",
+			errorMessage: "Cloudflare D1 setup requires SQLite database and Cloudflare Workers runtime."
+		},
+		docker: { errorMessage: "In Better-Fullstack, Docker setup is currently not available with SQLite database or Cloudflare Workers runtime." },
+		none: { errorMessage: "" }
+	};
+	if (dbSetup && dbSetup !== "none") {
+		const validation = setupValidations[dbSetup];
+		if (dbSetup === "planetscale") {
+			if (database !== "postgres" && database !== "mysql") exitWithError(validation.errorMessage);
+		} else if (validation.database && database !== validation.database) exitWithError(validation.errorMessage);
+		if (validation.runtime && runtime !== validation.runtime) exitWithError(validation.errorMessage);
+		if (dbSetup === "docker") {
+			if (database === "sqlite") exitWithError("In Better-Fullstack, Docker setup is currently not available with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
+			if (runtime === "workers") exitWithError("In Better-Fullstack, Docker setup is currently not available with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+		}
+	}
+}
+function validateEcosystemAuthCompatibility(config, providedFlags) {
+	const auth = config.auth;
+	if (!auth || auth === "none") return;
+	if ((auth === "better-auth" || auth === "better-auth-organizations") && config.orm && [
+		"typeorm",
+		"sequelize",
+		"mikroorm"
+	].includes(config.orm)) {
+		config.auth = "none";
+		if (providedFlags?.has("auth") && !isSilent()) consola.warn(pc.yellow(`Unsupported auth selection '${auth}' with ${config.orm}: no Better Auth adapter exists. Falling back to '--auth none'.`));
+		return;
+	}
+	const normalized = (0, types_exports.normalizeCapabilitySelection)("auth", {
+		ecosystem: config.ecosystem,
+		backend: config.backend,
+		frontend: config.frontend
+	}, auth);
+	if (!normalized.normalized || normalized.value === auth) return;
+	config.auth = normalized.value;
+	if (providedFlags?.has("auth") && normalized.reason && !isSilent()) consola.warn(pc.yellow(`Unsupported auth selection '${auth}' for the current stack: ${normalized.reason}. Falling back to '--auth ${normalized.value}'.`));
+}
+function validateConvexConstraints(config, providedFlags) {
+	const { backend } = config;
+	if (backend !== "convex") return;
+	const has = (k) => providedFlags.has(k);
+	if (has("runtime") && config.runtime !== "none") constraintError({
+		message: "Convex backend manages its own runtime.",
+		provided: {
+			backend: "convex",
+			runtime: config.runtime || ""
+		},
+		suggestions: ["Remove --runtime flag", "Set --runtime none"]
+	});
+	if (has("database") && config.database !== "none") constraintError({
+		message: "Convex backend has its own built-in database.",
+		provided: {
+			backend: "convex",
+			database: config.database || ""
+		},
+		suggestions: ["Remove --database flag", "Set --database none"]
+	});
+	if (has("orm") && config.orm !== "none") constraintError({
+		message: "Convex backend has its own data layer (no ORM needed).",
+		provided: {
+			backend: "convex",
+			orm: config.orm || ""
+		},
+		suggestions: ["Remove --orm flag", "Set --orm none"]
+	});
+	if (has("api") && config.api !== "none") constraintError({
+		message: "Convex backend has its own built-in API layer.",
+		provided: {
+			backend: "convex",
+			api: config.api || ""
+		},
+		suggestions: ["Remove --api flag", "Set --api none"]
+	});
+	if (has("dbSetup") && config.dbSetup !== "none") constraintError({
+		message: "Convex backend manages its own database infrastructure.",
+		provided: {
+			backend: "convex",
+			"db-setup": config.dbSetup || ""
+		},
+		suggestions: ["Remove --db-setup flag", "Set --db-setup none"]
+	});
+	if (has("serverDeploy") && config.serverDeploy !== "none") constraintError({
+		message: "Convex backend has its own deployment platform.",
+		provided: {
+			backend: "convex",
+			"server-deploy": config.serverDeploy || ""
+		},
+		suggestions: ["Remove --server-deploy flag", "Set --server-deploy none"]
+	});
+}
+function validateBackendNoneConstraints(config, providedFlags) {
+	const { backend } = config;
+	const hasGraphBackend = config.stackParts?.some((part) => part.role === "backend" && !part.ownerPartId && part.source !== "provided" && part.ecosystem !== "typescript" && part.ecosystem !== "react-native" && part.ecosystem !== "universal");
+	const hasEcosystemBackend = getEcosystemBackend(config) !== void 0;
+	if (backend !== "none" || hasGraphBackend || hasEcosystemBackend) return;
+	const has = (k) => providedFlags.has(k);
+	if (has("runtime") && config.runtime !== "none") exitWithError("Backend 'none' requires '--runtime none'. Please remove the --runtime flag or set it to 'none'.");
+	if (has("database") && config.database !== "none") exitWithError("Backend 'none' requires '--database none'. Please remove the --database flag or set it to 'none'.");
+	if (has("orm") && config.orm !== "none") exitWithError("Backend 'none' requires '--orm none'. Please remove the --orm flag or set it to 'none'.");
+	if (has("api") && config.api !== "none") exitWithError("Backend 'none' requires '--api none'. Please remove the --api flag or set it to 'none'.");
+	if (has("payments") && config.payments !== "none") exitWithError("Backend 'none' requires '--payments none'. Please remove the --payments flag or set it to 'none'.");
+	if (has("dbSetup") && config.dbSetup !== "none") exitWithError("Backend 'none' requires '--db-setup none'. Please remove the --db-setup flag or set it to 'none'.");
+	if (has("serverDeploy") && config.serverDeploy !== "none") exitWithError("Backend 'none' requires '--server-deploy none'. Please remove the --server-deploy flag or set it to 'none'.");
+}
+function validateSelfBackendConstraints(config, providedFlags) {
+	const { backend } = config;
+	if (backend !== "self") return;
+	const has = (k) => providedFlags.has(k);
+	if (has("runtime") && config.runtime !== "none") exitWithError("Backend 'self' (fullstack) requires '--runtime none'. Please remove the --runtime flag or set it to 'none'.");
+}
+function validateEncoreConstraints(config, providedFlags) {
+	const { backend } = config;
+	if (backend !== "encore") return;
+	const has = (k) => providedFlags.has(k);
+	if (has("runtime") && config.runtime !== "none") exitWithError("Encore.ts backend requires '--runtime none'. Encore has its own runtime via the Encore CLI. Please remove the --runtime flag or set it to 'none'.");
+	if (has("api") && config.api !== "none") exitWithError("Encore.ts backend requires '--api none'. Encore has its own type-safe API system. Please remove the --api flag or set it to 'none'.");
+	if (has("database") && config.database !== "none") exitWithError("Encore.ts backend requires '--database none'. Encore manages databases through its infrastructure primitives. Please remove the --database flag or set it to 'none'.");
+	if (has("orm") && config.orm !== "none") exitWithError("Encore.ts backend requires '--orm none'. Encore has its own database abstractions. Please remove the --orm flag or set it to 'none'.");
+	if (has("dbSetup") && config.dbSetup !== "none") exitWithError("Encore.ts backend requires '--db-setup none'. Encore manages infrastructure automatically. Please remove the --db-setup flag or set it to 'none'.");
+	if (has("serverDeploy") && config.serverDeploy !== "none") exitWithError("Encore.ts backend requires '--server-deploy none'. Encore has its own deployment platform. Please remove the --server-deploy flag or set it to 'none'.");
+}
+function validateAdonisJSConstraints(config, providedFlags) {
+	const { backend } = config;
+	if (backend !== "adonisjs") return;
+	const has = (k) => providedFlags.has(k);
+	if (has("runtime") && config.runtime !== "node") exitWithError("AdonisJS backend requires '--runtime node'. AdonisJS currently only supports Node.js runtime. Please use '--runtime node' or remove the --runtime flag.");
+}
+function validateBackendConstraints(config, providedFlags, options) {
+	const { backend } = config;
+	if (providedFlags.has("backend") && backend && backend !== "convex" && backend !== "none" && backend !== "self" && backend !== "encore") {
+		if (providedFlags.has("runtime") && options.runtime === "none") exitWithError("'--runtime none' is only supported with '--backend convex', '--backend none', '--backend self', or '--backend encore'. Please choose 'bun', 'node', or remove the --runtime flag.");
+	}
+	if (backend === "convex" && providedFlags.has("frontend") && options.frontend) {
+		const incompatibleFrontends = options.frontend.filter((f) => ["solid", "astro"].includes(f));
+		if (incompatibleFrontends.length > 0) exitWithError(`The following frontends are not compatible with '--backend convex': ${incompatibleFrontends.join(", ")}. Please choose a different frontend or backend.`);
+	}
+}
+function validateFrontendConstraints(config, providedFlags) {
+	const { frontend } = config;
+	if (frontend && frontend.length > 0) {
+		if (config.ecosystem === "react-native" && frontend.some((item) => !item.startsWith("native-") && item !== "none")) incompatibilityError({
+			message: "React Native ecosystem only supports native Expo frontends.",
+			provided: {
+				ecosystem: "react-native",
+				frontend: frontend.join(" ")
+			},
+			suggestions: [
+				"Use --frontend native-bare",
+				"Use --frontend native-uniwind",
+				"Use --frontend native-unistyles"
+			]
+		});
+		ensureSingleWebAndNative(frontend);
+		if (providedFlags.has("api") && providedFlags.has("frontend") && config.api) validateApiFrontendCompatibility(config.api, frontend, config.astroIntegration);
+	}
+	const hasWebFrontendFlag = (frontend ?? []).some((f) => isWebFrontend(f));
+	validateWebDeployRequiresWebFrontend(config.webDeploy, hasWebFrontendFlag);
+	validateWebDeployFrontendTemplates(config.webDeploy, frontend);
+}
+function validateApiConstraints(config, _options) {
+	if (config.api !== "openapi" && config.api !== "apollo-server") return;
+	const apiDisplayName = config.api === "apollo-server" ? "Apollo Server" : "OpenAPI";
+	const frontend = config.frontend ?? [];
+	if (frontend.some((item) => [
+		"native-bare",
+		"native-uniwind",
+		"native-unistyles"
+	].includes(item))) incompatibilityError({
+		message: `${apiDisplayName} is currently available for web frontends, not React Native.`,
+		provided: {
+			api: config.api,
+			frontend
+		},
+		suggestions: [
+			"Use --api trpc",
+			"Use --api orpc",
+			"Use a web frontend"
+		]
+	});
+	if (!config.backend || ![
+		"hono",
+		"express",
+		"fastify",
+		"elysia"
+	].includes(config.backend)) incompatibilityError({
+		message: `${apiDisplayName} currently supports Hono, Express, Fastify, and Elysia backends.`,
+		provided: {
+			api: config.api,
+			backend: config.backend ?? "none"
+		},
+		suggestions: [
+			"Use --backend hono",
+			"Use --backend express",
+			"Use --backend fastify",
+			"Use --backend elysia"
+		]
+	});
+}
+function validateJavaConstraints(config, providedFlags = /* @__PURE__ */ new Set()) {
+	if (config.ecosystem !== "java") return;
+	const hasSpringBoot = config.javaWebFramework === "spring-boot";
+	const hasJavaWebFramework = config.javaWebFramework !== "none";
+	const hasNoBuildTool = config.javaBuildTool === "none";
+	const hasJavaLibraries = (config.javaLibraries ?? []).some((library) => library !== "none");
+	const hasJavaTestingLibraries = (config.javaTestingLibraries ?? []).some((library) => library !== "none");
+	const hasSpringOnlyFeatures = config.javaOrm !== "none" || config.javaAuth !== "none" || hasJavaLibraries;
+	if (hasNoBuildTool && hasJavaWebFramework) incompatibilityError({
+		message: "Java web frameworks require Maven or Gradle in the Java scaffold.",
+		provided: {
+			"java-web-framework": config.javaWebFramework ?? "none",
+			"java-build-tool": config.javaBuildTool ?? "none"
+		},
+		suggestions: ["Use --java-build-tool maven or --java-build-tool gradle with Java web frameworks", "Use --java-web-framework none for a plain Java source-only scaffold"]
+	});
+	if ((!hasSpringBoot || hasNoBuildTool) && hasSpringOnlyFeatures) incompatibilityError({
+		message: "Spring-only Java features require the Spring Boot scaffold with Maven or Gradle.",
+		provided: {
+			"java-web-framework": config.javaWebFramework ?? "none",
+			"java-build-tool": config.javaBuildTool ?? "none",
+			"java-orm": config.javaOrm ?? "none",
+			"java-auth": config.javaAuth ?? "none",
+			"java-libraries": (config.javaLibraries ?? []).join(" ") || "none"
+		},
+		suggestions: ["Use --java-web-framework spring-boot and a real build tool for Spring features", "Clear --java-orm, --java-auth, and --java-libraries when using plain Java or Quarkus"]
+	});
+	if (hasNoBuildTool && hasJavaTestingLibraries) incompatibilityError({
+		message: "Java testing libraries require Maven or Gradle to manage test dependencies.",
+		provided: {
+			"java-build-tool": config.javaBuildTool ?? "none",
+			"java-testing-libraries": (config.javaTestingLibraries ?? []).join(" ") || "none"
+		},
+		suggestions: ["Use --java-build-tool maven or --java-build-tool gradle to enable JUnit/Mockito/Testcontainers", "Set --java-testing-libraries none for a source-only plain Java scaffold"]
+	});
+}
+function validateElixirConstraints(config) {
+	if (config.ecosystem !== "elixir") return;
+	const hasPhoenix = config.elixirWebFramework !== "none";
+	const hasEcto = config.elixirOrm !== "none";
+	const hasEctoSql = config.elixirOrm === "ecto-sql";
+	if (!hasPhoenix) {
+		const phoenixOnlySelections = [
+			{
+				flag: "elixir-auth",
+				value: config.elixirAuth,
+				message: "Elixir auth scaffolds require Phoenix."
+			},
+			{
+				flag: "elixir-api",
+				value: config.elixirApi,
+				message: "Elixir API scaffolds require Phoenix."
+			},
+			{
+				flag: "elixir-realtime",
+				value: config.elixirRealtime,
+				message: "Elixir realtime scaffolds require Phoenix."
+			},
+			{
+				flag: "elixir-testing",
+				value: config.elixirTesting === "wallaby" ? config.elixirTesting : "none",
+				message: "Wallaby browser tests require Phoenix."
+			}
+		];
+		for (const selection of phoenixOnlySelections) {
+			if (!selection.value || selection.value === "none") continue;
+			incompatibilityError({
+				message: selection.message,
+				provided: {
+					"elixir-web-framework": config.elixirWebFramework ?? "none",
+					[selection.flag]: selection.value
+				},
+				suggestions: [
+					"Use --elixir-web-framework phoenix",
+					"Use --elixir-web-framework phoenix-live-view",
+					`Use --${selection.flag} none`
+				]
+			});
+		}
+	}
+	if (hasPhoenix && config.elixirJson === "none") incompatibilityError({
+		message: "Phoenix JSON scaffolds require Jason.",
+		provided: { "elixir-json": "none" },
+		suggestions: ["Use --elixir-json jason"]
+	});
+	if (config.elixirAuth === "phx-gen-auth" && !hasEctoSql) incompatibilityError({
+		message: "phx.gen.auth requires Ecto SQL with PostgreSQL in the generated Phoenix scaffold.",
+		provided: {
+			"elixir-auth": "phx-gen-auth",
+			"elixir-orm": config.elixirOrm ?? "none"
+		},
+		suggestions: ["Use --elixir-orm ecto-sql", "Use --elixir-auth none"]
+	});
+	if (config.elixirJobs === "oban" && config.elixirOrm !== "ecto-sql") incompatibilityError({
+		message: "Oban requires Ecto SQL with PostgreSQL in the generated Phoenix scaffold.",
+		provided: {
+			"elixir-jobs": "oban",
+			"elixir-orm": config.elixirOrm ?? "none"
+		},
+		suggestions: ["Use --elixir-orm ecto-sql", "Use --elixir-jobs none"]
+	});
+	if (config.elixirRealtime === "live-view-streams" && config.elixirWebFramework !== "phoenix-live-view") incompatibilityError({
+		message: "LiveView Streams require Phoenix LiveView.",
+		provided: {
+			"elixir-realtime": "live-view-streams",
+			"elixir-web-framework": config.elixirWebFramework ?? "none"
+		},
+		suggestions: ["Use --elixir-web-framework phoenix-live-view", "Use --elixir-realtime channels"]
+	});
+	if (config.elixirApi === "absinthe" && !hasEcto) incompatibilityError({
+		message: "Absinthe GraphQL requires Ecto in the current generated Phoenix scaffold.",
+		provided: {
+			"elixir-api": "absinthe",
+			"elixir-orm": config.elixirOrm ?? "none"
+		},
+		suggestions: ["Use --elixir-orm ecto-sql", "Use --elixir-api rest"]
+	});
+}
+function validateEmailConstraints(config) {
+	if (!config.email || config.email === "none") return;
+	if (config.ecosystem !== "typescript" && config.email !== "resend") incompatibilityError({
+		message: "Only Resend email is available for non-TypeScript ecosystems.",
+		provided: {
+			ecosystem: config.ecosystem ?? "typescript",
+			email: config.email
+		},
+		suggestions: ["Use --email resend", "Use --email none"]
+	});
+	if (config.ecosystem === "java" && config.email === "resend" && config.javaBuildTool === "none") incompatibilityError({
+		message: "Resend email for Java requires Maven or Gradle to manage the SDK dependency.",
+		provided: {
+			"java-build-tool": "none",
+			email: "resend"
+		},
+		suggestions: ["Use --java-build-tool maven", "Use --java-build-tool gradle"]
+	});
+}
+function validateObservabilityConstraints(config) {
+	if (!config.observability || config.observability === "none") return;
+	if (config.ecosystem !== "typescript" && config.observability !== "sentry") incompatibilityError({
+		message: "Only Sentry observability is available for non-TypeScript ecosystems.",
+		provided: {
+			ecosystem: config.ecosystem ?? "typescript",
+			observability: config.observability
+		},
+		suggestions: ["Use --observability sentry", "Use --observability none"]
+	});
+	if (config.ecosystem === "java" && config.observability === "sentry" && config.javaBuildTool === "none") incompatibilityError({
+		message: "Sentry observability for Java requires Maven or Gradle to manage the SDK dependency.",
+		provided: {
+			"java-build-tool": "none",
+			observability: "sentry"
+		},
+		suggestions: ["Use --java-build-tool maven", "Use --java-build-tool gradle"]
+	});
+}
+function validateCachingConstraints(config) {
+	if (!config.caching || config.caching === "none") return;
+	if (config.ecosystem !== "typescript" && config.caching !== "upstash-redis") incompatibilityError({
+		message: "Only Upstash Redis caching is available for non-TypeScript ecosystems.",
+		provided: {
+			ecosystem: config.ecosystem ?? "typescript",
+			caching: config.caching
+		},
+		suggestions: ["Use --caching upstash-redis", "Use --caching none"]
+	});
+	if (config.ecosystem === "java" && config.caching === "upstash-redis" && config.javaBuildTool === "none") incompatibilityError({
+		message: "Upstash Redis caching for Java requires Maven or Gradle to manage the Redis client dependency.",
+		provided: {
+			"java-build-tool": "none",
+			caching: "upstash-redis"
+		},
+		suggestions: ["Use --java-build-tool maven", "Use --java-build-tool gradle"]
+	});
+}
+function validateRateLimitConstraints(config) {
+	if (!config.rateLimit || config.rateLimit === "none") return;
+	if (config.ecosystem !== "typescript") incompatibilityError({
+		message: "Rate limiting helpers are currently available for TypeScript stacks only.",
+		provided: {
+			ecosystem: config.ecosystem ?? "typescript",
+			"rate-limit": config.rateLimit
+		},
+		suggestions: ["Use --rate-limit none"]
+	});
+	if (config.backend === "convex") incompatibilityError({
+		message: "Rate limiting helpers are not generated with Convex backend.",
+		provided: {
+			backend: "convex",
+			"rate-limit": config.rateLimit
+		},
+		suggestions: ["Use --rate-limit none"]
+	});
+	if (config.backend === "none") incompatibilityError({
+		message: "Rate limiting requires a backend.",
+		provided: {
+			backend: "none",
+			"rate-limit": config.rateLimit
+		},
+		suggestions: ["Use --backend hono", "Use --rate-limit none"]
+	});
+}
+function validateSearchConstraints(config) {
+	if (!config.search || config.search === "none") return;
+	const ecosystem = config.ecosystem ?? "typescript";
+	if (ecosystem !== "typescript" && config.search !== "meilisearch") incompatibilityError({
+		message: "Only Meilisearch search is available for non-TypeScript ecosystems.",
+		provided: {
+			ecosystem,
+			search: config.search
+		},
+		suggestions: ["Use --search meilisearch", "Use --search none"]
+	});
+	if (config.ecosystem === "java" && config.search === "meilisearch" && config.javaBuildTool === "none") incompatibilityError({
+		message: "Meilisearch search for Java requires Maven or Gradle to manage the SDK dependency.",
+		provided: {
+			"java-build-tool": "none",
+			search: "meilisearch"
+		},
+		suggestions: ["Use --java-build-tool maven", "Use --java-build-tool gradle"]
+	});
+}
+function validateShadcnConstraints(config, providedFlags) {
+	const shadcnFlagMap = {
+		shadcnBase: "--shadcn-base",
+		shadcnStyle: "--shadcn-style",
+		shadcnIconLibrary: "--shadcn-icon-library",
+		shadcnColorTheme: "--shadcn-color-theme",
+		shadcnBaseColor: "--shadcn-base-color",
+		shadcnFont: "--shadcn-font",
+		shadcnRadius: "--shadcn-radius"
+	};
+	const providedShadcnFlags = Object.keys(shadcnFlagMap).filter((f) => providedFlags.has(f));
+	if (providedShadcnFlags.length > 0 && config.uiLibrary !== "shadcn-ui") incompatibilityError({
+		message: "shadcn/ui customization flags require --ui-library shadcn-ui.",
+		provided: {
+			"ui-library": config.uiLibrary || "none",
+			...Object.fromEntries(providedShadcnFlags.map((f) => [shadcnFlagMap[f], String(config[f] ?? "")]))
+		},
+		suggestions: ["Add --ui-library shadcn-ui to use shadcn customization flags", "Remove the --shadcn-* flags if not using shadcn/ui"]
+	});
+}
+function validatePythonApiConstraints(config) {
+	if (config.ecosystem === "python" && config.pythonApi && config.pythonApi !== "none" && config.pythonWebFramework !== "django") incompatibilityError({
+		message: "Python API frameworks require --python-web-framework django.",
+		provided: {
+			"python-web-framework": config.pythonWebFramework || "none",
+			"python-api": config.pythonApi
+		},
+		suggestions: ["Use --python-web-framework django with --python-api django-rest-framework or django-ninja", "Set --python-api none for FastAPI, Flask, Litestar, or no Python web framework"]
+	});
+}
+function validateFullConfig(config, providedFlags, options) {
+	if (config.stackParts && !options.yolo) {
+		const graphValidation = (0, types_exports.validateStackParts)(config.stackParts);
+		if (graphValidation.issues.length > 0) exitWithError(graphValidation.issues.map((issue) => issue.message).join("\n"));
+	}
+	validateEcosystemAuthCompatibility(config, providedFlags);
+	validateDatabaseOrmAuth(config, providedFlags);
+	validateDatabaseSetup(config, providedFlags);
+	validateConvexConstraints(config, providedFlags);
+	validateBackendNoneConstraints(config, providedFlags);
+	validateSelfBackendConstraints(config, providedFlags);
+	validateEncoreConstraints(config, providedFlags);
+	validateAdonisJSConstraints(config, providedFlags);
+	validateBackendConstraints(config, providedFlags, options);
+	validateFrontendConstraints(config, providedFlags);
+	validateApiConstraints(config, options);
+	validatePythonApiConstraints(config);
+	validateEmailConstraints(config);
+	validateObservabilityConstraints(config);
+	validateCachingConstraints(config);
+	validateRateLimitConstraints(config);
+	validateSearchConstraints(config);
+	validateJavaConstraints(config, providedFlags);
+	validateElixirConstraints(config);
+	const hasGraphBackend = config.stackParts?.some((part) => part.role === "backend" && !part.ownerPartId && part.source !== "provided" && part.ecosystem !== "typescript" && part.ecosystem !== "react-native" && part.ecosystem !== "universal");
+	if (!(providedFlags.has("serverDeploy") && !options.yes && !options.part?.length && options.ecosystem === void 0 && options.backend === void 0 && config.stackParts === void 0)) validateServerDeployRequiresBackend(config.serverDeploy, config.backend, Boolean(hasGraphBackend));
+	validateSelfBackendCompatibility(providedFlags, options, config);
+	validateWorkersCompatibility(providedFlags, options, config);
+	if (config.runtime === "workers" && config.serverDeploy === "none") exitWithError("Cloudflare Workers runtime requires a server deployment. Please choose 'alchemy' for --server-deploy.");
+	if (providedFlags.has("serverDeploy") && config.serverDeploy === "cloudflare" && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
+	if (config.serverDeploy === "vercel" && [
+		"nestjs",
+		"adonisjs",
+		"encore"
+	].includes(config.backend)) incompatibilityError({
+		message: "Vercel serverless functions cannot host persistent-process backends",
+		provided: {
+			backend: config.backend,
+			serverDeploy: config.serverDeploy
+		},
+		suggestions: ["Use --server-deploy fly or --server-deploy railway for NestJS/AdonisJS", "Switch to a serverless-compatible backend like Hono or Express"]
+	});
+	if (config.serverDeploy === "netlify") {
+		if (config.backend !== "hono") incompatibilityError({
+			message: "Netlify Functions server deploy is currently supported only with Hono",
+			provided: {
+				backend: config.backend,
+				serverDeploy: config.serverDeploy
+			},
+			suggestions: ["Use --backend hono", "Use --server-deploy fly, railway, render, or docker for this backend"]
+		});
+		if (config.runtime !== "node") incompatibilityError({
+			message: "Netlify Functions server deploy requires Node.js runtime",
+			provided: {
+				runtime: config.runtime,
+				serverDeploy: config.serverDeploy
+			},
+			suggestions: ["Use --runtime node", "Choose a different server deployment target"]
+		});
+	}
+	if (config.addons && config.addons.length > 0) {
+		validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime, config.ecosystem, config.rustFrontend, config.javaWebFramework, config.database);
+		config.addons = [...new Set(config.addons)];
+	}
+	validateExamplesCompatibility(config.examples ?? [], config.backend, config.frontend ?? [], config.runtime, config.ai);
+	validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend ?? []);
+	validateAIFrontendCompatibility(config.ai, config.frontend ?? []);
+	validateUILibraryFrontendCompatibility(config.uiLibrary, config.frontend ?? [], config.astroIntegration);
+	validateUILibraryCSSFrameworkCompatibility(config.uiLibrary, config.cssFramework);
+	validateShadcnConstraints(config, providedFlags);
+	validatePeerDependencies(config);
+}
+function validateConfigForProgrammaticUse(config) {
+	try {
+		if (config.stackParts) {
+			const graphValidation = (0, types_exports.validateStackParts)(config.stackParts);
+			if (graphValidation.issues.length > 0) throw new Error(graphValidation.issues.map((issue) => issue.message).join("\n"));
+		}
+		validateEcosystemAuthCompatibility(config);
+		validateDatabaseOrmAuth(config);
+		if (config.frontend && config.frontend.length > 0) ensureSingleWebAndNative(config.frontend);
+		validateApiFrontendCompatibility(config.api, config.frontend, config.astroIntegration);
+		validatePythonApiConstraints(config);
+		validateEmailConstraints(config);
+		validateObservabilityConstraints(config);
+		validateCachingConstraints(config);
+		validateRateLimitConstraints(config);
+		validateSearchConstraints(config);
+		validateJavaConstraints(config);
+		validateElixirConstraints(config);
+		validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend);
+		if (config.addons && config.addons.length > 0) validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime, config.ecosystem, config.rustFrontend, config.javaWebFramework, config.database);
+		validateExamplesCompatibility(config.examples ?? [], config.backend, config.frontend ?? [], config.runtime, config.ai);
+		validateAIFrontendCompatibility(config.ai, config.frontend ?? []);
+		validateUILibraryFrontendCompatibility(config.uiLibrary, config.frontend ?? [], config.astroIntegration);
+		validateUILibraryCSSFrameworkCompatibility(config.uiLibrary, config.cssFramework);
+		validatePeerDependencies(config);
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(String(error), { cause: error });
+	}
+}
+
+//#endregion
+export { generateReproducibleCommand as a, getTemplateDescription as i, validateFullConfig as n, CreateCommandInputSchema as o, getTemplateConfig as r, CreateCommandOptionsSchema as s, validateConfigForProgrammaticUse as t };