create-better-fullstack 1.0.5 → 1.1.1

package/dist/{src-B1JV3DqF.mjs → src-uKym6_H1.mjs}

@@ -1038,25 +1038,153 @@ async function getAddonsChoice(addons, frontends, auth) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/ai.ts
+async function getAIChoice(ai) {
+	if (ai !== void 0) return ai;
+	const response = await navigableSelect({
+		message: "Select AI SDK",
+		options: [
+			{
+				value: "vercel-ai",
+				label: "Vercel AI SDK",
+				hint: "The AI Toolkit for TypeScript - supports OpenAI, Anthropic, Google, etc."
+			},
+			{
+				value: "mastra",
+				label: "Mastra",
+				hint: "TypeScript-native AI agent framework with workflows"
+			},
+			{
+				value: "voltagent",
+				label: "VoltAgent",
+				hint: "AI Agent framework with memory, workflows, and observability"
+			},
+			{
+				value: "langgraph",
+				label: "LangGraph.js",
+				hint: "Graph-based agent orchestration with stateful workflows"
+			},
+			{
+				value: "openai-agents",
+				label: "OpenAI Agents SDK",
+				hint: "Official multi-agent framework with handoffs and guardrails"
+			},
+			{
+				value: "google-adk",
+				label: "Google ADK",
+				hint: "Code-first agent development kit for building AI agents"
+			},
+			{
+				value: "modelfusion",
+				label: "ModelFusion",
+				hint: "Type-safe AI library for multi-provider text generation"
+			},
+			{
+				value: "langchain",
+				label: "LangChain",
+				hint: "Build context-aware reasoning applications"
+			},
+			{
+				value: "llamaindex",
+				label: "LlamaIndex",
+				hint: "Data framework for LLM applications"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No AI SDK"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/prompts/animation.ts
+async function getAnimationChoice(animation, frontends) {
+	if (animation !== void 0) return animation;
+	const { web } = splitFrontends(frontends);
+	if (web.length === 0) return "none";
+	const isReact = web.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next",
+		"redwood"
+	].includes(f));
+	const options = [];
+	if (isReact) options.push({
+		value: "framer-motion",
+		label: "Framer Motion",
+		hint: "Production-ready declarative animations for React"
+	}, {
+		value: "react-spring",
+		label: "React Spring",
+		hint: "Physics-based animations for fluid interactions"
+	});
+	options.push({
+		value: "gsap",
+		label: "GSAP",
+		hint: "Professional-grade animation engine for the web"
+	}, {
+		value: "auto-animate",
+		label: "Auto Animate",
+		hint: "Zero-config, drop-in animation utility"
+	}, {
+		value: "lottie",
+		label: "Lottie",
+		hint: "Render After Effects animations natively"
+	}, {
+		value: "none",
+		label: "None",
+		hint: "Skip animation library setup"
+	});
+	const response = await navigableSelect({
+		message: "Select animation library",
+		options,
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/api.ts
 async function getApiChoice(Api, frontend, backend, astroIntegration) {
 	if (backend === "convex" || backend === "none") return "none";
 	const allowed = allowedApisForFrontends(frontend ?? [], astroIntegration);
 	if (Api) return allowed.includes(Api) ? Api : allowed[0];
-	const apiOptions = allowed.map((a) => a === "trpc" ? {
-		value: "trpc",
-		label: "tRPC",
-		hint: "End-to-end typesafe APIs made easy"
-	} : a === "orpc" ? {
-		value: "orpc",
-		label: "oRPC",
-		hint: "End-to-end type-safe APIs that adhere to OpenAPI standards"
-	} : {
-		value: "none",
-		label: "None",
-		hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
-	});
+	const apiOptionMap = {
+		trpc: {
+			value: "trpc",
+			label: "tRPC",
+			hint: "End-to-end typesafe APIs made easy"
+		},
+		orpc: {
+			value: "orpc",
+			label: "oRPC",
+			hint: "End-to-end type-safe APIs that adhere to OpenAPI standards"
+		},
+		"ts-rest": {
+			value: "ts-rest",
+			label: "ts-rest",
+			hint: "RPC-like client, contract, and server implementation for REST APIs"
+		},
+		garph: {
+			value: "garph",
+			label: "Garph",
+			hint: "Fullstack GraphQL framework with end-to-end type safety"
+		},
+		none: {
+			value: "none",
+			label: "None",
+			hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
+		}
+	};
+	const apiOptions = allowed.map((a) => apiOptionMap[a]);
 	const apiType = await navigableSelect({
 		message: "Select API type",
 		options: apiOptions,
@@ -1128,41 +1256,54 @@ async function getAuthChoice(auth, backend, frontend) {
 			"native-uniwind",
 			"native-unistyles"
 		].includes(f));
-		const options = [];
-		if (supportedBetterAuthFrontends) options.push({
+		const options$1 = [];
+		if (supportedBetterAuthFrontends) options$1.push({
 			value: "better-auth",
 			label: "Better-Auth",
 			hint: "comprehensive auth framework for TypeScript"
 		});
-		if (hasClerkCompatibleFrontends) options.push({
+		if (hasClerkCompatibleFrontends) options$1.push({
 			value: "clerk",
 			label: "Clerk",
 			hint: "More than auth, Complete User Management"
 		});
-		if (options.length === 0) return "none";
-		options.push({
+		if (options$1.length === 0) return "none";
+		options$1.push({
 			value: "none",
 			label: "None",
 			hint: "No auth"
 		});
 		const response$1 = await navigableSelect({
 			message: "Select authentication provider",
-			options,
+			options: options$1,
 			initialValue: "none"
 		});
 		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
 		return response$1;
 	}
+	const supportsNextAuth = frontend?.includes("next") && backend === "self";
+	const options = [{
+		value: "better-auth",
+		label: "Better-Auth",
+		hint: "comprehensive auth framework for TypeScript"
+	}, {
+		value: "clerk",
+		label: "Clerk",
+		hint: "More than auth, Complete User Management"
+	}];
+	if (supportsNextAuth) options.push({
+		value: "nextauth",
+		label: "Auth.js (NextAuth)",
+		hint: "Authentication for Next.js (formerly NextAuth.js)"
+	});
+	options.push({
+		value: "none",
+		label: "None",
+		hint: "No authentication"
+	});
 	const response = await navigableSelect({
 		message: "Select authentication provider",
-		options: [{
-			value: "better-auth",
-			label: "Better-Auth",
-			hint: "comprehensive auth framework for TypeScript"
-		}, {
-			value: "none",
-			label: "None"
-		}],
+		options,
 		initialValue: DEFAULT_CONFIG.auth
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
@@ -1206,6 +1347,22 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 		value: "fets",
 		label: "feTS",
 		hint: "TypeScript HTTP Framework with e2e type-safety"
+	}, {
+		value: "nestjs",
+		label: "NestJS",
+		hint: "Progressive Node.js framework for scalable applications"
+	}, {
+		value: "adonisjs",
+		label: "AdonisJS",
+		hint: "Full-featured MVC framework for Node.js"
+	}, {
+		value: "nitro",
+		label: "Nitro",
+		hint: "Universal server framework from UnJS"
+	}, {
+		value: "encore",
+		label: "Encore",
+		hint: "Backend development platform with built-in infrastructure"
 	});
 	if (!hasIncompatibleFrontend) backendOptions.push({
 		value: "convex",
@@ -1226,6 +1383,63 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/caching.ts
+async function getCachingChoice(caching, backend) {
+	if (caching !== void 0) return caching;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select caching solution",
+		options: [{
+			value: "upstash-redis",
+			label: "Upstash Redis",
+			hint: "Serverless Redis with REST API for edge and serverless"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "Skip caching layer setup"
+		}],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/prompts/cms.ts
+async function getCMSChoice(cms, backend) {
+	if (cms !== void 0) return cms;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select headless CMS",
+		options: [
+			{
+				value: "payload",
+				label: "Payload",
+				hint: "TypeScript-first headless CMS with Next.js integration"
+			},
+			{
+				value: "sanity",
+				label: "Sanity",
+				hint: "Real-time collaborative CMS with schema-as-code"
+			},
+			{
+				value: "strapi",
+				label: "Strapi",
+				hint: "Open-source headless CMS with admin panel"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip headless CMS setup"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/css-framework.ts
 const CSS_FRAMEWORK_OPTIONS = {
@@ -1407,6 +1621,27 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/ecosystem.ts
+async function getEcosystemChoice(ecosystem) {
+	if (ecosystem !== void 0) return ecosystem;
+	const response = await navigableSelect({
+		message: "Select ecosystem",
+		options: [{
+			value: "typescript",
+			label: "TypeScript",
+			hint: "Full-stack TypeScript with React, Vue, Svelte, and more"
+		}, {
+			value: "rust",
+			label: "Rust",
+			hint: "Rust ecosystem with Axum, Leptos, and more"
+		}],
+		initialValue: "typescript"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/effect.ts
 async function getEffectChoice(effect) {
@@ -1455,6 +1690,36 @@ async function getEmailChoice(email, backend) {
 				label: "React Email",
 				hint: "Build emails using React components (no sending service)."
 			},
+			{
+				value: "nodemailer",
+				label: "Nodemailer",
+				hint: "Classic Node.js email sending library."
+			},
+			{
+				value: "postmark",
+				label: "Postmark",
+				hint: "Transactional email service with high deliverability."
+			},
+			{
+				value: "sendgrid",
+				label: "SendGrid",
+				hint: "Email delivery and marketing platform by Twilio."
+			},
+			{
+				value: "aws-ses",
+				label: "AWS SES",
+				hint: "Amazon Simple Email Service for scalable email."
+			},
+			{
+				value: "mailgun",
+				label: "Mailgun",
+				hint: "Email API service for sending and tracking emails."
+			},
+			{
+				value: "plunk",
+				label: "Plunk",
+				hint: "Open-source email platform for developers."
+			},
 			{
 				value: "none",
 				label: "None",
@@ -1495,6 +1760,98 @@ async function getExamplesChoice(examples, database, frontends, backend, api) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/file-upload.ts
+async function getFileUploadChoice(fileUpload, backend) {
+	if (fileUpload !== void 0) return fileUpload;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select file upload solution",
+		options: [
+			{
+				value: "uploadthing",
+				label: "UploadThing",
+				hint: "TypeScript-first file uploads with built-in validation"
+			},
+			{
+				value: "filepond",
+				label: "FilePond",
+				hint: "Flexible file upload with image preview and drag & drop"
+			},
+			{
+				value: "uppy",
+				label: "Uppy",
+				hint: "Modular file uploader with resumable uploads and plugins"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip file upload integration"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/prompts/forms.ts
+async function getFormsChoice(forms, frontends) {
+	if (forms !== void 0) return forms;
+	const { web } = splitFrontends(frontends);
+	if (web.length === 0) return "none";
+	const isReact = web.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next",
+		"redwood"
+	].includes(f));
+	const isSolid = web.includes("solid");
+	const isQwik = web.includes("qwik");
+	const options = [];
+	if (isReact) options.push({
+		value: "react-hook-form",
+		label: "React Hook Form",
+		hint: "Performant, flexible form validation library"
+	}, {
+		value: "formik",
+		label: "Formik",
+		hint: "Popular form state management with Yup validation"
+	}, {
+		value: "final-form",
+		label: "Final Form",
+		hint: "Framework-agnostic form state management"
+	}, {
+		value: "conform",
+		label: "Conform",
+		hint: "Progressive enhancement forms with Zod validation"
+	});
+	options.push({
+		value: "tanstack-form",
+		label: "TanStack Form",
+		hint: "Fully-typed, framework-agnostic form library"
+	});
+	if (isSolid || isQwik) options.push({
+		value: "modular-forms",
+		label: "Modular Forms",
+		hint: "Type-safe forms for Solid and Qwik (3KB bundle)"
+	});
+	options.push({
+		value: "none",
+		label: "None",
+		hint: "Build custom form handling"
+	});
+	const response = await navigableSelect({
+		message: "Select form library",
+		options,
+		initialValue: isReact ? "react-hook-form" : "tanstack-form"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/frontend.ts
 async function getFrontendChoice(frontendOptions, backend, auth) {
@@ -1563,6 +1920,26 @@ async function getFrontendChoice(frontendOptions, backend, auth) {
 						value: "tanstack-start",
 						label: "TanStack Start",
 						hint: "SSR, Server Functions, API Routes and more with TanStack Router"
+					},
+					{
+						value: "qwik",
+						label: "Qwik",
+						hint: "Resumable framework with instant load times"
+					},
+					{
+						value: "angular",
+						label: "Angular",
+						hint: "Enterprise-grade TypeScript framework by Google"
+					},
+					{
+						value: "redwood",
+						label: "RedwoodJS",
+						hint: "Opinionated fullstack (React + GraphQL + Prisma)"
+					},
+					{
+						value: "fresh",
+						label: "Fresh",
+						hint: "Deno-native framework with islands architecture"
 					}
 				].filter((option) => isFrontendAllowedWithBackend(option.value, backend, auth)),
 				initialValue: DEFAULT_CONFIG.frontend[0]
@@ -1637,6 +2014,76 @@ async function getinstallChoice(install) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/job-queue.ts
+async function getJobQueueChoice(jobQueue, backend) {
+	if (jobQueue !== void 0) return jobQueue;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select job queue solution",
+		options: [
+			{
+				value: "bullmq",
+				label: "BullMQ",
+				hint: "Redis-backed job queue for background tasks and scheduling"
+			},
+			{
+				value: "trigger-dev",
+				label: "Trigger.dev",
+				hint: "Background jobs as code with serverless execution"
+			},
+			{
+				value: "inngest",
+				label: "Inngest",
+				hint: "Event-driven functions with built-in queuing and scheduling"
+			},
+			{
+				value: "temporal",
+				label: "Temporal",
+				hint: "Durable workflow orchestration for reliable distributed systems"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip job queue/background worker setup"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/prompts/logging.ts
+async function getLoggingChoice(logging, backend) {
+	if (logging !== void 0) return logging;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select logging framework",
+		options: [
+			{
+				value: "pino",
+				label: "Pino",
+				hint: "Fast JSON logger with minimal overhead"
+			},
+			{
+				value: "winston",
+				label: "Winston",
+				hint: "Flexible logging library with multiple transports"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip logging framework setup"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/navigable-group.ts
 /**
@@ -1694,6 +2141,28 @@ async function navigableGroup(prompts, opts) {
 	return results;
 }
 
+//#endregion
+//#region src/prompts/observability.ts
+async function getObservabilityChoice(observability, backend) {
+	if (observability !== void 0) return observability;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select observability solution",
+		options: [{
+			value: "opentelemetry",
+			label: "OpenTelemetry",
+			hint: "Observability framework for traces, metrics, and logs"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "Skip observability/tracing setup"
+		}],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/orm.ts
 const ormOptions = {
@@ -1787,24 +2256,93 @@ async function getPackageManagerChoice(packageManager) {
 async function getPaymentsChoice(payments, auth, backend, frontends) {
 	if (payments !== void 0) return payments;
 	if (backend === "none") return "none";
-	if (!(auth === "better-auth" && backend !== "convex" && (frontends?.length === 0 || splitFrontends(frontends).web.length > 0))) return "none";
+	const isPolarCompatible = auth === "better-auth" && backend !== "convex" && (frontends?.length === 0 || splitFrontends(frontends).web.length > 0);
+	const options = [];
+	if (isPolarCompatible) options.push({
+		value: "polar",
+		label: "Polar",
+		hint: "Turn your software into a business. 6 lines of code."
+	});
+	options.push({
+		value: "stripe",
+		label: "Stripe",
+		hint: "Payment processing platform for internet businesses."
+	}, {
+		value: "lemon-squeezy",
+		label: "Lemon Squeezy",
+		hint: "All-in-one platform for SaaS, digital products, and subscriptions."
+	}, {
+		value: "paddle",
+		label: "Paddle",
+		hint: "Complete payments infrastructure for SaaS."
+	}, {
+		value: "dodo",
+		label: "Dodo Payments",
+		hint: "Simple payment infrastructure for developers."
+	}, {
+		value: "none",
+		label: "None",
+		hint: "No payments integration"
+	});
 	const response = await navigableSelect({
 		message: "Select payments provider",
-		options: [{
-			value: "polar",
-			label: "Polar",
-			hint: "Turn your software into a business. 6 lines of code."
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No payments integration"
-		}],
+		options,
 		initialValue: DEFAULT_CONFIG.payments
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
+//#endregion
+//#region src/prompts/realtime.ts
+async function getRealtimeChoice(realtime, backend) {
+	if (realtime !== void 0) return realtime;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select real-time solution",
+		options: [
+			{
+				value: "socket-io",
+				label: "Socket.IO",
+				hint: "Real-time bidirectional communication with fallbacks"
+			},
+			{
+				value: "partykit",
+				label: "PartyKit",
+				hint: "Edge-native multiplayer infrastructure on Cloudflare"
+			},
+			{
+				value: "ably",
+				label: "Ably",
+				hint: "Real-time messaging platform with pub/sub and presence"
+			},
+			{
+				value: "pusher",
+				label: "Pusher",
+				hint: "Real-time communication APIs with channels and events"
+			},
+			{
+				value: "liveblocks",
+				label: "Liveblocks",
+				hint: "Collaboration infrastructure for multiplayer experiences"
+			},
+			{
+				value: "yjs",
+				label: "Y.js",
+				hint: "CRDT library for real-time collaboration with conflict-free sync"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip real-time/WebSocket integration"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/runtime.ts
 async function getRuntimeChoice(runtime, backend) {
@@ -1833,6 +2371,181 @@ async function getRuntimeChoice(runtime, backend) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/rust-ecosystem.ts
+async function getRustWebFrameworkChoice(rustWebFramework) {
+	if (rustWebFramework !== void 0) return rustWebFramework;
+	const response = await navigableSelect({
+		message: "Select Rust web framework",
+		options: [
+			{
+				value: "axum",
+				label: "Axum",
+				hint: "Ergonomic and modular web framework from Tokio"
+			},
+			{
+				value: "actix-web",
+				label: "Actix Web",
+				hint: "Powerful, pragmatic, and extremely fast web framework"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No web framework"
+			}
+		],
+		initialValue: "axum"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustFrontendChoice(rustFrontend) {
+	if (rustFrontend !== void 0) return rustFrontend;
+	const response = await navigableSelect({
+		message: "Select Rust frontend framework",
+		options: [
+			{
+				value: "leptos",
+				label: "Leptos",
+				hint: "Build fast web applications with Rust"
+			},
+			{
+				value: "dioxus",
+				label: "Dioxus",
+				hint: "Fullstack, cross-platform UI library for Rust"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No Rust frontend (API only)"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustOrmChoice(rustOrm) {
+	if (rustOrm !== void 0) return rustOrm;
+	const response = await navigableSelect({
+		message: "Select Rust ORM/database layer",
+		options: [
+			{
+				value: "sea-orm",
+				label: "SeaORM",
+				hint: "Async & dynamic ORM for Rust"
+			},
+			{
+				value: "sqlx",
+				label: "SQLx",
+				hint: "Async SQL toolkit with compile-time checked queries"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No database layer"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustApiChoice(rustApi) {
+	if (rustApi !== void 0) return rustApi;
+	const response = await navigableSelect({
+		message: "Select Rust API layer",
+		options: [
+			{
+				value: "tonic",
+				label: "Tonic",
+				hint: "gRPC implementation for Rust"
+			},
+			{
+				value: "async-graphql",
+				label: "async-graphql",
+				hint: "High-performance GraphQL server library"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "REST API only"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustCliChoice(rustCli) {
+	if (rustCli !== void 0) return rustCli;
+	const response = await navigableSelect({
+		message: "Select Rust CLI tools",
+		options: [
+			{
+				value: "clap",
+				label: "Clap",
+				hint: "Command Line Argument Parser for Rust"
+			},
+			{
+				value: "ratatui",
+				label: "Ratatui",
+				hint: "Build rich terminal user interfaces"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No CLI tools"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustLibrariesChoice(rustLibraries) {
+	if (rustLibraries !== void 0) return rustLibraries;
+	const response = await navigableMultiselect({
+		message: "Select Rust libraries",
+		options: [
+			{
+				value: "serde",
+				label: "Serde",
+				hint: "Serialization framework for Rust"
+			},
+			{
+				value: "validator",
+				label: "Validator",
+				hint: "Struct validation derive macros"
+			},
+			{
+				value: "jsonwebtoken",
+				label: "jsonwebtoken",
+				hint: "JWT encoding/decoding library"
+			},
+			{
+				value: "argon2",
+				label: "Argon2",
+				hint: "Password hashing library"
+			},
+			{
+				value: "tokio-test",
+				label: "Tokio Test",
+				hint: "Testing utilities for Tokio"
+			},
+			{
+				value: "mockall",
+				label: "Mockall",
+				hint: "Powerful mocking library for Rust"
+			}
+		],
+		required: false,
+		initialValues: ["serde"]
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/server-deploy.ts
 async function getServerDeploymentChoice(deployment, runtime, backend, _webDeploy) {
@@ -1843,6 +2556,115 @@ async function getServerDeploymentChoice(deployment, runtime, backend, _webDeplo
 	return "none";
 }
 
+//#endregion
+//#region src/prompts/state-management.ts
+async function getStateManagementChoice(stateManagement, frontends) {
+	if (stateManagement !== void 0) return stateManagement;
+	const { web } = splitFrontends(frontends);
+	if (web.length === 0) return "none";
+	const isReact = web.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next",
+		"redwood"
+	].includes(f));
+	const options = [];
+	if (isReact) options.push({
+		value: "zustand",
+		label: "Zustand",
+		hint: "Lightweight state management with simple API"
+	}, {
+		value: "jotai",
+		label: "Jotai",
+		hint: "Primitive and flexible atomic state"
+	}, {
+		value: "redux-toolkit",
+		label: "Redux Toolkit",
+		hint: "Enterprise-standard state with excellent TS support"
+	}, {
+		value: "valtio",
+		label: "Valtio",
+		hint: "Proxy-based state management"
+	}, {
+		value: "legend-state",
+		label: "Legend State",
+		hint: "High-performance observable state for React"
+	}, {
+		value: "mobx",
+		label: "MobX",
+		hint: "Observable-based reactive state management"
+	});
+	options.push({
+		value: "nanostores",
+		label: "Nanostores",
+		hint: "Tiny state manager (1KB) for all frameworks"
+	}, {
+		value: "xstate",
+		label: "XState",
+		hint: "State machines and statecharts for complex logic"
+	}, {
+		value: "tanstack-store",
+		label: "TanStack Store",
+		hint: "Framework-agnostic store powering TanStack ecosystem"
+	}, {
+		value: "none",
+		label: "None",
+		hint: "Skip state management setup"
+	});
+	const response = await navigableSelect({
+		message: "Select state management",
+		options,
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/prompts/testing.ts
+async function getTestingChoice(testing) {
+	if (testing !== void 0) return testing;
+	const response = await navigableSelect({
+		message: "Select testing framework",
+		options: [
+			{
+				value: "vitest",
+				label: "Vitest",
+				hint: "Blazing fast Vite-native unit test framework"
+			},
+			{
+				value: "vitest-playwright",
+				label: "Vitest + Playwright",
+				hint: "Both unit and E2E testing for complete coverage"
+			},
+			{
+				value: "playwright",
+				label: "Playwright",
+				hint: "End-to-end testing framework by Microsoft"
+			},
+			{
+				value: "jest",
+				label: "Jest",
+				hint: "Classic testing framework with wide ecosystem"
+			},
+			{
+				value: "cypress",
+				label: "Cypress",
+				hint: "E2E testing with time travel debugging"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip testing framework setup"
+			}
+		],
+		initialValue: "vitest"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/ui-library.ts
 const UI_LIBRARY_OPTIONS = {
@@ -1915,6 +2737,60 @@ async function getUILibraryChoice(uiLibrary, frontends) {
 	return selected;
 }
 
+//#endregion
+//#region src/prompts/validation.ts
+async function getValidationChoice(validation) {
+	if (validation !== void 0) return validation;
+	const response = await navigableSelect({
+		message: "Select validation library",
+		options: [
+			{
+				value: "zod",
+				label: "Zod",
+				hint: "TypeScript-first schema validation (recommended)"
+			},
+			{
+				value: "valibot",
+				label: "Valibot",
+				hint: "Smaller bundle alternative to Zod (~1KB)"
+			},
+			{
+				value: "arktype",
+				label: "ArkType",
+				hint: "TypeScript-first validation, 2-4x faster than Zod"
+			},
+			{
+				value: "typebox",
+				label: "TypeBox",
+				hint: "JSON Schema type builder for TypeScript"
+			},
+			{
+				value: "typia",
+				label: "Typia",
+				hint: "Super-fast validation via compile-time transform"
+			},
+			{
+				value: "runtypes",
+				label: "Runtypes",
+				hint: "Runtime type validation with composable validators"
+			},
+			{
+				value: "effect-schema",
+				label: "@effect/schema",
+				hint: "Effect ecosystem schema validation with powerful transformations"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Use Zod internally only (no additional library)"
+			}
+		],
+		initialValue: "zod"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/web-deploy.ts
 function hasWebFrontend(frontends) {
@@ -1953,33 +2829,158 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 //#region src/prompts/config-prompts.ts
 async function gatherConfig(flags, projectName, projectDir, relativePath) {
 	const result = await navigableGroup({
-		frontend: () => getFrontendChoice(flags.frontend, flags.backend, flags.auth),
+		ecosystem: () => getEcosystemChoice(flags.ecosystem),
+		frontend: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve([]);
+			return getFrontendChoice(flags.frontend, flags.backend, flags.auth);
+		},
 		astroIntegration: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve(void 0);
 			if (results.frontend?.includes("astro")) return getAstroIntegrationChoice(flags.astroIntegration);
 			return Promise.resolve(void 0);
 		},
 		uiLibrary: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
 			if (hasWebStyling(results.frontend)) return getUILibraryChoice(flags.uiLibrary, results.frontend);
 			return Promise.resolve("none");
 		},
 		cssFramework: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
 			if (hasWebStyling(results.frontend)) return getCSSFrameworkChoice(flags.cssFramework, results.uiLibrary);
 			return Promise.resolve("none");
 		},
-		backend: ({ results }) => getBackendFrameworkChoice(flags.backend, results.frontend),
-		runtime: ({ results }) => getRuntimeChoice(flags.runtime, results.backend),
-		database: ({ results }) => getDatabaseChoice(flags.database, results.backend, results.runtime),
-		orm: ({ results }) => getORMChoice(flags.orm, results.database !== "none", results.database, results.backend, results.runtime),
-		api: ({ results }) => getApiChoice(flags.api, results.frontend, results.backend, results.astroIntegration),
-		auth: ({ results }) => getAuthChoice(flags.auth, results.backend, results.frontend),
-		payments: ({ results }) => getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend),
-		email: ({ results }) => getEmailChoice(flags.email, results.backend),
-		effect: () => getEffectChoice(flags.effect),
-		addons: ({ results }) => getAddonsChoice(flags.addons, results.frontend, results.auth),
-		examples: ({ results }) => getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api),
-		dbSetup: ({ results }) => getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime),
-		webDeploy: ({ results }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend),
-		serverDeploy: ({ results }) => getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy),
+		backend: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getBackendFrameworkChoice(flags.backend, results.frontend);
+		},
+		runtime: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getRuntimeChoice(flags.runtime, results.backend);
+		},
+		database: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getDatabaseChoice(flags.database, results.backend, results.runtime);
+		},
+		orm: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getORMChoice(flags.orm, results.database !== "none", results.database, results.backend, results.runtime);
+		},
+		api: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getApiChoice(flags.api, results.frontend, results.backend, results.astroIntegration);
+		},
+		auth: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getAuthChoice(flags.auth, results.backend, results.frontend);
+		},
+		payments: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend);
+		},
+		email: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getEmailChoice(flags.email, results.backend);
+		},
+		effect: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getEffectChoice(flags.effect);
+		},
+		addons: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve([]);
+			return getAddonsChoice(flags.addons, results.frontend, results.auth);
+		},
+		examples: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve([]);
+			return getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api);
+		},
+		dbSetup: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime);
+		},
+		webDeploy: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend);
+		},
+		serverDeploy: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy);
+		},
+		ai: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getAIChoice(flags.ai);
+		},
+		validation: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getValidationChoice(flags.validation);
+		},
+		forms: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getFormsChoice(flags.forms, results.frontend);
+		},
+		stateManagement: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getStateManagementChoice(flags.stateManagement, results.frontend);
+		},
+		animation: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getAnimationChoice(flags.animation, results.frontend);
+		},
+		testing: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getTestingChoice(flags.testing);
+		},
+		realtime: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getRealtimeChoice(flags.realtime, results.backend);
+		},
+		jobQueue: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getJobQueueChoice(flags.jobQueue, results.backend);
+		},
+		fileUpload: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getFileUploadChoice(flags.fileUpload, results.backend);
+		},
+		logging: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getLoggingChoice(flags.logging, results.backend);
+		},
+		observability: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getObservabilityChoice(flags.observability, results.backend);
+		},
+		cms: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getCMSChoice(flags.cms, results.backend);
+		},
+		caching: ({ results }) => {
+			if (results.ecosystem === "rust") return Promise.resolve("none");
+			return getCachingChoice(flags.caching, results.backend);
+		},
+		rustWebFramework: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			return getRustWebFrameworkChoice(flags.rustWebFramework);
+		},
+		rustFrontend: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			return getRustFrontendChoice(flags.rustFrontend);
+		},
+		rustOrm: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			return getRustOrmChoice(flags.rustOrm);
+		},
+		rustApi: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			return getRustApiChoice(flags.rustApi);
+		},
+		rustCli: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			return getRustCliChoice(flags.rustCli);
+		},
+		rustLibraries: ({ results }) => {
+			if (results.ecosystem === "typescript") return Promise.resolve([]);
+			return getRustLibrariesChoice(flags.rustLibraries);
+		},
 		git: () => getGitChoice(flags.git),
 		packageManager: () => getPackageManagerChoice(flags.packageManager),
 		install: () => getinstallChoice(flags.install)
@@ -2009,26 +3010,26 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		api: result.api,
 		webDeploy: result.webDeploy,
 		serverDeploy: result.serverDeploy,
-		ai: flags.ai ?? "none",
-		stateManagement: flags.stateManagement ?? "none",
-		validation: flags.validation ?? "zod",
-		forms: flags.forms ?? "react-hook-form",
-		testing: flags.testing ?? "vitest",
-		realtime: flags.realtime ?? "none",
-		jobQueue: flags.jobQueue ?? "none",
-		animation: flags.animation ?? "none",
-		fileUpload: flags.fileUpload ?? "none",
-		logging: flags.logging ?? "none",
-		observability: flags.observability ?? "none",
-		cms: flags.cms ?? "none",
-		caching: flags.caching ?? "none",
-		ecosystem: flags.ecosystem ?? "typescript",
-		rustWebFramework: flags.rustWebFramework ?? "none",
-		rustFrontend: flags.rustFrontend ?? "none",
-		rustOrm: flags.rustOrm ?? "none",
-		rustApi: flags.rustApi ?? "none",
-		rustCli: flags.rustCli ?? "none",
-		rustLibraries: flags.rustLibraries ?? []
+		ai: result.ai,
+		stateManagement: result.stateManagement,
+		validation: result.validation,
+		forms: result.forms,
+		testing: result.testing,
+		realtime: result.realtime,
+		jobQueue: result.jobQueue,
+		animation: result.animation,
+		fileUpload: result.fileUpload,
+		logging: result.logging,
+		observability: result.observability,
+		cms: result.cms,
+		caching: result.caching,
+		ecosystem: result.ecosystem,
+		rustWebFramework: result.rustWebFramework,
+		rustFrontend: result.rustFrontend,
+		rustOrm: result.rustOrm,
+		rustApi: result.rustApi,
+		rustCli: result.rustCli,
+		rustLibraries: result.rustLibraries
 	};
 }
 
@@ -2302,24 +3303,17 @@ const TITLE_TEXT = `
  ██║     ╚██████╔╝███████╗███████╗███████║   ██║   ██║  ██║╚██████╗██║  ██╗
  ╚═╝      ╚═════╝ ╚══════╝╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
  `;
-const catppuccinTheme = {
-	pink: "#F5C2E7",
-	mauve: "#CBA6F7",
-	red: "#F38BA8",
-	maroon: "#E78284",
-	peach: "#FAB387",
-	yellow: "#F9E2AF",
-	green: "#A6E3A1",
-	teal: "#94E2D5",
-	sky: "#89DCEB",
-	sapphire: "#74C7EC",
-	lavender: "#B4BEFE"
+const monochromeTheme = {
+	white: "#FFFFFF",
+	lightGray: "#E5E5E5",
+	gray: "#A3A3A3",
+	darkGray: "#737373"
 };
 const renderTitle = () => {
 	const terminalWidth = process.stdout.columns || 80;
 	const titleLines = TITLE_TEXT.split("\n");
-	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(catppuccinTheme)).multiline(`Better Fullstack`));
-	else console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
+	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(monochromeTheme)).multiline(`Better Fullstack`));
+	else console.log(gradient(Object.values(monochromeTheme)).multiline(TITLE_TEXT));
 };
 
 //#endregion
@@ -5148,6 +6142,8 @@ const router = os.router({
 		animation: types_exports.AnimationSchema.optional(),
 		logging: types_exports.LoggingSchema.optional(),
 		observability: types_exports.ObservabilitySchema.optional(),
+		cms: types_exports.CMSSchema.optional().describe("Headless CMS solution"),
+		caching: types_exports.CachingSchema.optional().describe("Caching solution"),
 		frontend: z.array(types_exports.FrontendSchema).optional(),
 		addons: z.array(types_exports.AddonsSchema).optional(),
 		examples: z.array(types_exports.ExamplesSchema).optional(),