create-better-fullstack 1.1.12 → 1.1.15

package/dist/{src-BVho5D9n.mjs → src-DDAojCKV.mjs}

@@ -211,8 +211,8 @@ const __filename = fileURLToPath(import.meta.url);
 const distPath = path$1.dirname(__filename);
 const PKG_ROOT = path$1.join(distPath, "../");
 const DEFAULT_CONFIG_BASE = {
-	projectName: "my-better-t-app",
-	relativePath: "my-better-t-app",
+	projectName: "my-app",
+	relativePath: "my-app",
 	ecosystem: "typescript",
 	frontend: ["tanstack-router"],
 	database: "sqlite",
@@ -230,9 +230,13 @@ const DEFAULT_CONFIG_BASE = {
 	realtime: "none",
 	jobQueue: "none",
 	caching: "none",
+	search: "none",
+	fileStorage: "none",
 	animation: "none",
 	logging: "none",
 	observability: "none",
+	featureFlags: "none",
+	analytics: "none",
 	cms: "none",
 	addons: ["turborepo"],
 	examples: [],
@@ -251,7 +255,18 @@ const DEFAULT_CONFIG_BASE = {
 	rustOrm: "none",
 	rustApi: "none",
 	rustCli: "none",
-	rustLibraries: []
+	rustLibraries: [],
+	pythonWebFramework: "fastapi",
+	pythonOrm: "sqlalchemy",
+	pythonValidation: "pydantic",
+	pythonAi: [],
+	pythonTaskQueue: "none",
+	pythonQuality: "ruff",
+	goWebFramework: "gin",
+	goOrm: "gorm",
+	goApi: "none",
+	goCli: "none",
+	goLogging: "zap"
 };
 function getDefaultConfig() {
 	return {
@@ -261,7 +276,8 @@ function getDefaultConfig() {
 		frontend: [...DEFAULT_CONFIG_BASE.frontend],
 		addons: [...DEFAULT_CONFIG_BASE.addons],
 		examples: [...DEFAULT_CONFIG_BASE.examples],
-		rustLibraries: [...DEFAULT_CONFIG_BASE.rustLibraries]
+		rustLibraries: [...DEFAULT_CONFIG_BASE.rustLibraries],
+		pythonAi: [...DEFAULT_CONFIG_BASE.pythonAi]
 	};
 }
 const DEFAULT_CONFIG = getDefaultConfig();
@@ -322,7 +338,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: ["tailwind"]
 	},
@@ -348,7 +365,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -364,7 +382,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"react-router",
 			"tanstack-start",
 			"next",
-			"nuxt"
+			"nuxt",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -381,7 +400,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-start",
 			"next",
 			"nuxt",
-			"solid"
+			"solid",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -395,7 +415,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -410,7 +431,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: ["tailwind"]
 	},
@@ -419,7 +441,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -434,7 +457,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -452,7 +476,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"next",
 			"nuxt",
 			"svelte",
-			"solid"
+			"solid",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -467,7 +492,8 @@ const UI_LIBRARY_COMPATIBILITY = {
 			"tanstack-router",
 			"react-router",
 			"tanstack-start",
-			"next"
+			"next",
+			"astro"
 		],
 		cssFrameworks: [
 			"tailwind",
@@ -870,6 +896,10 @@ function isFrontendAllowedWithBackend(frontend, backend, auth) {
 		if (frontend !== "next") return false;
 		if (backend !== "self") return false;
 	}
+	if (auth === "supabase-auth") {
+		if (frontend !== "next") return false;
+		if (backend !== "self") return false;
+	}
 	return true;
 }
 function validateNextAuthCompatibility(auth, backend, frontends = []) {
@@ -878,6 +908,24 @@ function validateNextAuthCompatibility(auth, backend, frontends = []) {
 	if (backend !== "self") exitWithError("Auth.js (NextAuth) is only supported with the 'self' backend (fullstack Next.js). Please use '--backend self' or choose a different auth provider.");
 	if (!hasNextJs) exitWithError("Auth.js (NextAuth) requires Next.js frontend. Please use '--frontend next' or choose a different auth provider.");
 }
+function validateStackAuthCompatibility(auth, backend, frontends = []) {
+	if (auth !== "stack-auth") return;
+	const hasNextJs = frontends.includes("next");
+	if (backend !== "self") exitWithError("Stack Auth is only supported with the 'self' backend (fullstack Next.js). Please use '--backend self' or choose a different auth provider.");
+	if (!hasNextJs) exitWithError("Stack Auth requires Next.js frontend. Please use '--frontend next' or choose a different auth provider.");
+}
+function validateSupabaseAuthCompatibility(auth, backend, frontends = []) {
+	if (auth !== "supabase-auth") return;
+	const hasNextJs = frontends.includes("next");
+	if (backend !== "self") exitWithError("Supabase Auth is only supported with the 'self' backend (fullstack Next.js). Please use '--backend self' or choose a different auth provider.");
+	if (!hasNextJs) exitWithError("Supabase Auth requires Next.js frontend. Please use '--frontend next' or choose a different auth provider.");
+}
+function validateAuth0Compatibility(auth, backend, frontends = []) {
+	if (auth !== "auth0") return;
+	const hasNextJs = frontends.includes("next");
+	if (backend !== "self") exitWithError("Auth0 is only supported with the 'self' backend (fullstack Next.js). Please use '--backend self' or choose a different auth provider.");
+	if (!hasNextJs) exitWithError("Auth0 requires Next.js frontend. Please use '--frontend next' or choose a different auth provider.");
+}
 function allowedApisForFrontends(frontends = [], astroIntegration) {
 	const includesNuxt = frontends.includes("nuxt");
 	const includesSvelte = frontends.includes("svelte");
@@ -972,15 +1020,23 @@ function validateUILibraryFrontendCompatibility(uiLibrary, frontends = [], astro
 	const compatibility = UI_LIBRARY_COMPATIBILITY[uiLibrary];
 	const webFrontend = web[0];
 	if (webFrontend === "astro") {
+		const supportsReact = compatibility.frontends.some((f) => [
+			"tanstack-router",
+			"react-router",
+			"tanstack-start",
+			"next"
+		].includes(f));
+		const supportsNonReact = compatibility.frontends.some((f) => [
+			"nuxt",
+			"svelte",
+			"solid",
+			"qwik",
+			"angular"
+		].includes(f));
 		if (astroIntegration === "react") {
-			if (compatibility.frontends.some((f) => [
-				"tanstack-router",
-				"react-router",
-				"tanstack-start",
-				"next"
-			].includes(f))) return;
+			if (supportsReact) return;
 		}
-		if (!compatibility.frontends.includes("astro")) {
+		if (!supportsNonReact) {
 			const integrationName = astroIntegration || "none";
 			incompatibilityError({
 				message: `UI library '${uiLibrary}' requires React.`,
@@ -1029,7 +1085,13 @@ function getCompatibleUILibraries(frontends = [], astroIntegration) {
 				"next",
 				"astro"
 			].includes(f));
-			return compatibility.frontends.includes("astro");
+			return compatibility.frontends.some((f) => [
+				"nuxt",
+				"svelte",
+				"solid",
+				"qwik",
+				"angular"
+			].includes(f));
 		}
 		return compatibility.frontends.includes(webFrontend);
 	});
@@ -1663,7 +1725,7 @@ async function getAuthChoice(auth, backend, frontend) {
 		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
 		return response$1;
 	}
-	const supportsNextAuth = frontend?.includes("next") && backend === "self";
+	const supportsNextJsAuth = frontend?.includes("next") && backend === "self";
 	const options = [{
 		value: "better-auth",
 		label: "Better-Auth",
@@ -1673,11 +1735,28 @@ async function getAuthChoice(auth, backend, frontend) {
 		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)"
-	});
+	if (supportsNextJsAuth) {
+		options.push({
+			value: "nextauth",
+			label: "Auth.js (NextAuth)",
+			hint: "Authentication for Next.js (formerly NextAuth.js)"
+		});
+		options.push({
+			value: "stack-auth",
+			label: "Stack Auth",
+			hint: "Open-source Auth0/Clerk alternative"
+		});
+		options.push({
+			value: "supabase-auth",
+			label: "Supabase Auth",
+			hint: "Auth with Supabase platform integration"
+		});
+		options.push({
+			value: "auth0",
+			label: "Auth0",
+			hint: "Flexible identity platform for authentication"
+		});
+	}
 	options.push({
 		value: "none",
 		label: "None",
@@ -1889,11 +1968,23 @@ async function getDatabaseChoice(database, backend, runtime) {
 			hint: "popular open-source relational database system"
 		}
 	];
-	if (runtime !== "workers") databaseOptions.push({
-		value: "mongodb",
-		label: "MongoDB",
-		hint: "open-source NoSQL database that stores data in JSON-like documents called BSON"
-	});
+	if (runtime !== "workers") {
+		databaseOptions.push({
+			value: "mongodb",
+			label: "MongoDB",
+			hint: "open-source NoSQL database that stores data in JSON-like documents called BSON"
+		});
+		databaseOptions.push({
+			value: "edgedb",
+			label: "EdgeDB",
+			hint: "graph-relational database with built-in query builder (no ORM needed)"
+		});
+		databaseOptions.push({
+			value: "redis",
+			label: "Redis",
+			hint: "in-memory data store for caching, sessions, and real-time features"
+		});
+	}
 	const response = await navigableSelect({
 		message: "Select database",
 		options: databaseOptions,
@@ -1993,6 +2084,23 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
+	else if (databaseType === "redis") options = [
+		{
+			value: "upstash",
+			label: "Upstash",
+			hint: "Serverless Redis with REST API"
+		},
+		{
+			value: "docker",
+			label: "Docker",
+			hint: "Run locally with docker compose"
+		},
+		{
+			value: "none",
+			label: "None",
+			hint: "Manual setup"
+		}
+	];
 	else return "none";
 	const response = await navigableSelect({
 		message: `Select ${databaseType} setup option`,
@@ -2009,15 +2117,28 @@ 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"
-		}],
+		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"
+			},
+			{
+				value: "python",
+				label: "Python",
+				hint: "Python ecosystem with FastAPI, Django, and AI/ML tools"
+			},
+			{
+				value: "go",
+				label: "Go",
+				hint: "Go ecosystem with Gin, Echo, GORM, and more"
+			}
+		],
 		initialValue: "typescript"
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
@@ -2142,6 +2263,36 @@ async function getExamplesChoice(examples, database, frontends, backend, api) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/file-storage.ts
+async function getFileStorageChoice(fileStorage, backend) {
+	if (fileStorage !== void 0) return fileStorage;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select file storage",
+		options: [
+			{
+				value: "s3",
+				label: "AWS S3",
+				hint: "Amazon S3 object storage - scalable and reliable"
+			},
+			{
+				value: "r2",
+				label: "Cloudflare R2",
+				hint: "S3-compatible storage with zero egress fees"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip file storage setup"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/file-upload.ts
 async function getFileUploadChoice(fileUpload, backend) {
@@ -2384,6 +2535,123 @@ async function getGitChoice(git) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/go-ecosystem.ts
+async function getGoWebFrameworkChoice(goWebFramework) {
+	if (goWebFramework !== void 0) return goWebFramework;
+	const response = await navigableSelect({
+		message: "Select Go web framework",
+		options: [
+			{
+				value: "gin",
+				label: "Gin",
+				hint: "High-performance HTTP web framework with martini-like API"
+			},
+			{
+				value: "echo",
+				label: "Echo",
+				hint: "High performance, minimalist Go web framework"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No web framework"
+			}
+		],
+		initialValue: "gin"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getGoOrmChoice(goOrm) {
+	if (goOrm !== void 0) return goOrm;
+	const response = await navigableSelect({
+		message: "Select Go ORM/database layer",
+		options: [
+			{
+				value: "gorm",
+				label: "GORM",
+				hint: "The fantastic ORM library for Golang"
+			},
+			{
+				value: "sqlc",
+				label: "sqlc",
+				hint: "Generate type-safe Go code from SQL"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No ORM/database layer"
+			}
+		],
+		initialValue: "gorm"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getGoApiChoice(goApi) {
+	if (goApi !== void 0) return goApi;
+	const response = await navigableSelect({
+		message: "Select Go API layer",
+		options: [{
+			value: "grpc-go",
+			label: "gRPC-Go",
+			hint: "The Go implementation of gRPC"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No API layer"
+		}],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getGoCliChoice(goCli) {
+	if (goCli !== void 0) return goCli;
+	const response = await navigableSelect({
+		message: "Select Go CLI tools",
+		options: [
+			{
+				value: "cobra",
+				label: "Cobra",
+				hint: "Library for creating powerful modern CLI applications"
+			},
+			{
+				value: "bubbletea",
+				label: "Bubble Tea",
+				hint: "Powerful TUI framework based on The Elm Architecture"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No CLI tools"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getGoLoggingChoice(goLogging) {
+	if (goLogging !== void 0) return goLogging;
+	const response = await navigableSelect({
+		message: "Select Go logging library",
+		options: [{
+			value: "zap",
+			label: "Zap",
+			hint: "Blazing fast, structured, leveled logging in Go"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No logging library"
+		}],
+		initialValue: "zap"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/utils/command-exists.ts
 async function commandExists(command) {
@@ -2411,6 +2679,18 @@ async function getinstallChoice(install, ecosystem) {
 		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
 		return response$1;
 	}
+	if (ecosystem === "python") {
+		if (!await commandExists("uv")) {
+			log.warn("uv is not installed. Please install uv from https://docs.astral.sh/uv/");
+			return false;
+		}
+		const response$1 = await navigableConfirm({
+			message: "Run uv sync?",
+			initialValue: DEFAULT_CONFIG.install
+		});
+		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
+		return response$1;
+	}
 	const response = await navigableConfirm({
 		message: "Install dependencies?",
 		initialValue: DEFAULT_CONFIG.install
@@ -2553,15 +2833,28 @@ async function getObservabilityChoice(observability, backend) {
 	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"
-		}],
+		options: [
+			{
+				value: "opentelemetry",
+				label: "OpenTelemetry",
+				hint: "Observability framework for traces, metrics, and logs"
+			},
+			{
+				value: "sentry",
+				label: "Sentry",
+				hint: "Error tracking and performance monitoring"
+			},
+			{
+				value: "grafana",
+				label: "Grafana",
+				hint: "Prometheus metrics for Grafana dashboards and alerting"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip observability/tracing setup"
+			}
+		],
 		initialValue: "none"
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
@@ -2610,6 +2903,8 @@ const ormOptions = {
 async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
 	if (backend === "convex") return "none";
 	if (!hasDatabase) return "none";
+	if (database === "edgedb") return "none";
+	if (database === "redis") return "none";
 	if (orm !== void 0) return orm;
 	const response = await navigableSelect({
 		message: "Select ORM",
@@ -2698,6 +2993,157 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/python-ecosystem.ts
+async function getPythonWebFrameworkChoice(pythonWebFramework) {
+	if (pythonWebFramework !== void 0) return pythonWebFramework;
+	const response = await navigableSelect({
+		message: "Select Python web framework",
+		options: [
+			{
+				value: "fastapi",
+				label: "FastAPI",
+				hint: "Modern, fast (high-performance) web framework for building APIs"
+			},
+			{
+				value: "django",
+				label: "Django",
+				hint: "High-level Python web framework with batteries included"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No web framework"
+			}
+		],
+		initialValue: "fastapi"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getPythonOrmChoice(pythonOrm) {
+	if (pythonOrm !== void 0) return pythonOrm;
+	const response = await navigableSelect({
+		message: "Select Python ORM/database layer",
+		options: [
+			{
+				value: "sqlalchemy",
+				label: "SQLAlchemy",
+				hint: "The SQL toolkit and ORM for Python"
+			},
+			{
+				value: "sqlmodel",
+				label: "SQLModel",
+				hint: "SQL databases in Python with Pydantic and SQLAlchemy"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "No ORM/database layer"
+			}
+		],
+		initialValue: "sqlalchemy"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getPythonValidationChoice(pythonValidation) {
+	if (pythonValidation !== void 0) return pythonValidation;
+	const response = await navigableSelect({
+		message: "Select Python validation library",
+		options: [{
+			value: "pydantic",
+			label: "Pydantic",
+			hint: "Data validation using Python type hints"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No validation library"
+		}],
+		initialValue: "pydantic"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getPythonAiChoice(pythonAi) {
+	if (pythonAi !== void 0) return pythonAi;
+	const response = await navigableMultiselect({
+		message: "Select Python AI/ML frameworks",
+		options: [
+			{
+				value: "langchain",
+				label: "LangChain",
+				hint: "Building applications with LLMs through composability"
+			},
+			{
+				value: "llamaindex",
+				label: "LlamaIndex",
+				hint: "Data framework for LLM applications"
+			},
+			{
+				value: "openai-sdk",
+				label: "OpenAI SDK",
+				hint: "Official OpenAI Python client"
+			},
+			{
+				value: "anthropic-sdk",
+				label: "Anthropic SDK",
+				hint: "Official Anthropic Claude API client"
+			},
+			{
+				value: "langgraph",
+				label: "LangGraph",
+				hint: "Graph-based agent orchestration"
+			},
+			{
+				value: "crewai",
+				label: "CrewAI",
+				hint: "Multi-agent orchestration framework"
+			}
+		],
+		required: false,
+		initialValues: []
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getPythonTaskQueueChoice(pythonTaskQueue) {
+	if (pythonTaskQueue !== void 0) return pythonTaskQueue;
+	const response = await navigableSelect({
+		message: "Select Python task queue",
+		options: [{
+			value: "celery",
+			label: "Celery",
+			hint: "Distributed task queue for Python"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No task queue"
+		}],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getPythonQualityChoice(pythonQuality) {
+	if (pythonQuality !== void 0) return pythonQuality;
+	const response = await navigableSelect({
+		message: "Select Python code quality tool",
+		options: [{
+			value: "ruff",
+			label: "Ruff",
+			hint: "An extremely fast Python linter and formatter"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No code quality tools"
+		}],
+		initialValue: "ruff"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/realtime.ts
 async function getRealtimeChoice(realtime, backend) {
@@ -2951,6 +3397,36 @@ async function getRustLibrariesChoice(rustLibraries) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/search.ts
+async function getSearchChoice(search, backend) {
+	if (search !== void 0) return search;
+	if (backend === "none" || backend === "convex") return "none";
+	const response = await navigableSelect({
+		message: "Select search engine",
+		options: [
+			{
+				value: "meilisearch",
+				label: "Meilisearch",
+				hint: "Lightning-fast search engine with typo tolerance"
+			},
+			{
+				value: "typesense",
+				label: "Typesense",
+				hint: "Fast, typo-tolerant search with built-in vector search"
+			},
+			{
+				value: "none",
+				label: "None",
+				hint: "Skip search engine setup"
+			}
+		],
+		initialValue: "none"
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/server-deploy.ts
 async function getServerDeploymentChoice(deployment, runtime, backend, _webDeploy) {
@@ -3236,159 +3712,219 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 	const result = await navigableGroup({
 		ecosystem: () => getEcosystemChoice(flags.ecosystem),
 		frontend: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve([]);
+			if (results.ecosystem !== "typescript") return Promise.resolve([]);
 			return getFrontendChoice(flags.frontend, flags.backend, flags.auth);
 		},
 		astroIntegration: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve(void 0);
+			if (results.ecosystem !== "typescript") 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 (results.ecosystem !== "typescript") return Promise.resolve("none");
 			if (hasWebStyling(results.frontend)) return getUILibraryChoice(flags.uiLibrary, results.frontend, results.astroIntegration);
 			return Promise.resolve("none");
 		},
 		cssFramework: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			if (hasWebStyling(results.frontend)) return getCSSFrameworkChoice(flags.cssFramework, results.uiLibrary);
 			return Promise.resolve("none");
 		},
 		backend: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getBackendFrameworkChoice(flags.backend, results.frontend);
 		},
 		runtime: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getRuntimeChoice(flags.runtime, results.backend);
 		},
 		database: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getDatabaseChoice(flags.database, results.backend, results.runtime);
 		},
 		orm: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") 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");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getApiChoice(flags.api, results.frontend, results.backend, results.astroIntegration);
 		},
 		auth: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getAuthChoice(flags.auth, results.backend, results.frontend);
 		},
 		payments: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend);
 		},
 		email: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getEmailChoice(flags.email, results.backend);
 		},
 		effect: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getEffectChoice(flags.effect);
 		},
 		addons: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve([]);
+			if (results.ecosystem !== "typescript") return Promise.resolve([]);
 			return getAddonsChoice(flags.addons, results.frontend, results.auth);
 		},
 		examples: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve([]);
+			if (results.ecosystem !== "typescript") 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");
+			if (results.ecosystem !== "typescript") 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");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend);
 		},
 		serverDeploy: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy);
 		},
 		ai: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getAIChoice(flags.ai);
 		},
 		validation: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getValidationChoice(flags.validation);
 		},
 		forms: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getFormsChoice(flags.forms, results.frontend);
 		},
 		stateManagement: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getStateManagementChoice(flags.stateManagement, results.frontend);
 		},
 		animation: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getAnimationChoice(flags.animation, results.frontend);
 		},
 		testing: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getTestingChoice(flags.testing);
 		},
 		realtime: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getRealtimeChoice(flags.realtime, results.backend);
 		},
 		jobQueue: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getJobQueueChoice(flags.jobQueue, results.backend);
 		},
 		fileUpload: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getFileUploadChoice(flags.fileUpload, results.backend);
 		},
 		logging: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getLoggingChoice(flags.logging, results.backend);
 		},
 		observability: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getObservabilityChoice(flags.observability, results.backend);
 		},
+		featureFlags: ({ results }) => {
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
+			return Promise.resolve(flags.featureFlags || "none");
+		},
+		analytics: ({ results }) => {
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
+			return Promise.resolve(flags.analytics || "none");
+		},
 		cms: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getCMSChoice(flags.cms, results.backend);
 		},
 		caching: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("none");
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
 			return getCachingChoice(flags.caching, results.backend);
 		},
+		search: ({ results }) => {
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
+			return getSearchChoice(flags.search, results.backend);
+		},
+		fileStorage: ({ results }) => {
+			if (results.ecosystem !== "typescript") return Promise.resolve("none");
+			return getFileStorageChoice(flags.fileStorage, results.backend);
+		},
 		rustWebFramework: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustWebFrameworkChoice(flags.rustWebFramework);
 		},
 		rustFrontend: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustFrontendChoice(flags.rustFrontend);
 		},
 		rustOrm: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustOrmChoice(flags.rustOrm);
 		},
 		rustApi: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustApiChoice(flags.rustApi);
 		},
 		rustCli: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve("none");
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustCliChoice(flags.rustCli);
 		},
 		rustLibraries: ({ results }) => {
-			if (results.ecosystem === "typescript") return Promise.resolve([]);
+			if (results.ecosystem !== "rust") return Promise.resolve([]);
 			return getRustLibrariesChoice(flags.rustLibraries);
 		},
+		pythonWebFramework: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve("none");
+			return getPythonWebFrameworkChoice(flags.pythonWebFramework);
+		},
+		pythonOrm: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve("none");
+			return getPythonOrmChoice(flags.pythonOrm);
+		},
+		pythonValidation: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve("none");
+			return getPythonValidationChoice(flags.pythonValidation);
+		},
+		pythonAi: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve([]);
+			return getPythonAiChoice(flags.pythonAi);
+		},
+		pythonTaskQueue: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve("none");
+			return getPythonTaskQueueChoice(flags.pythonTaskQueue);
+		},
+		pythonQuality: ({ results }) => {
+			if (results.ecosystem !== "python") return Promise.resolve("none");
+			return getPythonQualityChoice(flags.pythonQuality);
+		},
+		goWebFramework: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoWebFrameworkChoice(flags.goWebFramework);
+		},
+		goOrm: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoOrmChoice(flags.goOrm);
+		},
+		goApi: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoApiChoice(flags.goApi);
+		},
+		goCli: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoCliChoice(flags.goCli);
+		},
+		goLogging: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoLoggingChoice(flags.goLogging);
+		},
 		git: () => getGitChoice(flags.git),
 		packageManager: ({ results }) => {
-			if (results.ecosystem === "rust") return Promise.resolve("npm");
+			if (results.ecosystem === "rust" || results.ecosystem === "python" || results.ecosystem === "go") return Promise.resolve("npm");
 			return getPackageManagerChoice(flags.packageManager);
 		},
 		install: ({ results }) => getinstallChoice(flags.install, results.ecosystem)
@@ -3429,15 +3965,30 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		fileUpload: result.fileUpload,
 		logging: result.logging,
 		observability: result.observability,
+		featureFlags: result.featureFlags,
+		analytics: result.analytics,
 		cms: result.cms,
 		caching: result.caching,
+		search: result.search,
+		fileStorage: result.fileStorage,
 		ecosystem: result.ecosystem,
 		rustWebFramework: result.rustWebFramework,
 		rustFrontend: result.rustFrontend,
 		rustOrm: result.rustOrm,
 		rustApi: result.rustApi,
 		rustCli: result.rustCli,
-		rustLibraries: result.rustLibraries
+		rustLibraries: result.rustLibraries,
+		pythonWebFramework: result.pythonWebFramework,
+		pythonOrm: result.pythonOrm,
+		pythonValidation: result.pythonValidation,
+		pythonAi: result.pythonAi,
+		pythonTaskQueue: result.pythonTaskQueue,
+		pythonQuality: result.pythonQuality,
+		goWebFramework: result.goWebFramework,
+		goOrm: result.goOrm,
+		goApi: result.goApi,
+		goCli: result.goCli,
+		goLogging: result.goLogging
 	};
 }
 
@@ -3849,6 +4400,10 @@ function processFlags(options, projectName) {
 	if (options.observability !== void 0) config.observability = options.observability;
 	if (options.cms !== void 0) config.cms = options.cms;
 	if (options.caching !== void 0) config.caching = options.caching;
+	if (options.search !== void 0) config.search = options.search;
+	if (options.fileStorage !== void 0) config.fileStorage = options.fileStorage;
+	if (options.analytics !== void 0) config.analytics = options.analytics;
+	if (options.featureFlags !== void 0) config.featureFlags = options.featureFlags;
 	if (options.fileUpload !== void 0) config.fileUpload = options.fileUpload;
 	if (options.git !== void 0) config.git = options.git;
 	if (options.install !== void 0) config.install = options.install;
@@ -4093,7 +4648,7 @@ function validateDatabaseOrmAuth(cfg, flags) {
 		},
 		suggestions: ["Use --orm mongoose", "Use --orm prisma"]
 	});
-	if (has("database") && has("orm") && db && db !== "none" && orm === "none") missingRequirementError({
+	if (has("database") && has("orm") && db && db !== "none" && db !== "edgedb" && db !== "redis" && orm === "none") missingRequirementError({
 		message: "Database selection requires an ORM.",
 		provided: {
 			database: db,
@@ -4105,6 +4660,22 @@ function validateDatabaseOrmAuth(cfg, flags) {
 			"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: {
@@ -4140,6 +4711,10 @@ function validateDatabaseSetup(config, providedFlags) {
 			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."
@@ -4333,6 +4908,9 @@ function validateFullConfig(config, providedFlags, options) {
 	validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? [], config.api);
 	validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend ?? []);
 	validateNextAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+	validateStackAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+	validateSupabaseAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+	validateAuth0Compatibility(config.auth, config.backend, config.frontend ?? []);
 	validateUILibraryFrontendCompatibility(config.uiLibrary, config.frontend ?? [], config.astroIntegration);
 	validateUILibraryCSSFrameworkCompatibility(config.uiLibrary, config.cssFramework);
 	validatePeerDependencies(config);
@@ -4344,6 +4922,9 @@ function validateConfigForProgrammaticUse(config) {
 		validateApiFrontendCompatibility(config.api, config.frontend, config.astroIntegration);
 		validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend);
 		validateNextAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+		validateStackAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+		validateSupabaseAuthCompatibility(config.auth, config.backend, config.frontend ?? []);
+		validateAuth0Compatibility(config.auth, config.backend, config.frontend ?? []);
 		if (config.addons && config.addons.length > 0) validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
 		validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? [], config.api);
 		validateUILibraryFrontendCompatibility(config.uiLibrary, config.frontend ?? [], config.astroIntegration);
@@ -4471,14 +5052,29 @@ async function writeBtsConfig(projectConfig) {
 		animation: projectConfig.animation,
 		logging: projectConfig.logging,
 		observability: projectConfig.observability,
+		featureFlags: projectConfig.featureFlags,
+		analytics: projectConfig.analytics,
 		cms: projectConfig.cms,
 		caching: projectConfig.caching,
+		search: projectConfig.search,
+		fileStorage: projectConfig.fileStorage,
 		rustWebFramework: projectConfig.rustWebFramework,
 		rustFrontend: projectConfig.rustFrontend,
 		rustOrm: projectConfig.rustOrm,
 		rustApi: projectConfig.rustApi,
 		rustCli: projectConfig.rustCli,
-		rustLibraries: projectConfig.rustLibraries
+		rustLibraries: projectConfig.rustLibraries,
+		pythonWebFramework: projectConfig.pythonWebFramework,
+		pythonOrm: projectConfig.pythonOrm,
+		pythonValidation: projectConfig.pythonValidation,
+		pythonAi: projectConfig.pythonAi,
+		pythonTaskQueue: projectConfig.pythonTaskQueue,
+		pythonQuality: projectConfig.pythonQuality,
+		goWebFramework: projectConfig.goWebFramework,
+		goOrm: projectConfig.goOrm,
+		goApi: projectConfig.goApi,
+		goCli: projectConfig.goCli,
+		goLogging: projectConfig.goLogging
 	};
 	const baseContent = {
 		$schema: "https://better-fullstack-web.vercel.app/schema.json",
@@ -4514,12 +5110,29 @@ async function writeBtsConfig(projectConfig) {
 		animation: btsConfig.animation,
 		logging: btsConfig.logging,
 		observability: btsConfig.observability,
+		featureFlags: btsConfig.featureFlags,
+		analytics: btsConfig.analytics,
+		cms: btsConfig.cms,
+		caching: btsConfig.caching,
+		search: btsConfig.search,
+		fileStorage: btsConfig.fileStorage,
 		rustWebFramework: btsConfig.rustWebFramework,
 		rustFrontend: btsConfig.rustFrontend,
 		rustOrm: btsConfig.rustOrm,
 		rustApi: btsConfig.rustApi,
 		rustCli: btsConfig.rustCli,
-		rustLibraries: btsConfig.rustLibraries
+		rustLibraries: btsConfig.rustLibraries,
+		pythonWebFramework: btsConfig.pythonWebFramework,
+		pythonOrm: btsConfig.pythonOrm,
+		pythonValidation: btsConfig.pythonValidation,
+		pythonAi: btsConfig.pythonAi,
+		pythonTaskQueue: btsConfig.pythonTaskQueue,
+		pythonQuality: btsConfig.pythonQuality,
+		goWebFramework: btsConfig.goWebFramework,
+		goOrm: btsConfig.goOrm,
+		goApi: btsConfig.goApi,
+		goCli: btsConfig.goCli,
+		goLogging: btsConfig.goLogging
 	};
 	let configContent = JSON.stringify(baseContent);
 	const formatResult = JSONC.format(configContent, void 0, {
@@ -5292,12 +5905,12 @@ async function setupDockerCompose(config) {
 	const { database, projectDir, projectName, backend } = config;
 	if (database === "none" || database === "sqlite") return;
 	try {
-		await writeEnvFile$4(projectDir, database, projectName, backend);
+		await writeEnvFile$5(projectDir, database, projectName, backend);
 	} catch (error) {
 		if (error instanceof Error) console.error(`Error: ${error.message}`);
 	}
 }
-async function writeEnvFile$4(projectDir, database, projectName, backend) {
+async function writeEnvFile$5(projectDir, database, projectName, backend) {
 	const targetApp = backend === "self" ? "apps/web" : "apps/server";
 	await addEnvVariablesToFile(path$1.join(projectDir, targetApp, ".env"), [{
 		key: "DATABASE_URL",
@@ -5358,7 +5971,7 @@ async function initMongoDBAtlas(serverDir) {
 		return null;
 	}
 }
-async function writeEnvFile$3(projectDir, backend, config) {
+async function writeEnvFile$4(projectDir, backend, config) {
 	try {
 		const targetApp = backend === "self" ? "apps/web" : "apps/server";
 		await addEnvVariablesToFile(path$1.join(projectDir, targetApp, ".env"), [{
@@ -5370,7 +5983,7 @@ async function writeEnvFile$3(projectDir, backend, config) {
 		consola.error("Failed to update environment configuration");
 	}
 }
-function displayManualSetupInstructions$3() {
+function displayManualSetupInstructions$4() {
 	log.info(`
 ${pc.green("MongoDB Atlas Manual Setup Instructions:")}
 
@@ -5395,8 +6008,8 @@ async function setupMongoDBAtlas(config, cliInput) {
 		await fs.ensureDir(serverDir);
 		if (manualDb) {
 			log.info("MongoDB Atlas manual setup selected");
-			await writeEnvFile$3(projectDir, backend);
-			displayManualSetupInstructions$3();
+			await writeEnvFile$4(projectDir, backend);
+			displayManualSetupInstructions$4();
 			return;
 		}
 		const mode = await select({
@@ -5415,24 +6028,24 @@ async function setupMongoDBAtlas(config, cliInput) {
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
 			log.info("MongoDB Atlas manual setup selected");
-			await writeEnvFile$3(projectDir, backend);
-			displayManualSetupInstructions$3();
+			await writeEnvFile$4(projectDir, backend);
+			displayManualSetupInstructions$4();
 			return;
 		}
 		const config$1 = await initMongoDBAtlas(serverDir);
 		if (config$1) {
-			await writeEnvFile$3(projectDir, backend, config$1);
+			await writeEnvFile$4(projectDir, backend, config$1);
 			log.success(pc.green("MongoDB Atlas setup complete! Connection saved to .env file."));
 		} else {
 			log.warn(pc.yellow("Falling back to local MongoDB configuration"));
-			await writeEnvFile$3(projectDir, backend);
-			displayManualSetupInstructions$3();
+			await writeEnvFile$4(projectDir, backend);
+			displayManualSetupInstructions$4();
 		}
 	} catch (error) {
 		consola.error(pc.red(`Error during MongoDB Atlas setup: ${error instanceof Error ? error.message : String(error)}`));
 		try {
-			await writeEnvFile$3(projectDir, backend);
-			displayManualSetupInstructions$3();
+			await writeEnvFile$4(projectDir, backend);
+			displayManualSetupInstructions$4();
 		} catch {}
 	}
 }
@@ -5507,7 +6120,7 @@ async function createNeonProject(projectName, regionId, packageManager) {
 		consola$1.error(pc.red("Failed to create Neon project"));
 	}
 }
-async function writeEnvFile$2(projectDir, backend, config) {
+async function writeEnvFile$3(projectDir, backend, config) {
 	const targetApp = backend === "self" ? "apps/web" : "apps/server";
 	await addEnvVariablesToFile(path$1.join(projectDir, targetApp, ".env"), [{
 		key: "DATABASE_URL",
@@ -5532,7 +6145,7 @@ async function setupWithNeonDb(projectDir, packageManager, backend) {
 		throw error;
 	}
 }
-function displayManualSetupInstructions$2(target) {
+function displayManualSetupInstructions$3(target) {
 	log.info(`Manual Neon PostgreSQL Setup Instructions:
 
 1. Visit https://neon.tech and create an account
@@ -5547,8 +6160,8 @@ async function setupNeonPostgres(config, cliInput) {
 	const manualDb = cliInput?.manualDb ?? false;
 	try {
 		if (manualDb) {
-			await writeEnvFile$2(projectDir, backend);
-			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$3(projectDir, backend);
+			displayManualSetupInstructions$3(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const mode = await select({
@@ -5566,8 +6179,8 @@ async function setupNeonPostgres(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			await writeEnvFile$2(projectDir, backend);
-			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$3(projectDir, backend);
+			displayManualSetupInstructions$3(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const setupMethod = await select({
@@ -5602,13 +6215,13 @@ async function setupNeonPostgres(config, cliInput) {
 			if (!neonConfig) throw new Error("Failed to create project - couldn't get connection information");
 			const finalSpinner = spinner();
 			finalSpinner.start("Configuring database connection");
-			await writeEnvFile$2(projectDir, backend, neonConfig);
+			await writeEnvFile$3(projectDir, backend, neonConfig);
 			finalSpinner.stop("Neon database configured!");
 		}
 	} catch (error) {
 		if (error instanceof Error) consola$1.error(pc.red(error.message));
-		await writeEnvFile$2(projectDir, backend);
-		displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
+		await writeEnvFile$3(projectDir, backend);
+		displayManualSetupInstructions$3(backend === "self" ? "apps/web" : "apps/server");
 	}
 }
 
@@ -5731,7 +6344,7 @@ async function setupWithCreateDb(serverDir, packageManager) {
 		return null;
 	}
 }
-async function writeEnvFile$1(projectDir, backend, config) {
+async function writeEnvFile$2(projectDir, backend, config) {
 	try {
 		const targetApp = backend === "self" ? "apps/web" : "apps/server";
 		const envPath = path$1.join(projectDir, targetApp, ".env");
@@ -5750,7 +6363,7 @@ async function writeEnvFile$1(projectDir, backend, config) {
 		consola$1.error("Failed to update environment configuration");
 	}
 }
-function displayManualSetupInstructions$1(target) {
+function displayManualSetupInstructions$2(target) {
 	log.info(`Manual Prisma PostgreSQL Setup Instructions:
 
 1. Visit https://console.prisma.io and create an account
@@ -5767,8 +6380,8 @@ async function setupPrismaPostgres(config, cliInput) {
 	try {
 		await fs.ensureDir(dbDir);
 		if (manualDb) {
-			await writeEnvFile$1(projectDir, backend);
-			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const setupMode = await select({
@@ -5786,24 +6399,24 @@ async function setupPrismaPostgres(config, cliInput) {
 		});
 		if (isCancel(setupMode)) return;
 		if (setupMode === "manual") {
-			await writeEnvFile$1(projectDir, backend);
-			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const prismaConfig = await setupWithCreateDb(dbDir, packageManager);
 		if (prismaConfig) {
-			await writeEnvFile$1(projectDir, backend, prismaConfig);
+			await writeEnvFile$2(projectDir, backend, prismaConfig);
 			log.success(pc.green("Prisma Postgres database configured successfully!"));
 			if (prismaConfig.claimUrl) log.info(pc.blue(`Claim URL saved to .env: ${prismaConfig.claimUrl}`));
 		} else {
-			await writeEnvFile$1(projectDir, backend);
-			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 		}
 	} catch (error) {
 		consola$1.error(pc.red(`Error during Prisma Postgres setup: ${error instanceof Error ? error.message : String(error)}`));
 		try {
-			await writeEnvFile$1(projectDir, backend);
-			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 		} catch {}
 		log.info("Setup completed with manual configuration required.");
 	}
@@ -6062,7 +6675,7 @@ async function createTursoDatabase(dbName, groupName) {
 		s.stop(pc.red("Failed to retrieve database connection details"));
 	}
 }
-async function writeEnvFile(projectDir, backend, config) {
+async function writeEnvFile$1(projectDir, backend, config) {
 	const targetApp = backend === "self" ? "apps/web" : "apps/server";
 	await addEnvVariablesToFile(path$1.join(projectDir, targetApp, ".env"), [{
 		key: "DATABASE_URL",
@@ -6074,7 +6687,7 @@ async function writeEnvFile(projectDir, backend, config) {
 		condition: true
 	}]);
 }
-function displayManualSetupInstructions() {
+function displayManualSetupInstructions$1() {
 	log.info(`Manual Turso Setup Instructions:
 
 1. Visit https://turso.tech and create an account
@@ -6091,8 +6704,8 @@ async function setupTurso(config, cliInput) {
 	const setupSpinner = spinner();
 	try {
 		if (manualDb) {
-			await writeEnvFile(projectDir, backend);
-			displayManualSetupInstructions();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1();
 			return;
 		}
 		const mode = await select({
@@ -6110,8 +6723,8 @@ async function setupTurso(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			await writeEnvFile(projectDir, backend);
-			displayManualSetupInstructions();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1();
 			return;
 		}
 		setupSpinner.start("Checking Turso CLI availability...");
@@ -6120,8 +6733,8 @@ async function setupTurso(config, cliInput) {
 		if (platform === "win32") {
 			if (setupSpinner) setupSpinner.stop(pc.yellow("Turso setup not supported on Windows"));
 			log.warn(pc.yellow("Automatic Turso setup is not supported on Windows."));
-			await writeEnvFile(projectDir, backend);
-			displayManualSetupInstructions();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1();
 			return;
 		}
 		if (setupSpinner) setupSpinner.stop("Turso CLI availability checked");
@@ -6132,8 +6745,8 @@ async function setupTurso(config, cliInput) {
 			});
 			if (isCancel(shouldInstall)) return exitCancelled("Operation cancelled");
 			if (!shouldInstall) {
-				await writeEnvFile(projectDir, backend);
-				displayManualSetupInstructions();
+				await writeEnvFile$1(projectDir, backend);
+				displayManualSetupInstructions$1();
 				return;
 			}
 			await installTursoCLI(isMac);
@@ -6153,7 +6766,7 @@ async function setupTurso(config, cliInput) {
 			if (isCancel(dbNameResponse)) return exitCancelled("Operation cancelled");
 			dbName = dbNameResponse;
 			try {
-				await writeEnvFile(projectDir, backend, await createTursoDatabase(dbName, selectedGroup));
+				await writeEnvFile$1(projectDir, backend, await createTursoDatabase(dbName, selectedGroup));
 				success = true;
 			} catch (error) {
 				if (error instanceof Error && error.message === "DATABASE_EXISTS") {
@@ -6166,12 +6779,109 @@ async function setupTurso(config, cliInput) {
 	} catch (error) {
 		if (setupSpinner) setupSpinner.stop(pc.red("Turso CLI availability check failed"));
 		consola.error(pc.red(`Error during Turso setup: ${error instanceof Error ? error.message : String(error)}`));
-		await writeEnvFile(projectDir, backend);
-		displayManualSetupInstructions();
+		await writeEnvFile$1(projectDir, backend);
+		displayManualSetupInstructions$1();
 		log.success("Setup completed with manual configuration required.");
 	}
 }
 
+//#endregion
+//#region src/helpers/database-providers/upstash-setup.ts
+async function writeEnvFile(projectDir, backend, config) {
+	try {
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		await addEnvVariablesToFile(path$1.join(projectDir, targetApp, ".env"), [{
+			key: "UPSTASH_REDIS_REST_URL",
+			value: config?.redisUrl ?? "",
+			condition: true
+		}, {
+			key: "UPSTASH_REDIS_REST_TOKEN",
+			value: config?.redisToken ?? "",
+			condition: true
+		}]);
+	} catch {
+		consola.error("Failed to update environment configuration");
+	}
+}
+function displayManualSetupInstructions() {
+	log.info(`
+${pc.green("Upstash Redis Manual Setup Instructions:")}
+
+1. Visit ${pc.blue("https://console.upstash.com")} and create an account
+
+2. Create a new Redis database from the dashboard
+
+3. Copy your REST URL and REST Token from the database details page
+
+4. Add them to the .env file in apps/server/.env:
+   ${pc.dim("UPSTASH_REDIS_REST_URL=\"your_rest_url\"")}
+   ${pc.dim("UPSTASH_REDIS_REST_TOKEN=\"your_rest_token\"")}
+`);
+}
+async function setupUpstash(config, cliInput) {
+	const { projectDir, backend } = config;
+	const manualDb = cliInput?.manualDb ?? false;
+	const serverDir = path$1.join(projectDir, "packages/db");
+	try {
+		await fs.ensureDir(serverDir);
+		if (manualDb) {
+			log.info("Upstash Redis manual setup selected");
+			await writeEnvFile(projectDir, backend);
+			displayManualSetupInstructions();
+			return;
+		}
+		const mode = await select({
+			message: "Upstash Redis setup: choose mode",
+			options: [{
+				label: "Enter credentials",
+				value: "credentials",
+				hint: "Enter your Upstash REST URL and token"
+			}, {
+				label: "Manual",
+				value: "manual",
+				hint: "Manual setup, add env vars yourself"
+			}],
+			initialValue: "credentials"
+		});
+		if (isCancel(mode)) return exitCancelled("Operation cancelled");
+		if (mode === "manual") {
+			log.info("Upstash Redis manual setup selected");
+			await writeEnvFile(projectDir, backend);
+			displayManualSetupInstructions();
+			return;
+		}
+		const redisUrl = await text({
+			message: "Enter your Upstash Redis REST URL:",
+			placeholder: "https://xxx.upstash.io",
+			validate(value) {
+				if (!value) return "Please enter a REST URL";
+				if (!value.startsWith("https://") || !value.includes("upstash.io")) return "URL should be a valid Upstash REST URL (https://xxx.upstash.io)";
+			}
+		});
+		if (isCancel(redisUrl)) return exitCancelled("Operation cancelled");
+		const redisToken = await text({
+			message: "Enter your Upstash Redis REST Token:",
+			placeholder: "AXxxxxxxxxxxxxxxxxxxxx",
+			validate(value) {
+				if (!value) return "Please enter a REST token";
+				if (value.length < 20) return "Token appears to be too short";
+			}
+		});
+		if (isCancel(redisToken)) return exitCancelled("Operation cancelled");
+		await writeEnvFile(projectDir, backend, {
+			redisUrl,
+			redisToken
+		});
+		log.success(pc.green("Upstash Redis setup complete! Credentials saved to .env file."));
+	} catch (error) {
+		consola.error(pc.red(`Error during Upstash setup: ${error instanceof Error ? error.message : String(error)}`));
+		try {
+			await writeEnvFile(projectDir, backend);
+			displayManualSetupInstructions();
+		} catch {}
+	}
+}
+
 //#endregion
 //#region src/helpers/core/db-setup.ts
 /**
@@ -6201,6 +6911,7 @@ async function setupDatabase(config, cliInput) {
 			else if (dbSetup === "supabase") await setupSupabase(config, cliInput);
 		} else if (database === "mysql" && dbSetup === "planetscale") await setupPlanetScale(config);
 		else if (database === "mongodb" && dbSetup === "mongodb-atlas") await setupMongoDBAtlas(config, cliInput);
+		else if (database === "redis" && dbSetup === "upstash") await setupUpstash(config, cliInput);
 	} catch (error) {
 		if (error instanceof Error) consola.error(pc.red(error.message));
 	}
@@ -6258,6 +6969,20 @@ async function runCargoBuild({ projectDir }) {
 		if (error instanceof Error) consola.error(pc.red(`Cargo build error: ${error.message}`));
 	}
 }
+async function runUvSync({ projectDir }) {
+	const s = spinner();
+	try {
+		s.start("Running uv sync...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`uv sync`;
+		s.stop("Python dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("uv sync failed"));
+		if (error instanceof Error) consola.error(pc.red(`uv sync error: ${error.message}`));
+	}
+}
 
 //#endregion
 //#region src/utils/docker-utils.ts
@@ -6546,11 +7271,12 @@ async function createProject(options, cliInput = {}) {
 		await writeBtsConfig(options);
 		await formatProject(projectDir);
 		if (!isSilent()) log.success("Project template successfully scaffolded!");
-		if (options.install && options.ecosystem !== "rust") await installDependencies({
+		if (options.install && options.ecosystem === "typescript") await installDependencies({
 			projectDir,
 			packageManager: options.packageManager
 		});
 		if (options.install && options.ecosystem === "rust") await runCargoBuild({ projectDir });
+		if (options.install && options.ecosystem === "python") await runUvSync({ projectDir });
 		await initializeGit(projectDir, options.git);
 		if (!isSilent()) await displayPostInstallInstructions({
 			...options,
@@ -6665,7 +7391,22 @@ async function createProjectHandler(input, options = {}) {
 						rustCli: "none",
 						rustLibraries: [],
 						cms: "none",
-						caching: "none"
+						caching: "none",
+						search: "none",
+						featureFlags: "none",
+						analytics: "none",
+						fileStorage: "none",
+						pythonWebFramework: "none",
+						pythonOrm: "none",
+						pythonValidation: "none",
+						pythonAi: [],
+						pythonTaskQueue: "none",
+						pythonQuality: "none",
+						goWebFramework: "none",
+						goOrm: "none",
+						goApi: "none",
+						goCli: "none",
+						goLogging: "none"
 					},
 					reproducibleCommand: "",
 					timeScaffolded,
@@ -6880,7 +7621,7 @@ const router = os.router({
 		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"),
 		verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
-		ecosystem: types_exports.EcosystemSchema.optional().describe("Language ecosystem (typescript or rust)"),
+		ecosystem: types_exports.EcosystemSchema.optional().describe("Language ecosystem (typescript, rust, or python)"),
 		database: types_exports.DatabaseSchema.optional(),
 		orm: types_exports.ORMSchema.optional(),
 		auth: types_exports.AuthSchema.optional(),
@@ -6898,8 +7639,10 @@ const router = os.router({
 		animation: types_exports.AnimationSchema.optional(),
 		logging: types_exports.LoggingSchema.optional(),
 		observability: types_exports.ObservabilitySchema.optional(),
+		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"),
+		fileStorage: types_exports.FileStorageSchema.optional().describe("File storage solution (S3, R2)"),
 		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(),
@@ -6924,7 +7667,18 @@ const router = os.router({
 		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")
+		rustLibraries: z.array(types_exports.RustLibrariesSchema).optional().describe("Rust core libraries"),
+		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"),
+		pythonTaskQueue: types_exports.PythonTaskQueueSchema.optional().describe("Python task queue (celery)"),
+		pythonQuality: types_exports.PythonQualitySchema.optional().describe("Python code quality (ruff)"),
+		goWebFramework: types_exports.GoWebFrameworkSchema.optional().describe("Go web framework (gin, echo)"),
+		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)"),
+		goLogging: types_exports.GoLoggingSchema.optional().describe("Go logging (zap)")
 	})])).handler(async ({ input }) => {
 		const [projectName, options] = input;
 		const result = await createProjectHandler({
@@ -7102,14 +7856,29 @@ async function createVirtual(options) {
 				animation: options.animation || "none",
 				logging: options.logging || "none",
 				observability: options.observability || "none",
+				featureFlags: options.featureFlags || "none",
+				analytics: options.analytics || "none",
 				cms: options.cms || "none",
 				caching: options.caching || "none",
+				search: options.search || "none",
+				fileStorage: options.fileStorage || "none",
 				rustWebFramework: options.rustWebFramework || "none",
 				rustFrontend: options.rustFrontend || "none",
 				rustOrm: options.rustOrm || "none",
 				rustApi: options.rustApi || "none",
 				rustCli: options.rustCli || "none",
-				rustLibraries: options.rustLibraries || []
+				rustLibraries: options.rustLibraries || [],
+				pythonWebFramework: options.pythonWebFramework || "none",
+				pythonOrm: options.pythonOrm || "none",
+				pythonValidation: options.pythonValidation || "none",
+				pythonAi: options.pythonAi || [],
+				pythonTaskQueue: options.pythonTaskQueue || "none",
+				pythonQuality: options.pythonQuality || "none",
+				goWebFramework: options.goWebFramework || "none",
+				goOrm: options.goOrm || "none",
+				goApi: options.goApi || "none",
+				goCli: options.goCli || "none",
+				goLogging: options.goLogging || "none"
 			},
 			templates: EMBEDDED_TEMPLATES
 		});