tvi-cli 0.1.4

package/dist/index.js

@@ -0,0 +1,4315 @@
+#!/usr/bin/env node
+import { cancel, confirm, group, intro, isCancel, log, multiselect, outro, password, select, spinner, text } from "@clack/prompts";
+import consola, { consola as consola$1 } from "consola";
+import pc from "picocolors";
+import { createCli, trpcServer, zod } from "trpc-cli";
+import path from "node:path";
+import fs from "fs-extra";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { PostHog } from "posthog-node";
+import gradient from "gradient-string";
+import * as JSONC from "jsonc-parser";
+import { $, execa } from "execa";
+import { globby } from "globby";
+import handlebars from "handlebars";
+import os from "node:os";
+
+//#region src/utils/get-package-manager.ts
+const getUserPkgManager = () => {
+	const userAgent = process.env.npm_config_user_agent;
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("bun")) return "bun";
+	return "npm";
+};
+
+//#endregion
+//#region src/constants.ts
+const __filename = fileURLToPath(import.meta.url);
+const distPath = path.dirname(__filename);
+const PKG_ROOT = path.join(distPath, "../");
+const DEFAULT_CONFIG = {
+	projectName: "my-tvi-app",
+	projectDir: path.resolve(process.cwd(), "my-tvi-app"),
+	relativePath: "my-tvi-app",
+	frontend: ["tanstack-router"],
+	database: "sqlite",
+	orm: "drizzle",
+	auth: true,
+	addons: ["turborepo"],
+	examples: [],
+	git: true,
+	packageManager: getUserPkgManager(),
+	install: true,
+	dbSetup: "none",
+	backend: "hono",
+	runtime: "bun",
+	api: "trpc"
+};
+const dependencyVersionMap = {
+	"better-auth": "^1.2.10",
+	"@better-auth/expo": "^1.2.10",
+	"drizzle-orm": "^0.44.2",
+	"drizzle-kit": "^0.31.2",
+	"@libsql/client": "^0.15.9",
+	pg: "^8.14.1",
+	"@types/pg": "^8.11.11",
+	mysql2: "^3.14.0",
+	"@prisma/client": "^6.9.0",
+	prisma: "^6.9.0",
+	mongoose: "^8.14.0",
+	"vite-plugin-pwa": "^0.21.2",
+	"@vite-pwa/assets-generator": "^0.2.6",
+	"@tauri-apps/cli": "^2.4.0",
+	"@biomejs/biome": "^2.0.0",
+	husky: "^9.1.7",
+	"lint-staged": "^15.5.0",
+	tsx: "^4.19.2",
+	"@types/node": "^22.13.11",
+	"@types/bun": "^1.2.6",
+	"@elysiajs/node": "^1.2.6",
+	"@elysiajs/cors": "^1.2.0",
+	"@elysiajs/trpc": "^1.1.0",
+	elysia: "^1.2.25",
+	"@hono/node-server": "^1.14.4",
+	"@hono/trpc-server": "^0.4.0",
+	hono: "^4.8.2",
+	cors: "^2.8.5",
+	express: "^5.1.0",
+	"@types/express": "^5.0.1",
+	"@types/cors": "^2.8.17",
+	fastify: "^5.3.3",
+	"@fastify/cors": "^11.0.1",
+	turbo: "^2.5.4",
+	ai: "^4.3.16",
+	"@ai-sdk/google": "^1.2.3",
+	"@ai-sdk/vue": "^1.2.8",
+	"@ai-sdk/svelte": "^2.1.9",
+	"@ai-sdk/react": "^1.2.12",
+	"@prisma/extension-accelerate": "^1.3.0",
+	"@orpc/server": "^1.5.0",
+	"@orpc/client": "^1.5.0",
+	"@orpc/tanstack-query": "^1.5.0",
+	"@trpc/tanstack-react-query": "^11.4.2",
+	"@trpc/server": "^11.4.2",
+	"@trpc/client": "^11.4.2",
+	convex: "^1.23.0",
+	"@convex-dev/react-query": "^0.0.0-alpha.8",
+	"convex-svelte": "^0.0.11",
+	"@tanstack/svelte-query": "^5.74.4",
+	"@tanstack/react-query-devtools": "^5.80.5",
+	"@tanstack/react-query": "^5.80.5",
+	"@tanstack/solid-query": "^5.75.0",
+	"@tanstack/solid-query-devtools": "^5.75.0",
+	wrangler: "^4.20.0"
+};
+const ADDON_COMPATIBILITY = {
+	pwa: [
+		"tanstack-router",
+		"react-router",
+		"solid"
+	],
+	tauri: [
+		"tanstack-router",
+		"react-router",
+		"nuxt",
+		"svelte",
+		"solid"
+	],
+	biome: [],
+	husky: [],
+	turborepo: [],
+	starlight: [],
+	none: []
+};
+
+//#endregion
+//#region src/types.ts
+const DatabaseSchema = z.enum([
+	"none",
+	"sqlite",
+	"postgres",
+	"mysql",
+	"mongodb"
+]).describe("Database type");
+const ORMSchema = z.enum([
+	"drizzle",
+	"prisma",
+	"mongoose",
+	"none"
+]).describe("ORM type");
+const BackendSchema = z.enum([
+	"hono",
+	"express",
+	"fastify",
+	"next",
+	"elysia",
+	"convex",
+	"none"
+]).describe("Backend framework");
+const RuntimeSchema = z.enum([
+	"bun",
+	"node",
+	"workers",
+	"none"
+]).describe("Runtime environment (workers only available with hono backend and drizzle orm)");
+const FrontendSchema = z.enum([
+	"tanstack-router",
+	"react-router",
+	"tanstack-start",
+	"next",
+	"nuxt",
+	"native-nativewind",
+	"native-unistyles",
+	"svelte",
+	"solid",
+	"none"
+]).describe("Frontend framework");
+const AddonsSchema = z.enum([
+	"pwa",
+	"tauri",
+	"starlight",
+	"biome",
+	"husky",
+	"turborepo",
+	"none"
+]).describe("Additional addons");
+const ExamplesSchema = z.enum([
+	"todo",
+	"ai",
+	"none"
+]).describe("Example templates to include");
+const PackageManagerSchema = z.enum([
+	"npm",
+	"pnpm",
+	"bun"
+]).describe("Package manager");
+const DatabaseSetupSchema = z.enum([
+	"turso",
+	"neon",
+	"prisma-postgres",
+	"mongodb-atlas",
+	"supabase",
+	"d1",
+	"none"
+]).describe("Database hosting setup");
+const APISchema = z.enum([
+	"trpc",
+	"orpc",
+	"none"
+]).describe("API type");
+const ProjectNameSchema = z.string().min(1, "Project name cannot be empty").max(255, "Project name must be less than 255 characters").refine((name) => name === "." || !name.startsWith("."), "Project name cannot start with a dot (except for '.')").refine((name) => name === "." || !name.startsWith("-"), "Project name cannot start with a dash").refine((name) => {
+	const invalidChars = [
+		"<",
+		">",
+		":",
+		"\"",
+		"|",
+		"?",
+		"*"
+	];
+	return !invalidChars.some((char) => name.includes(char));
+}, "Project name contains invalid characters").refine((name) => name.toLowerCase() !== "node_modules", "Project name is reserved").describe("Project name or path");
+
+//#endregion
+//#region src/utils/addon-compatibility.ts
+function validateAddonCompatibility(addon, frontend) {
+	const compatibleFrontends = ADDON_COMPATIBILITY[addon];
+	if (compatibleFrontends.length === 0) return { isCompatible: true };
+	const hasCompatibleFrontend = frontend.some((f) => compatibleFrontends.includes(f));
+	if (!hasCompatibleFrontend) {
+		const frontendList = compatibleFrontends.join(", ");
+		return {
+			isCompatible: false,
+			reason: `${addon} addon requires one of these frontends: ${frontendList}`
+		};
+	}
+	return { isCompatible: true };
+}
+function getCompatibleAddons(allAddons, frontend, existingAddons = []) {
+	return allAddons.filter((addon) => {
+		if (existingAddons.includes(addon)) return false;
+		if (addon === "none") return false;
+		const { isCompatible } = validateAddonCompatibility(addon, frontend);
+		return isCompatible;
+	});
+}
+
+//#endregion
+//#region src/prompts/addons.ts
+function getAddonDisplay(addon, isRecommended = false) {
+	let label;
+	let hint;
+	if (addon === "turborepo") {
+		label = isRecommended ? "Turborepo (Recommended)" : "Turborepo";
+		hint = "High-performance build system for JavaScript and TypeScript";
+	} else if (addon === "pwa") {
+		label = "PWA (Progressive Web App)";
+		hint = "Make your app installable and work offline";
+	} else if (addon === "tauri") {
+		label = isRecommended ? "Tauri Desktop App" : "Tauri";
+		hint = "Build native desktop apps from your web frontend";
+	} else if (addon === "biome") {
+		label = "Biome";
+		hint = isRecommended ? "Add Biome for linting and formatting" : "Fast formatter and linter for JavaScript, TypeScript, JSX";
+	} else if (addon === "husky") {
+		label = "Husky";
+		hint = isRecommended ? "Add Git hooks with Husky, lint-staged (requires Biome)" : "Git hooks made easy";
+	} else if (addon === "starlight") {
+		label = "Starlight";
+		hint = isRecommended ? "Add Astro Starlight documentation site" : "Documentation site with Astro";
+	} else {
+		label = addon;
+		hint = `Add ${addon}`;
+	}
+	return {
+		label,
+		hint
+	};
+}
+async function getAddonsChoice(addons, frontends) {
+	if (addons !== void 0) return addons;
+	const allAddons = AddonsSchema.options.filter((addon) => addon !== "none");
+	const allPossibleOptions = [];
+	for (const addon of allAddons) {
+		const { isCompatible } = validateAddonCompatibility(addon, frontends || []);
+		if (isCompatible) {
+			const { label, hint } = getAddonDisplay(addon, true);
+			allPossibleOptions.push({
+				value: addon,
+				label,
+				hint
+			});
+		}
+	}
+	const options = allPossibleOptions.sort((a, b) => {
+		if (a.value === "turborepo") return -1;
+		if (b.value === "turborepo") return 1;
+		return 0;
+	});
+	const initialValues = DEFAULT_CONFIG.addons.filter((addonValue) => options.some((opt) => opt.value === addonValue));
+	const response = await multiselect({
+		message: "Select addons",
+		options,
+		initialValues,
+		required: false
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	if (response.includes("husky") && !response.includes("biome")) response.push("biome");
+	return response;
+}
+async function getAddonsToAdd(frontend, existingAddons = []) {
+	const options = [];
+	const allAddons = AddonsSchema.options.filter((addon) => addon !== "none");
+	const compatibleAddons = getCompatibleAddons(allAddons, frontend, existingAddons);
+	for (const addon of compatibleAddons) {
+		const { label, hint } = getAddonDisplay(addon, false);
+		options.push({
+			value: addon,
+			label,
+			hint
+		});
+	}
+	if (options.length === 0) return [];
+	const response = await multiselect({
+		message: "Select addons",
+		options,
+		required: true
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/api.ts
+async function getApiChoice(Api, frontend, backend) {
+	if (backend === "convex" || backend === "none") return "none";
+	if (Api) return Api;
+	const includesNuxt = frontend?.includes("nuxt");
+	const includesSvelte = frontend?.includes("svelte");
+	const includesSolid = frontend?.includes("solid");
+	let apiOptions = [
+		{
+			value: "trpc",
+			label: "tRPC",
+			hint: "End-to-end typesafe APIs made easy"
+		},
+		{
+			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)"
+		}
+	];
+	if (includesNuxt || includesSvelte || includesSolid) apiOptions = [{
+		value: "orpc",
+		label: "oRPC",
+		hint: `End-to-end type-safe APIs (Recommended for ${includesNuxt ? "Nuxt" : includesSvelte ? "Svelte" : "Solid"} frontend)`
+	}, {
+		value: "none",
+		label: "None",
+		hint: "No API layer"
+	}];
+	const apiType = await select({
+		message: "Select API type",
+		options: apiOptions,
+		initialValue: apiOptions[0].value
+	});
+	if (isCancel(apiType)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return apiType;
+}
+
+//#endregion
+//#region src/prompts/auth.ts
+async function getAuthChoice(auth, hasDatabase, backend) {
+	if (backend === "convex") return false;
+	if (!hasDatabase) return false;
+	if (auth !== void 0) return auth;
+	const response = await confirm({
+		message: "Add authentication with Better-Auth?",
+		initialValue: DEFAULT_CONFIG.auth
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/backend.ts
+async function getBackendFrameworkChoice(backendFramework, frontends) {
+	if (backendFramework !== void 0) return backendFramework;
+	const hasIncompatibleFrontend = frontends?.some((f) => f === "nuxt" || f === "solid");
+	const backendOptions = [
+		{
+			value: "hono",
+			label: "Hono",
+			hint: "Lightweight, ultrafast web framework"
+		},
+		{
+			value: "next",
+			label: "Next.js",
+			hint: "separate api routes only backend"
+		},
+		{
+			value: "express",
+			label: "Express",
+			hint: "Fast, unopinionated, minimalist web framework for Node.js"
+		},
+		{
+			value: "fastify",
+			label: "Fastify",
+			hint: "Fast, low-overhead web framework for Node.js"
+		},
+		{
+			value: "elysia",
+			label: "Elysia",
+			hint: "Ergonomic web framework for building backend servers"
+		}
+	];
+	if (!hasIncompatibleFrontend) backendOptions.push({
+		value: "convex",
+		label: "Convex",
+		hint: "Reactive backend-as-a-service platform"
+	});
+	backendOptions.push({
+		value: "none",
+		label: "None",
+		hint: "No backend server"
+	});
+	let initialValue = DEFAULT_CONFIG.backend;
+	if (hasIncompatibleFrontend && initialValue === "convex") initialValue = "hono";
+	const response = await select({
+		message: "Select backend",
+		options: backendOptions,
+		initialValue
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/database.ts
+async function getDatabaseChoice(database, backend, runtime) {
+	if (backend === "convex" || backend === "none") return "none";
+	if (database !== void 0) return database;
+	const databaseOptions = [
+		{
+			value: "none",
+			label: "None",
+			hint: "No database setup"
+		},
+		{
+			value: "sqlite",
+			label: "SQLite",
+			hint: "lightweight, server-less, embedded relational database"
+		},
+		{
+			value: "postgres",
+			label: "PostgreSQL",
+			hint: "powerful, open source object-relational database system"
+		},
+		{
+			value: "mysql",
+			label: "MySQL",
+			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"
+	});
+	const response = await select({
+		message: "Select database",
+		options: databaseOptions,
+		initialValue: DEFAULT_CONFIG.database
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/database-setup.ts
+async function getDBSetupChoice(databaseType, dbSetup, orm, backend, runtime) {
+	if (backend === "convex") return "none";
+	if (dbSetup !== void 0) return dbSetup;
+	if (databaseType === "none") return "none";
+	if (databaseType === "sqlite" && orm === "prisma") return "none";
+	let options = [];
+	if (databaseType === "sqlite") options = [
+		{
+			value: "turso",
+			label: "Turso",
+			hint: "SQLite for Production. Powered by libSQL"
+		},
+		...runtime === "workers" ? [{
+			value: "d1",
+			label: "Cloudflare D1",
+			hint: "Cloudflare's managed, serverless database with SQLite's SQL semantics"
+		}] : [],
+		{
+			value: "none",
+			label: "None",
+			hint: "Manual setup"
+		}
+	];
+	else if (databaseType === "postgres") options = [
+		{
+			value: "neon",
+			label: "Neon Postgres",
+			hint: "Serverless Postgres with branching capability"
+		},
+		{
+			value: "supabase",
+			label: "Supabase",
+			hint: "Local Supabase stack (requires Docker)"
+		},
+		...orm === "prisma" ? [{
+			value: "prisma-postgres",
+			label: "Prisma Postgres",
+			hint: "Instant Postgres for Global Applications"
+		}] : [],
+		{
+			value: "none",
+			label: "None",
+			hint: "Manual setup"
+		}
+	];
+	else if (databaseType === "mongodb") options = [{
+		value: "mongodb-atlas",
+		label: "MongoDB Atlas",
+		hint: "The most effective way to deploy MongoDB"
+	}, {
+		value: "none",
+		label: "None",
+		hint: "Manual setup"
+	}];
+	else return "none";
+	const response = await select({
+		message: `Select ${databaseType} setup option`,
+		options,
+		initialValue: "none"
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/examples.ts
+async function getExamplesChoice(examples, database, frontends, backend, api) {
+	if (api === "none") return [];
+	if (examples !== void 0) return examples;
+	if (backend === "convex") return ["todo"];
+	if (backend === "none") return [];
+	if (database === "none") return [];
+	const noFrontendSelected = !frontends || frontends.length === 0;
+	if (noFrontendSelected) return [];
+	let response = [];
+	const options = [{
+		value: "todo",
+		label: "Todo App",
+		hint: "A simple CRUD example app"
+	}];
+	if (backend !== "elysia" && !frontends?.includes("solid")) options.push({
+		value: "ai",
+		label: "AI Chat",
+		hint: "A simple AI chat interface using AI SDK"
+	});
+	response = await multiselect({
+		message: "Include examples",
+		options,
+		required: false,
+		initialValues: DEFAULT_CONFIG.examples
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/frontend.ts
+async function getFrontendChoice(frontendOptions, backend) {
+	if (frontendOptions !== void 0) return frontendOptions;
+	const frontendTypes = await multiselect({
+		message: "Select platforms to develop for",
+		options: [{
+			value: "web",
+			label: "Web",
+			hint: "React, Vue or Svelte Web Application"
+		}, {
+			value: "native",
+			label: "Native",
+			hint: "Create a React Native/Expo app"
+		}],
+		required: false,
+		initialValues: ["web"]
+	});
+	if (isCancel(frontendTypes)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	const result = [];
+	if (frontendTypes.includes("web")) {
+		const allWebOptions = [
+			{
+				value: "tanstack-router",
+				label: "TanStack Router",
+				hint: "Modern and scalable routing for React Applications"
+			},
+			{
+				value: "react-router",
+				label: "React Router",
+				hint: "A user‑obsessed, standards‑focused, multi‑strategy router"
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "The React Framework for the Web"
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "The Progressive Web Framework for Vue.js"
+			},
+			{
+				value: "svelte",
+				label: "Svelte",
+				hint: "web development for the rest of us"
+			},
+			{
+				value: "solid",
+				label: "Solid",
+				hint: "Simple and performant reactivity for building user interfaces"
+			},
+			{
+				value: "tanstack-start",
+				label: "TanStack Start (devinxi)",
+				hint: "SSR, Server Functions, API Routes and more with TanStack Router"
+			}
+		];
+		const webOptions = allWebOptions.filter((option) => {
+			if (backend === "convex") return option.value !== "nuxt" && option.value !== "solid";
+			return true;
+		});
+		const webFramework = await select({
+			message: "Choose web",
+			options: webOptions,
+			initialValue: DEFAULT_CONFIG.frontend[0]
+		});
+		if (isCancel(webFramework)) {
+			cancel(pc.red("Operation cancelled"));
+			process.exit(0);
+		}
+		result.push(webFramework);
+	}
+	if (frontendTypes.includes("native")) {
+		const nativeFramework = await select({
+			message: "Choose native",
+			options: [{
+				value: "native-nativewind",
+				label: "NativeWind",
+				hint: "Use Tailwind CSS for React Native"
+			}, {
+				value: "native-unistyles",
+				label: "Unistyles",
+				hint: "Consistent styling for React Native"
+			}],
+			initialValue: "native-nativewind"
+		});
+		if (isCancel(nativeFramework)) {
+			cancel(pc.red("Operation cancelled"));
+			process.exit(0);
+		}
+		result.push(nativeFramework);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/prompts/git.ts
+async function getGitChoice(git) {
+	if (git !== void 0) return git;
+	const response = await confirm({
+		message: "Initialize git repository?",
+		initialValue: DEFAULT_CONFIG.git
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/install.ts
+async function getinstallChoice(install) {
+	if (install !== void 0) return install;
+	const response = await confirm({
+		message: "Install dependencies?",
+		initialValue: DEFAULT_CONFIG.install
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/orm.ts
+const ormOptions = {
+	prisma: {
+		value: "prisma",
+		label: "Prisma",
+		hint: "Powerful, feature-rich ORM"
+	},
+	mongoose: {
+		value: "mongoose",
+		label: "Mongoose",
+		hint: "Elegant object modeling tool"
+	},
+	drizzle: {
+		value: "drizzle",
+		label: "Drizzle",
+		hint: "Lightweight and performant TypeScript ORM"
+	}
+};
+async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
+	if (backend === "convex") return "none";
+	if (!hasDatabase) return "none";
+	if (orm !== void 0) return orm;
+	if (runtime === "workers") return "drizzle";
+	const options = [...database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma]];
+	const response = await select({
+		message: "Select ORM",
+		options,
+		initialValue: database === "mongodb" ? "prisma" : DEFAULT_CONFIG.orm
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/package-manager.ts
+async function getPackageManagerChoice(packageManager) {
+	if (packageManager !== void 0) return packageManager;
+	const detectedPackageManager = getUserPkgManager();
+	const response = await select({
+		message: "Choose package manager",
+		options: [
+			{
+				value: "npm",
+				label: "npm",
+				hint: "Node Package Manager"
+			},
+			{
+				value: "pnpm",
+				label: "pnpm",
+				hint: "Fast, disk space efficient package manager"
+			},
+			{
+				value: "bun",
+				label: "bun",
+				hint: "All-in-one JavaScript runtime & toolkit"
+			}
+		],
+		initialValue: detectedPackageManager
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/runtime.ts
+async function getRuntimeChoice(runtime, backend) {
+	if (backend === "convex" || backend === "none") return "none";
+	if (runtime !== void 0) return runtime;
+	if (backend === "next") return "node";
+	const runtimeOptions = [{
+		value: "bun",
+		label: "Bun",
+		hint: "Fast all-in-one JavaScript runtime"
+	}, {
+		value: "node",
+		label: "Node.js",
+		hint: "Traditional Node.js runtime"
+	}];
+	if (backend === "hono") runtimeOptions.push({
+		value: "workers",
+		label: "Cloudflare Workers (beta)",
+		hint: "Edge runtime on Cloudflare's global network"
+	});
+	const response = await select({
+		message: "Select runtime",
+		options: runtimeOptions,
+		initialValue: DEFAULT_CONFIG.runtime
+	});
+	if (isCancel(response)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return response;
+}
+
+//#endregion
+//#region src/prompts/config-prompts.ts
+async function gatherConfig(flags, projectName, projectDir, relativePath) {
+	const result = await group({
+		frontend: () => getFrontendChoice(flags.frontend, flags.backend),
+		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),
+		auth: ({ results }) => getAuthChoice(flags.auth, results.database !== "none", results.backend),
+		addons: ({ results }) => getAddonsChoice(flags.addons, results.frontend),
+		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),
+		git: () => getGitChoice(flags.git),
+		packageManager: () => getPackageManagerChoice(flags.packageManager),
+		install: () => getinstallChoice(flags.install)
+	}, { onCancel: () => {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	} });
+	if (result.backend === "convex") {
+		result.runtime = "none";
+		result.database = "none";
+		result.orm = "none";
+		result.api = "none";
+		result.auth = false;
+		result.dbSetup = "none";
+		result.examples = ["todo"];
+	}
+	if (result.backend === "none") {
+		result.runtime = "none";
+		result.database = "none";
+		result.orm = "none";
+		result.api = "none";
+		result.auth = false;
+		result.dbSetup = "none";
+		result.examples = [];
+	}
+	return {
+		projectName,
+		projectDir,
+		relativePath,
+		frontend: result.frontend,
+		backend: result.backend,
+		runtime: result.runtime,
+		database: result.database,
+		orm: result.orm,
+		auth: result.auth,
+		addons: result.addons,
+		examples: result.examples,
+		git: result.git,
+		packageManager: result.packageManager,
+		install: result.install,
+		dbSetup: result.dbSetup,
+		api: result.api
+	};
+}
+
+//#endregion
+//#region src/prompts/project-name.ts
+function validateDirectoryName(name) {
+	if (name === ".") return void 0;
+	const result = ProjectNameSchema.safeParse(name);
+	if (!result.success) return result.error.issues[0]?.message || "Invalid project name";
+	return void 0;
+}
+async function getProjectName(initialName) {
+	if (initialName) {
+		if (initialName === ".") return initialName;
+		const finalDirName = path.basename(initialName);
+		const validationError = validateDirectoryName(finalDirName);
+		if (!validationError) return initialName;
+	}
+	let isValid = false;
+	let projectPath = "";
+	let defaultName = DEFAULT_CONFIG.projectName;
+	let counter = 1;
+	while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
+		defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
+		counter++;
+	}
+	while (!isValid) {
+		const response = await text({
+			message: "Enter your project name or path (relative to current directory)",
+			placeholder: defaultName,
+			initialValue: initialName,
+			defaultValue: defaultName,
+			validate: (value) => {
+				const nameToUse = value.trim() || defaultName;
+				const finalDirName = path.basename(nameToUse);
+				const validationError = validateDirectoryName(finalDirName);
+				if (validationError) return validationError;
+				if (nameToUse !== ".") {
+					const projectDir = path.resolve(process.cwd(), nameToUse);
+					if (!projectDir.startsWith(process.cwd())) return "Project path must be within current directory";
+				}
+				return void 0;
+			}
+		});
+		if (isCancel(response)) {
+			cancel(pc.red("Operation cancelled."));
+			process.exit(0);
+		}
+		projectPath = response || defaultName;
+		isValid = true;
+	}
+	return projectPath;
+}
+
+//#endregion
+//#region src/utils/get-latest-cli-version.ts
+const getLatestCLIVersion = () => {
+	const packageJsonPath = path.join(PKG_ROOT, "package.json");
+	const packageJsonContent = fs.readJSONSync(packageJsonPath);
+	return packageJsonContent.version ?? "1.0.0";
+};
+
+//#endregion
+//#region src/utils/analytics.ts
+const POSTHOG_API_KEY = "lol";
+const POSTHOG_HOST = "lool";
+async function trackProjectCreation(config) {
+	if (!POSTHOG_API_KEY) return;
+	const posthog = new PostHog(POSTHOG_API_KEY, {
+		host: POSTHOG_HOST,
+		flushAt: 1,
+		flushInterval: 0,
+		privacyMode: true,
+		disableGeoip: true,
+		disabled: true
+	});
+	try {
+		const sessionId = `cli_${crypto.randomUUID().replace(/-/g, "")}`;
+		const { projectName, projectDir, relativePath,...safeConfig } = config;
+		posthog.capture({
+			distinctId: sessionId,
+			event: "project_created",
+			properties: {
+				...safeConfig,
+				cli_version: getLatestCLIVersion(),
+				node_version: process.version,
+				platform: process.platform,
+				$ip: null
+			}
+		});
+	} catch (_error) {} finally {
+		await posthog.shutdown();
+	}
+}
+
+//#endregion
+//#region src/utils/display-config.ts
+function displayConfig(config) {
+	const configDisplay = [];
+	if (config.projectName) configDisplay.push(`${pc.blue("Project Name:")} ${config.projectName}`);
+	if (config.frontend !== void 0) {
+		const frontend = Array.isArray(config.frontend) ? config.frontend : [config.frontend];
+		const frontendText = frontend.length > 0 && frontend[0] !== void 0 ? frontend.join(", ") : "none";
+		configDisplay.push(`${pc.blue("Frontend:")} ${frontendText}`);
+	}
+	if (config.backend !== void 0) configDisplay.push(`${pc.blue("Backend:")} ${String(config.backend)}`);
+	if (config.runtime !== void 0) configDisplay.push(`${pc.blue("Runtime:")} ${String(config.runtime)}`);
+	if (config.api !== void 0) configDisplay.push(`${pc.blue("API:")} ${String(config.api)}`);
+	if (config.database !== void 0) configDisplay.push(`${pc.blue("Database:")} ${String(config.database)}`);
+	if (config.orm !== void 0) configDisplay.push(`${pc.blue("ORM:")} ${String(config.orm)}`);
+	if (config.auth !== void 0) {
+		const authText = typeof config.auth === "boolean" ? config.auth ? "Yes" : "No" : String(config.auth);
+		configDisplay.push(`${pc.blue("Authentication:")} ${authText}`);
+	}
+	if (config.addons !== void 0) {
+		const addons = Array.isArray(config.addons) ? config.addons : [config.addons];
+		const addonsText = addons.length > 0 && addons[0] !== void 0 ? addons.join(", ") : "none";
+		configDisplay.push(`${pc.blue("Addons:")} ${addonsText}`);
+	}
+	if (config.examples !== void 0) {
+		const examples = Array.isArray(config.examples) ? config.examples : [config.examples];
+		const examplesText = examples.length > 0 && examples[0] !== void 0 ? examples.join(", ") : "none";
+		configDisplay.push(`${pc.blue("Examples:")} ${examplesText}`);
+	}
+	if (config.git !== void 0) {
+		const gitText = typeof config.git === "boolean" ? config.git ? "Yes" : "No" : String(config.git);
+		configDisplay.push(`${pc.blue("Git Init:")} ${gitText}`);
+	}
+	if (config.packageManager !== void 0) configDisplay.push(`${pc.blue("Package Manager:")} ${String(config.packageManager)}`);
+	if (config.install !== void 0) {
+		const installText = typeof config.install === "boolean" ? config.install ? "Yes" : "No" : String(config.install);
+		configDisplay.push(`${pc.blue("Install Dependencies:")} ${installText}`);
+	}
+	if (config.dbSetup !== void 0) configDisplay.push(`${pc.blue("Database Setup:")} ${String(config.dbSetup)}`);
+	if (configDisplay.length === 0) return pc.yellow("No configuration selected.");
+	return configDisplay.join("\n");
+}
+
+//#endregion
+//#region src/utils/generate-reproducible-command.ts
+function generateReproducibleCommand(config) {
+	const flags = [];
+	if (config.frontend && config.frontend.length > 0) flags.push(`--frontend ${config.frontend.join(" ")}`);
+	else flags.push("--frontend none");
+	flags.push(`--backend ${config.backend}`);
+	flags.push(`--runtime ${config.runtime}`);
+	flags.push(`--database ${config.database}`);
+	flags.push(`--orm ${config.orm}`);
+	flags.push(`--api ${config.api}`);
+	flags.push(config.auth ? "--auth" : "--no-auth");
+	if (config.addons && config.addons.length > 0) flags.push(`--addons ${config.addons.join(" ")}`);
+	else flags.push("--addons none");
+	if (config.examples && config.examples.length > 0) flags.push(`--examples ${config.examples.join(" ")}`);
+	else flags.push("--examples none");
+	flags.push(`--db-setup ${config.dbSetup}`);
+	flags.push(config.git ? "--git" : "--no-git");
+	flags.push(`--package-manager ${config.packageManager}`);
+	flags.push(config.install ? "--install" : "--no-install");
+	let baseCommand = "";
+	const pkgManager = config.packageManager;
+	if (pkgManager === "npm") baseCommand = "npx tvi-cli@latest";
+	else if (pkgManager === "pnpm") baseCommand = "pnpm create tvi@latest";
+	else if (pkgManager === "bun") baseCommand = "bun create tvi@latest";
+	const projectPathArg = config.relativePath ? ` ${config.relativePath}` : "";
+	return `${baseCommand}${projectPathArg} ${flags.join(" ")}`;
+}
+
+//#endregion
+//#region src/utils/project-directory.ts
+async function handleDirectoryConflict(currentPathInput) {
+	while (true) {
+		const resolvedPath = path.resolve(process.cwd(), currentPathInput);
+		const dirExists = fs.pathExistsSync(resolvedPath);
+		const dirIsNotEmpty = dirExists && fs.readdirSync(resolvedPath).length > 0;
+		if (!dirIsNotEmpty) return {
+			finalPathInput: currentPathInput,
+			shouldClearDirectory: false
+		};
+		log.warn(`Directory "${pc.yellow(currentPathInput)}" already exists and is not empty.`);
+		const action = await select({
+			message: "What would you like to do?",
+			options: [
+				{
+					value: "overwrite",
+					label: "Overwrite",
+					hint: "Empty the directory and create the project"
+				},
+				{
+					value: "merge",
+					label: "Merge",
+					hint: "Create project files inside, potentially overwriting conflicts"
+				},
+				{
+					value: "rename",
+					label: "Choose a different name/path",
+					hint: "Keep the existing directory and create a new one"
+				},
+				{
+					value: "cancel",
+					label: "Cancel",
+					hint: "Abort the process"
+				}
+			],
+			initialValue: "rename"
+		});
+		if (isCancel(action)) {
+			cancel(pc.red("Operation cancelled."));
+			process.exit(0);
+		}
+		switch (action) {
+			case "overwrite": return {
+				finalPathInput: currentPathInput,
+				shouldClearDirectory: true
+			};
+			case "merge":
+				log.info(`Proceeding into existing directory "${pc.yellow(currentPathInput)}". Files may be overwritten.`);
+				return {
+					finalPathInput: currentPathInput,
+					shouldClearDirectory: false
+				};
+			case "rename": {
+				log.info("Please choose a different project name or path.");
+				const newPathInput = await getProjectName(void 0);
+				return await handleDirectoryConflict(newPathInput);
+			}
+			case "cancel":
+				cancel(pc.red("Operation cancelled."));
+				process.exit(0);
+		}
+	}
+}
+async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
+	let finalResolvedPath;
+	let finalBaseName;
+	if (finalPathInput === ".") {
+		finalResolvedPath = process.cwd();
+		finalBaseName = path.basename(finalResolvedPath);
+	} else {
+		finalResolvedPath = path.resolve(process.cwd(), finalPathInput);
+		finalBaseName = path.basename(finalResolvedPath);
+	}
+	if (shouldClearDirectory) {
+		const s = spinner();
+		s.start(`Clearing directory "${finalResolvedPath}"...`);
+		try {
+			await fs.emptyDir(finalResolvedPath);
+			s.stop(`Directory "${finalResolvedPath}" cleared.`);
+		} catch (error) {
+			s.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
+			consola$1.error(error);
+			process.exit(1);
+		}
+	} else await fs.ensureDir(finalResolvedPath);
+	return {
+		finalResolvedPath,
+		finalBaseName
+	};
+}
+
+//#endregion
+//#region src/utils/render-title.ts
+const TITLE_TEXT = `
+ TVI TypeScript Initializer
+ A CLI tool to quickly scaffold TypeScript projects with popular frameworks and libraries.
+ `;
+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 renderTitle = () => {
+	const terminalWidth = process.stdout.columns || 80;
+	const titleLines = TITLE_TEXT.split("\n");
+	const titleWidth = Math.max(...titleLines.map((line) => line.length));
+	if (terminalWidth < titleWidth) {
+		const simplifiedTitle = `
+    ╔══════════════════╗
+    ║  TVI             ║
+    ╚══════════════════╝
+    `;
+		console.log(gradient(Object.values(catppuccinTheme)).multiline(simplifiedTitle));
+	} else console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
+};
+
+//#endregion
+//#region src/validation.ts
+function processAndValidateFlags(options, providedFlags, projectName) {
+	const config = {};
+	if (options.api) {
+		config.api = options.api;
+		if (options.api === "none") {
+			if (options.examples && !(options.examples.length === 1 && options.examples[0] === "none") && options.backend !== "convex") {
+				consola$1.fatal("Cannot use '--examples' when '--api' is set to 'none'. Please remove the --examples flag or choose an API type.");
+				process.exit(1);
+			}
+		}
+	}
+	if (options.backend) config.backend = options.backend;
+	if (providedFlags.has("backend") && config.backend && config.backend !== "convex" && config.backend !== "none") {
+		if (providedFlags.has("runtime") && options.runtime === "none") {
+			consola$1.fatal(`'--runtime none' is only supported with '--backend convex' or '--backend none'. Please choose 'bun', 'node', or remove the --runtime flag.`);
+			process.exit(1);
+		}
+	}
+	if (options.database) config.database = options.database;
+	if (options.orm) config.orm = options.orm;
+	if (options.auth !== void 0) config.auth = options.auth;
+	if (options.git !== void 0) config.git = options.git;
+	if (options.install !== void 0) config.install = options.install;
+	if (options.runtime) config.runtime = options.runtime;
+	if (options.dbSetup) config.dbSetup = options.dbSetup;
+	if (options.packageManager) config.packageManager = options.packageManager;
+	if (projectName) {
+		const result = ProjectNameSchema.safeParse(path.basename(projectName));
+		if (!result.success) {
+			consola$1.fatal(`Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`);
+			process.exit(1);
+		}
+		config.projectName = projectName;
+	} else if (options.projectDirectory) {
+		const baseName = path.basename(path.resolve(process.cwd(), options.projectDirectory));
+		const result = ProjectNameSchema.safeParse(baseName);
+		if (!result.success) {
+			consola$1.fatal(`Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`);
+			process.exit(1);
+		}
+		config.projectName = baseName;
+	}
+	if (options.frontend && options.frontend.length > 0) if (options.frontend.includes("none")) {
+		if (options.frontend.length > 1) {
+			consola$1.fatal(`Cannot combine 'none' with other frontend options.`);
+			process.exit(1);
+		}
+		config.frontend = [];
+	} else {
+		const validOptions = options.frontend.filter((f) => f !== "none");
+		const webFrontends = validOptions.filter((f) => f === "tanstack-router" || f === "react-router" || f === "tanstack-start" || f === "next" || f === "nuxt" || f === "svelte" || f === "solid");
+		const nativeFrontends = validOptions.filter((f) => f === "native-nativewind" || f === "native-unistyles");
+		if (webFrontends.length > 1) {
+			consola$1.fatal("Cannot select multiple web frameworks. Choose only one of: tanstack-router, tanstack-start, react-router, next, nuxt, svelte, solid");
+			process.exit(1);
+		}
+		if (nativeFrontends.length > 1) {
+			consola$1.fatal("Cannot select multiple native frameworks. Choose only one of: native-nativewind, native-unistyles");
+			process.exit(1);
+		}
+		config.frontend = validOptions;
+	}
+	if (options.addons && options.addons.length > 0) if (options.addons.includes("none")) {
+		if (options.addons.length > 1) {
+			consola$1.fatal(`Cannot combine 'none' with other addons.`);
+			process.exit(1);
+		}
+		config.addons = [];
+	} else config.addons = options.addons.filter((addon) => addon !== "none");
+	if (options.examples && options.examples.length > 0) if (options.examples.includes("none")) {
+		if (options.examples.length > 1) {
+			consola$1.fatal("Cannot combine 'none' with other examples.");
+			process.exit(1);
+		}
+		config.examples = [];
+	} else {
+		config.examples = options.examples.filter((ex) => ex !== "none");
+		if (options.examples.includes("none") && config.backend !== "convex") config.examples = [];
+	}
+	if (config.backend === "convex") {
+		const incompatibleFlags = [];
+		if (providedFlags.has("auth") && options.auth === true) incompatibleFlags.push("--auth");
+		if (providedFlags.has("database") && options.database !== "none") incompatibleFlags.push(`--database ${options.database}`);
+		if (providedFlags.has("orm") && options.orm !== "none") incompatibleFlags.push(`--orm ${options.orm}`);
+		if (providedFlags.has("api") && options.api !== "none") incompatibleFlags.push(`--api ${options.api}`);
+		if (providedFlags.has("runtime") && options.runtime !== "none") incompatibleFlags.push(`--runtime ${options.runtime}`);
+		if (providedFlags.has("dbSetup") && options.dbSetup !== "none") incompatibleFlags.push(`--db-setup ${options.dbSetup}`);
+		if (incompatibleFlags.length > 0) {
+			consola$1.fatal(`The following flags are incompatible with '--backend convex': ${incompatibleFlags.join(", ")}. Please remove them.`);
+			process.exit(1);
+		}
+		if (providedFlags.has("frontend") && options.frontend) {
+			const incompatibleFrontends = options.frontend.filter((f) => f === "nuxt" || f === "solid");
+			if (incompatibleFrontends.length > 0) {
+				consola$1.fatal(`The following frontends are not compatible with '--backend convex': ${incompatibleFrontends.join(", ")}. Please choose a different frontend or backend.`);
+				process.exit(1);
+			}
+		}
+		config.auth = false;
+		config.database = "none";
+		config.orm = "none";
+		config.api = "none";
+		config.runtime = "none";
+		config.dbSetup = "none";
+		config.examples = ["todo"];
+	} else if (config.backend === "none") {
+		const incompatibleFlags = [];
+		if (providedFlags.has("auth") && options.auth === true) incompatibleFlags.push("--auth");
+		if (providedFlags.has("database") && options.database !== "none") incompatibleFlags.push(`--database ${options.database}`);
+		if (providedFlags.has("orm") && options.orm !== "none") incompatibleFlags.push(`--orm ${options.orm}`);
+		if (providedFlags.has("api") && options.api !== "none") incompatibleFlags.push(`--api ${options.api}`);
+		if (providedFlags.has("runtime") && options.runtime !== "none") incompatibleFlags.push(`--runtime ${options.runtime}`);
+		if (providedFlags.has("dbSetup") && options.dbSetup !== "none") incompatibleFlags.push(`--db-setup ${options.dbSetup}`);
+		if (providedFlags.has("examples") && options.examples) {
+			const hasNonNoneExamples = options.examples.some((ex) => ex !== "none");
+			if (hasNonNoneExamples) incompatibleFlags.push("--examples");
+		}
+		if (incompatibleFlags.length > 0) {
+			consola$1.fatal(`The following flags are incompatible with '--backend none': ${incompatibleFlags.join(", ")}. Please remove them.`);
+			process.exit(1);
+		}
+		config.auth = false;
+		config.database = "none";
+		config.orm = "none";
+		config.api = "none";
+		config.runtime = "none";
+		config.dbSetup = "none";
+		config.examples = [];
+	}
+	if (config.orm === "mongoose" && config.database !== "mongodb") {
+		consola$1.fatal("Mongoose ORM requires MongoDB database. Please use '--database mongodb' or choose a different ORM.");
+		process.exit(1);
+	}
+	if (config.database === "mongodb" && config.orm && config.orm !== "mongoose" && config.orm !== "prisma") {
+		consola$1.fatal("MongoDB database requires Mongoose or Prisma ORM. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
+		process.exit(1);
+	}
+	if (config.orm === "drizzle" && config.database === "mongodb") {
+		consola$1.fatal("Drizzle ORM does not support MongoDB. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
+		process.exit(1);
+	}
+	if (config.database && config.database !== "none" && config.orm === "none") {
+		consola$1.fatal("Database selection requires an ORM. Please choose '--orm drizzle', '--orm prisma', or '--orm mongoose'.");
+		process.exit(1);
+	}
+	if (config.orm && config.orm !== "none" && config.database === "none") {
+		consola$1.fatal("ORM selection requires a database. Please choose a database or set '--orm none'.");
+		process.exit(1);
+	}
+	if (config.auth && config.database === "none") {
+		consola$1.fatal("Authentication requires a database. Please choose a database or set '--no-auth'.");
+		process.exit(1);
+	}
+	if (config.dbSetup && config.dbSetup !== "none" && config.database === "none") {
+		consola$1.fatal("Database setup requires a database. Please choose a database or set '--db-setup none'.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "turso" && config.database !== "sqlite") {
+		consola$1.fatal("Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "neon" && config.database !== "postgres") {
+		consola$1.fatal("Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "prisma-postgres" && config.database !== "postgres") {
+		consola$1.fatal("Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "mongodb-atlas" && config.database !== "mongodb") {
+		consola$1.fatal("MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "supabase" && config.database !== "postgres") {
+		consola$1.fatal("Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
+		process.exit(1);
+	}
+	if (config.dbSetup === "d1") {
+		if (config.database !== "sqlite") {
+			consola$1.fatal("Cloudflare D1 setup requires SQLite database. Please use '--database sqlite' or choose a different setup.");
+			process.exit(1);
+		}
+		if (config.runtime !== "workers") {
+			consola$1.fatal("Cloudflare D1 setup requires the Cloudflare Workers runtime. Please use '--runtime workers' or choose a different setup.");
+			process.exit(1);
+		}
+	}
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && config.backend !== "hono") {
+		consola$1.fatal(`Cloudflare Workers runtime (--runtime workers) is only supported with Hono backend (--backend hono). Current backend: ${config.backend}. Please use '--backend hono' or choose a different runtime.`);
+		process.exit(1);
+	}
+	if (providedFlags.has("backend") && config.backend && config.backend !== "hono" && config.runtime === "workers") {
+		consola$1.fatal(`Backend '${config.backend}' is not compatible with Cloudflare Workers runtime. Cloudflare Workers runtime is only supported with Hono backend. Please use '--backend hono' or choose a different runtime.`);
+		process.exit(1);
+	}
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.orm && config.orm !== "drizzle" && config.orm !== "none") {
+		consola$1.fatal(`Cloudflare Workers runtime (--runtime workers) is only supported with Drizzle ORM (--orm drizzle) or no ORM (--orm none). Current ORM: ${config.orm}. Please use '--orm drizzle', '--orm none', or choose a different runtime.`);
+		process.exit(1);
+	}
+	if (providedFlags.has("orm") && config.orm && config.orm !== "drizzle" && config.orm !== "none" && config.runtime === "workers") {
+		consola$1.fatal(`ORM '${config.orm}' is not compatible with Cloudflare Workers runtime. Cloudflare Workers runtime is only supported with Drizzle ORM or no ORM. Please use '--orm drizzle', '--orm none', or choose a different runtime.`);
+		process.exit(1);
+	}
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.database === "mongodb") {
+		consola$1.fatal("Cloudflare Workers runtime (--runtime workers) is not compatible with MongoDB database. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle ORM. Please use a different database or runtime.");
+		process.exit(1);
+	}
+	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") {
+		consola$1.fatal("MongoDB database is not compatible with Cloudflare Workers runtime. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle ORM. Please use a different database or runtime.");
+		process.exit(1);
+	}
+	return config;
+}
+function getProvidedFlags(options) {
+	return new Set(Object.keys(options).filter((key) => options[key] !== void 0));
+}
+
+//#endregion
+//#region src/utils/tvi-config.ts
+const TVI_CONFIG_FILE = "tvi.jsonc";
+async function writeTviConfig(projectConfig) {
+	const tviConfig = {
+		version: getLatestCLIVersion(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		database: projectConfig.database,
+		orm: projectConfig.orm,
+		backend: projectConfig.backend,
+		runtime: projectConfig.runtime,
+		frontend: projectConfig.frontend,
+		addons: projectConfig.addons,
+		examples: projectConfig.examples,
+		auth: projectConfig.auth,
+		packageManager: projectConfig.packageManager,
+		dbSetup: projectConfig.dbSetup,
+		api: projectConfig.api
+	};
+	const baseContent = {
+		$schema: "https://tvi.dev/schema.json",
+		version: tviConfig.version,
+		createdAt: tviConfig.createdAt,
+		database: tviConfig.database,
+		orm: tviConfig.orm,
+		backend: tviConfig.backend,
+		runtime: tviConfig.runtime,
+		frontend: tviConfig.frontend,
+		addons: tviConfig.addons,
+		examples: tviConfig.examples,
+		auth: tviConfig.auth,
+		packageManager: tviConfig.packageManager,
+		dbSetup: tviConfig.dbSetup,
+		api: tviConfig.api
+	};
+	let configContent = JSON.stringify(baseContent);
+	const formatResult = JSONC.format(configContent, void 0, {
+		tabSize: 2,
+		insertSpaces: true,
+		eol: "\n"
+	});
+	configContent = JSONC.applyEdits(configContent, formatResult);
+	const finalContent = `// tvi configuration file
+// safe to delete
+
+${configContent}`;
+	const configPath = path.join(projectConfig.projectDir, TVI_CONFIG_FILE);
+	await fs.writeFile(configPath, finalContent, "utf-8");
+}
+async function readTviConfig(projectDir) {
+	try {
+		const configPath = path.join(projectDir, TVI_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return null;
+		const configContent = await fs.readFile(configPath, "utf-8");
+		const errors = [];
+		const config = JSONC.parse(configContent, errors, {
+			allowTrailingComma: true,
+			disallowComments: false
+		});
+		if (errors.length > 0) {
+			console.warn("Warning: Found errors parsing tvi.jsonc:", errors);
+			return null;
+		}
+		return config;
+	} catch (_error) {
+		return null;
+	}
+}
+async function updateTviConfig(projectDir, updates) {
+	try {
+		const configPath = path.join(projectDir, TVI_CONFIG_FILE);
+		if (!await fs.pathExists(configPath)) return;
+		const configContent = await fs.readFile(configPath, "utf-8");
+		let modifiedContent = configContent;
+		for (const [key, value] of Object.entries(updates)) {
+			const editResult = JSONC.modify(modifiedContent, [key], value, { formattingOptions: {
+				tabSize: 2,
+				insertSpaces: true,
+				eol: "\n"
+			} });
+			modifiedContent = JSONC.applyEdits(modifiedContent, editResult);
+		}
+		await fs.writeFile(configPath, modifiedContent, "utf-8");
+	} catch (_error) {}
+}
+
+//#endregion
+//#region src/utils/add-package-deps.ts
+const addPackageDependency = async (opts) => {
+	const { dependencies = [], devDependencies = [], projectDir } = opts;
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	const pkgJson = await fs.readJson(pkgJsonPath);
+	if (!pkgJson.dependencies) pkgJson.dependencies = {};
+	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+	for (const pkgName of dependencies) {
+		const version = dependencyVersionMap[pkgName];
+		if (version) pkgJson.dependencies[pkgName] = version;
+		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+	}
+	for (const pkgName of devDependencies) {
+		const version = dependencyVersionMap[pkgName];
+		if (version) pkgJson.devDependencies[pkgName] = version;
+		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+	}
+	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+};
+
+//#endregion
+//#region src/utils/package-runner.ts
+/**
+* Returns the appropriate command for running a package without installing it globally,
+* based on the selected package manager.
+*
+* @param packageManager - The selected package manager (e.g., 'npm', 'yarn', 'pnpm', 'bun').
+* @param commandWithArgs - The command to run, including arguments (e.g., "prisma generate --schema=./prisma/schema.prisma").
+* @returns The full command string (e.g., "npx prisma generate --schema=./prisma/schema.prisma").
+*/
+function getPackageExecutionCommand(packageManager, commandWithArgs) {
+	switch (packageManager) {
+		case "pnpm": return `pnpm dlx ${commandWithArgs}`;
+		case "bun": return `bunx ${commandWithArgs}`;
+		default: return `npx ${commandWithArgs}`;
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/starlight-setup.ts
+async function setupStarlight(config) {
+	const { packageManager, projectDir } = config;
+	const s = spinner();
+	try {
+		s.start("Setting up Starlight docs...");
+		const starlightArgs = [
+			"docs",
+			"--template",
+			"starlight",
+			"--no-install",
+			"--add",
+			"tailwind",
+			"--no-git",
+			"--skip-houston"
+		];
+		const starlightArgsString = starlightArgs.join(" ");
+		const commandWithArgs = `create-astro@latest ${starlightArgsString}`;
+		const starlightInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+		await execa(starlightInitCommand, {
+			cwd: path.join(projectDir, "apps"),
+			env: { CI: "true" },
+			shell: true
+		});
+		s.stop("Starlight docs setup successfully!");
+	} catch (error) {
+		s.stop(pc.red("Failed to set up Starlight docs"));
+		if (error instanceof Error) consola.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/tauri-setup.ts
+async function setupTauri(config) {
+	const { packageManager, frontend, projectDir } = config;
+	const s = spinner();
+	const clientPackageDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(clientPackageDir)) return;
+	try {
+		s.start("Setting up Tauri desktop app support...");
+		await addPackageDependency({
+			devDependencies: ["@tauri-apps/cli"],
+			projectDir: clientPackageDir
+		});
+		const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
+		if (await fs.pathExists(clientPackageJsonPath)) {
+			const packageJson = await fs.readJson(clientPackageJsonPath);
+			packageJson.scripts = {
+				...packageJson.scripts,
+				tauri: "tauri",
+				"desktop:dev": "tauri dev",
+				"desktop:build": "tauri build"
+			};
+			await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
+		}
+		const _hasTanstackRouter = frontend.includes("tanstack-router");
+		const hasReactRouter = frontend.includes("react-router");
+		const hasNuxt = frontend.includes("nuxt");
+		const hasSvelte = frontend.includes("svelte");
+		const _hasSolid = frontend.includes("solid");
+		const hasNext = frontend.includes("next");
+		const devUrl = hasReactRouter || hasSvelte ? "http://localhost:5173" : hasNext ? "http://localhost:3001" : "http://localhost:3001";
+		const frontendDist = hasNuxt ? "../.output/public" : hasSvelte ? "../build" : hasNext ? "../.next" : hasReactRouter ? "../build/client" : "../dist";
+		const tauriArgs = [
+			"init",
+			`--app-name=${path.basename(projectDir)}`,
+			`--window-title=${path.basename(projectDir)}`,
+			`--frontend-dist=${frontendDist}`,
+			`--dev-url=${devUrl}`,
+			`--before-dev-command=\"${packageManager} run dev\"`,
+			`--before-build-command=\"${packageManager} run build\"`
+		];
+		const tauriArgsString = tauriArgs.join(" ");
+		const commandWithArgs = `@tauri-apps/cli@latest ${tauriArgsString}`;
+		const tauriInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+		await execa(tauriInitCommand, {
+			cwd: clientPackageDir,
+			env: { CI: "true" },
+			shell: true
+		});
+		s.stop("Tauri desktop app support configured successfully!");
+	} catch (error) {
+		s.stop(pc.red("Failed to set up Tauri"));
+		if (error instanceof Error) consola$1.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/addons-setup.ts
+async function setupAddons(config, isAddCommand = false) {
+	const { addons, frontend, projectDir } = config;
+	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
+	const hasNuxtFrontend = frontend.includes("nuxt");
+	const hasSvelteFrontend = frontend.includes("svelte");
+	const hasSolidFrontend = frontend.includes("solid");
+	const hasNextFrontend = frontend.includes("next");
+	if (addons.includes("turborepo")) {
+		await addPackageDependency({
+			devDependencies: ["turbo"],
+			projectDir
+		});
+		if (isAddCommand) log.info(`${pc.yellow("Update your package.json scripts:")}
+
+${pc.dim("Replace:")} ${pc.yellow("\"pnpm -r dev\"")} ${pc.dim("→")} ${pc.green("\"turbo dev\"")}
+${pc.dim("Replace:")} ${pc.yellow("\"pnpm --filter web dev\"")} ${pc.dim("→")} ${pc.green("\"turbo -F web dev\"")}
+
+${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
+		`);
+	}
+	if (addons.includes("pwa") && (hasReactWebFrontend || hasSolidFrontend)) await setupPwa(projectDir, frontend);
+	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await setupTauri(config);
+	if (addons.includes("biome")) await setupBiome(projectDir);
+	if (addons.includes("husky")) await setupHusky(projectDir);
+	if (addons.includes("starlight")) await setupStarlight(config);
+}
+function getWebAppDir(projectDir, frontends) {
+	if (frontends.some((f) => [
+		"react-router",
+		"tanstack-router",
+		"nuxt",
+		"svelte",
+		"solid"
+	].includes(f))) return path.join(projectDir, "apps/web");
+	return path.join(projectDir, "apps/web");
+}
+async function setupBiome(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["@biomejs/biome"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			check: "biome check --write ."
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+async function setupHusky(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["husky", "lint-staged"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			prepare: "husky"
+		};
+		packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+async function setupPwa(projectDir, frontends) {
+	const isCompatibleFrontend = frontends.some((f) => [
+		"react-router",
+		"tanstack-router",
+		"solid"
+	].includes(f));
+	if (!isCompatibleFrontend) return;
+	const clientPackageDir = getWebAppDir(projectDir, frontends);
+	if (!await fs.pathExists(clientPackageDir)) return;
+	await addPackageDependency({
+		dependencies: ["vite-plugin-pwa"],
+		devDependencies: ["@vite-pwa/assets-generator"],
+		projectDir: clientPackageDir
+	});
+	const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
+	if (await fs.pathExists(clientPackageJsonPath)) {
+		const packageJson = await fs.readJson(clientPackageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			"generate-pwa-assets": "pwa-assets-generator"
+		};
+		await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/project-generation/detect-project-config.ts
+async function detectProjectConfig(projectDir) {
+	try {
+		const tviConfig = await readTviConfig(projectDir);
+		if (tviConfig) return {
+			projectDir,
+			projectName: path.basename(projectDir),
+			database: tviConfig.database,
+			orm: tviConfig.orm,
+			backend: tviConfig.backend,
+			runtime: tviConfig.runtime,
+			frontend: tviConfig.frontend,
+			addons: tviConfig.addons,
+			examples: tviConfig.examples,
+			auth: tviConfig.auth,
+			packageManager: tviConfig.packageManager,
+			dbSetup: tviConfig.dbSetup,
+			api: tviConfig.api
+		};
+		return null;
+	} catch (_error) {
+		return null;
+	}
+}
+async function isBetterTStackProject(projectDir) {
+	try {
+		return await fs.pathExists(path.join(projectDir, "tvi.jsonc"));
+	} catch (_error) {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/helpers/project-generation/install-dependencies.ts
+async function installDependencies({ projectDir, packageManager }) {
+	const s = spinner();
+	try {
+		s.start(`Running ${packageManager} install...`);
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`${packageManager} install`;
+		s.stop("Dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("Failed to install dependencies"));
+		if (error instanceof Error) consola.error(pc.red(`Installation error: ${error.message}`));
+	}
+}
+
+//#endregion
+//#region src/utils/template-processor.ts
+/**
+* Processes a Handlebars template file and writes the output to the destination.
+* @param srcPath Path to the source .hbs template file.
+* @param destPath Path to write the processed file.
+* @param context Data to be passed to the Handlebars template.
+*/
+async function processTemplate(srcPath, destPath, context) {
+	try {
+		const templateContent = await fs.readFile(srcPath, "utf-8");
+		const template = handlebars.compile(templateContent);
+		const processedContent = template(context);
+		await fs.ensureDir(path.dirname(destPath));
+		await fs.writeFile(destPath, processedContent);
+	} catch (error) {
+		consola.error(`Error processing template ${srcPath}:`, error);
+		throw new Error(`Failed to process template ${srcPath}`);
+	}
+}
+handlebars.registerHelper("eq", (a, b) => a === b);
+handlebars.registerHelper("and", (a, b) => a && b);
+handlebars.registerHelper("or", (a, b) => a || b);
+handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
+
+//#endregion
+//#region src/helpers/project-generation/template-manager.ts
+async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true) {
+	const sourceFiles = await globby(sourcePattern, {
+		cwd: baseSourceDir,
+		dot: true,
+		onlyFiles: true,
+		absolute: false
+	});
+	for (const relativeSrcPath of sourceFiles) {
+		const srcPath = path.join(baseSourceDir, relativeSrcPath);
+		let relativeDestPath = relativeSrcPath;
+		if (relativeSrcPath.endsWith(".hbs")) relativeDestPath = relativeSrcPath.slice(0, -4);
+		const basename = path.basename(relativeSrcPath);
+		if (basename === "_gitignore") relativeDestPath = path.join(path.dirname(relativeSrcPath), ".gitignore");
+		else if (basename === "_npmrc") relativeDestPath = path.join(path.dirname(relativeSrcPath), ".npmrc");
+		const destPath = path.join(destDir, relativeDestPath);
+		try {
+			await fs.ensureDir(path.dirname(destPath));
+			if (!overwrite && await fs.pathExists(destPath)) continue;
+			if (srcPath.endsWith(".hbs")) await processTemplate(srcPath, destPath, context);
+			else await fs.copy(srcPath, destPath, { overwrite: true });
+		} catch (_error) {}
+	}
+}
+async function copyBaseTemplate(projectDir, context) {
+	const templateDir = path.join(PKG_ROOT, "templates/base");
+	await processAndCopyFiles(["**/*"], templateDir, projectDir, context);
+	await fs.ensureDir(path.join(projectDir, "packages"));
+}
+async function setupFrontendTemplates(projectDir, context) {
+	const hasReactWeb = context.frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	].includes(f));
+	const hasNuxtWeb = context.frontend.includes("nuxt");
+	const hasSvelteWeb = context.frontend.includes("svelte");
+	const hasSolidWeb = context.frontend.includes("solid");
+	const hasNativeWind = context.frontend.includes("native-nativewind");
+	const hasUnistyles = context.frontend.includes("native-unistyles");
+	const _hasNative = hasNativeWind || hasUnistyles;
+	const isConvex = context.backend === "convex";
+	if (hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) {
+		const webAppDir = path.join(projectDir, "apps/web");
+		await fs.ensureDir(webAppDir);
+		if (hasReactWeb) {
+			const webBaseDir = path.join(PKG_ROOT, "templates/frontend/react/web-base");
+			if (await fs.pathExists(webBaseDir)) await processAndCopyFiles("**/*", webBaseDir, webAppDir, context);
+			const reactFramework = context.frontend.find((f) => [
+				"tanstack-router",
+				"react-router",
+				"tanstack-start",
+				"next"
+			].includes(f));
+			if (reactFramework) {
+				const frameworkSrcDir = path.join(PKG_ROOT, `templates/frontend/react/${reactFramework}`);
+				if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, webAppDir, context);
+				if (!isConvex && context.api !== "none") {
+					const apiWebBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/react/base`);
+					if (await fs.pathExists(apiWebBaseDir)) await processAndCopyFiles("**/*", apiWebBaseDir, webAppDir, context);
+				}
+			}
+		} else if (hasNuxtWeb) {
+			const nuxtBaseDir = path.join(PKG_ROOT, "templates/frontend/nuxt");
+			if (await fs.pathExists(nuxtBaseDir)) await processAndCopyFiles("**/*", nuxtBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebNuxtDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/nuxt`);
+				if (await fs.pathExists(apiWebNuxtDir)) await processAndCopyFiles("**/*", apiWebNuxtDir, webAppDir, context);
+			}
+		} else if (hasSvelteWeb) {
+			const svelteBaseDir = path.join(PKG_ROOT, "templates/frontend/svelte");
+			if (await fs.pathExists(svelteBaseDir)) await processAndCopyFiles("**/*", svelteBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebSvelteDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/svelte`);
+				if (await fs.pathExists(apiWebSvelteDir)) await processAndCopyFiles("**/*", apiWebSvelteDir, webAppDir, context);
+			}
+		} else if (hasSolidWeb) {
+			const solidBaseDir = path.join(PKG_ROOT, "templates/frontend/solid");
+			if (await fs.pathExists(solidBaseDir)) await processAndCopyFiles("**/*", solidBaseDir, webAppDir, context);
+			if (!isConvex && context.api === "orpc") {
+				const apiWebSolidDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/solid`);
+				if (await fs.pathExists(apiWebSolidDir)) await processAndCopyFiles("**/*", apiWebSolidDir, webAppDir, context);
+			}
+		}
+	}
+	if (hasNativeWind || hasUnistyles) {
+		const nativeAppDir = path.join(projectDir, "apps/native");
+		await fs.ensureDir(nativeAppDir);
+		const nativeBaseCommonDir = path.join(PKG_ROOT, "templates/frontend/native/native-base");
+		if (await fs.pathExists(nativeBaseCommonDir)) await processAndCopyFiles("**/*", nativeBaseCommonDir, nativeAppDir, context);
+		let nativeFrameworkPath = "";
+		if (hasNativeWind) nativeFrameworkPath = "nativewind";
+		else if (hasUnistyles) nativeFrameworkPath = "unistyles";
+		const nativeSpecificDir = path.join(PKG_ROOT, `templates/frontend/native/${nativeFrameworkPath}`);
+		if (await fs.pathExists(nativeSpecificDir)) await processAndCopyFiles("**/*", nativeSpecificDir, nativeAppDir, context, true);
+		if (!isConvex && (context.api === "trpc" || context.api === "orpc")) {
+			const apiNativeSrcDir = path.join(PKG_ROOT, `templates/api/${context.api}/native`);
+			if (await fs.pathExists(apiNativeSrcDir)) await processAndCopyFiles("**/*", apiNativeSrcDir, nativeAppDir, context);
+		}
+	}
+}
+async function setupBackendFramework(projectDir, context) {
+	if (context.backend === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	if (context.backend === "convex") {
+		if (await fs.pathExists(serverAppDir)) await fs.remove(serverAppDir);
+		const convexBackendDestDir = path.join(projectDir, "packages/backend");
+		const convexSrcDir = path.join(PKG_ROOT, "templates/backend/convex/packages/backend");
+		await fs.ensureDir(convexBackendDestDir);
+		if (await fs.pathExists(convexSrcDir)) await processAndCopyFiles("**/*", convexSrcDir, convexBackendDestDir, context);
+		return;
+	}
+	await fs.ensureDir(serverAppDir);
+	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/server-base");
+	if (await fs.pathExists(serverBaseDir)) await processAndCopyFiles("**/*", serverBaseDir, serverAppDir, context);
+	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
+	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
+	if (context.api !== "none") {
+		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
+		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, serverAppDir, context, true);
+		const apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
+		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, serverAppDir, context, true);
+	}
+}
+async function setupDbOrmTemplates(projectDir, context) {
+	if (context.backend === "convex" || context.orm === "none" || context.database === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	await fs.ensureDir(serverAppDir);
+	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
+	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, serverAppDir, context);
+}
+async function setupAuthTemplate(projectDir, context) {
+	if (context.backend === "convex" || !context.auth) return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	const webAppDir = path.join(projectDir, "apps/web");
+	const nativeAppDir = path.join(projectDir, "apps/native");
+	const serverAppDirExists = await fs.pathExists(serverAppDir);
+	const webAppDirExists = await fs.pathExists(webAppDir);
+	const nativeAppDirExists = await fs.pathExists(nativeAppDir);
+	const hasReactWeb = context.frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	].includes(f));
+	const hasNuxtWeb = context.frontend.includes("nuxt");
+	const hasSvelteWeb = context.frontend.includes("svelte");
+	const hasSolidWeb = context.frontend.includes("solid");
+	const hasNativeWind = context.frontend.includes("native-nativewind");
+	const hasUnistyles = context.frontend.includes("native-unistyles");
+	const hasNative = hasNativeWind || hasUnistyles;
+	if (serverAppDirExists) {
+		const authServerBaseSrc = path.join(PKG_ROOT, "templates/auth/server/base");
+		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, serverAppDir, context);
+		if (context.backend === "next") {
+			const authServerNextSrc = path.join(PKG_ROOT, "templates/auth/server/next");
+			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, serverAppDir, context);
+		}
+		if (context.orm !== "none" && context.database !== "none") {
+			const orm = context.orm;
+			const db = context.database;
+			let authDbSrc = "";
+			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/drizzle/${db}`);
+			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/prisma/${db}`);
+			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/server/db/mongoose/${db}`);
+			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);
+			else if (authDbSrc) {}
+		}
+	}
+	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
+		if (hasReactWeb) {
+			const authWebBaseSrc = path.join(PKG_ROOT, "templates/auth/web/react/base");
+			if (await fs.pathExists(authWebBaseSrc)) await processAndCopyFiles("**/*", authWebBaseSrc, webAppDir, context);
+			const reactFramework = context.frontend.find((f) => [
+				"tanstack-router",
+				"react-router",
+				"tanstack-start",
+				"next"
+			].includes(f));
+			if (reactFramework) {
+				const authWebFrameworkSrc = path.join(PKG_ROOT, `templates/auth/web/react/${reactFramework}`);
+				if (await fs.pathExists(authWebFrameworkSrc)) await processAndCopyFiles("**/*", authWebFrameworkSrc, webAppDir, context);
+			}
+		} else if (hasNuxtWeb) {
+			const authWebNuxtSrc = path.join(PKG_ROOT, "templates/auth/web/nuxt");
+			if (await fs.pathExists(authWebNuxtSrc)) await processAndCopyFiles("**/*", authWebNuxtSrc, webAppDir, context);
+		} else if (hasSvelteWeb) {
+			if (context.api === "orpc") {
+				const authWebSvelteSrc = path.join(PKG_ROOT, "templates/auth/web/svelte");
+				if (await fs.pathExists(authWebSvelteSrc)) await processAndCopyFiles("**/*", authWebSvelteSrc, webAppDir, context);
+			}
+		} else if (hasSolidWeb) {
+			if (context.api === "orpc") {
+				const authWebSolidSrc = path.join(PKG_ROOT, "templates/auth/web/solid");
+				if (await fs.pathExists(authWebSolidSrc)) await processAndCopyFiles("**/*", authWebSolidSrc, webAppDir, context);
+			}
+		}
+	}
+	if (hasNative && nativeAppDirExists) {
+		const authNativeBaseSrc = path.join(PKG_ROOT, "templates/auth/native/native-base");
+		if (await fs.pathExists(authNativeBaseSrc)) await processAndCopyFiles("**/*", authNativeBaseSrc, nativeAppDir, context);
+		let nativeFrameworkAuthPath = "";
+		if (hasNativeWind) nativeFrameworkAuthPath = "nativewind";
+		else if (hasUnistyles) nativeFrameworkAuthPath = "unistyles";
+		if (nativeFrameworkAuthPath) {
+			const authNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/native/${nativeFrameworkAuthPath}`);
+			if (await fs.pathExists(authNativeFrameworkSrc)) await processAndCopyFiles("**/*", authNativeFrameworkSrc, nativeAppDir, context);
+		}
+	}
+}
+async function setupAddonsTemplate(projectDir, context) {
+	if (!context.addons || context.addons.length === 0) return;
+	for (const addon of context.addons) {
+		if (addon === "none") continue;
+		let addonSrcDir = path.join(PKG_ROOT, `templates/addons/${addon}`);
+		let addonDestDir = projectDir;
+		if (addon === "pwa") {
+			const webAppDir = path.join(projectDir, "apps/web");
+			if (!await fs.pathExists(webAppDir)) continue;
+			addonDestDir = webAppDir;
+			if (context.frontend.includes("next")) addonSrcDir = path.join(PKG_ROOT, "templates/addons/pwa/apps/web/next");
+			else if (context.frontend.some((f) => [
+				"tanstack-router",
+				"react-router",
+				"solid"
+			].includes(f))) addonSrcDir = path.join(PKG_ROOT, "templates/addons/pwa/apps/web/vite");
+			else continue;
+		}
+		if (await fs.pathExists(addonSrcDir)) await processAndCopyFiles("**/*", addonSrcDir, addonDestDir, context);
+	}
+}
+async function setupExamplesTemplate(projectDir, context) {
+	if (!context.examples || context.examples.length === 0 || context.examples[0] === "none") return;
+	const serverAppDir = path.join(projectDir, "apps/server");
+	const webAppDir = path.join(projectDir, "apps/web");
+	const serverAppDirExists = await fs.pathExists(serverAppDir);
+	const webAppDirExists = await fs.pathExists(webAppDir);
+	const nativeAppDir = path.join(projectDir, "apps/native");
+	const nativeAppDirExists = await fs.pathExists(nativeAppDir);
+	const hasReactWeb = context.frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	].includes(f));
+	const hasNuxtWeb = context.frontend.includes("nuxt");
+	const hasSvelteWeb = context.frontend.includes("svelte");
+	const hasSolidWeb = context.frontend.includes("solid");
+	for (const example of context.examples) {
+		if (example === "none") continue;
+		const exampleBaseDir = path.join(PKG_ROOT, `templates/examples/${example}`);
+		if (serverAppDirExists && context.backend !== "convex" && context.backend !== "none") {
+			const exampleServerSrc = path.join(exampleBaseDir, "server");
+			if (example === "ai" && context.backend === "next") {
+				const aiNextServerSrc = path.join(exampleServerSrc, "next");
+				if (await fs.pathExists(aiNextServerSrc)) await processAndCopyFiles("**/*", aiNextServerSrc, serverAppDir, context, false);
+			}
+			if (context.orm !== "none" && context.database !== "none") {
+				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
+				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, serverAppDir, context, false);
+				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
+				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, serverAppDir, context, false);
+			}
+			const ignorePatterns = [`${context.orm}/**`];
+			if (example === "ai" && context.backend === "next") ignorePatterns.push("next/**");
+			const generalServerFiles = await globby(["**/*.ts", "**/*.hbs"], {
+				cwd: exampleServerSrc,
+				onlyFiles: true,
+				deep: 1,
+				ignore: ignorePatterns
+			});
+			for (const file of generalServerFiles) {
+				const srcPath = path.join(exampleServerSrc, file);
+				const destPath = path.join(serverAppDir, file.replace(".hbs", ""));
+				try {
+					if (srcPath.endsWith(".hbs")) await processTemplate(srcPath, destPath, context);
+					else if (!await fs.pathExists(destPath)) await fs.copy(srcPath, destPath, { overwrite: false });
+				} catch (_error) {}
+			}
+		}
+		if (webAppDirExists) {
+			if (hasReactWeb) {
+				const exampleWebSrc = path.join(exampleBaseDir, "web/react");
+				if (await fs.pathExists(exampleWebSrc)) {
+					const reactFramework = context.frontend.find((f) => [
+						"next",
+						"react-router",
+						"tanstack-router",
+						"tanstack-start"
+					].includes(f));
+					if (reactFramework) {
+						const exampleWebFrameworkSrc = path.join(exampleWebSrc, reactFramework);
+						if (await fs.pathExists(exampleWebFrameworkSrc)) await processAndCopyFiles("**/*", exampleWebFrameworkSrc, webAppDir, context, false);
+					}
+				}
+			} else if (hasNuxtWeb) {
+				const exampleWebNuxtSrc = path.join(exampleBaseDir, "web/nuxt");
+				if (await fs.pathExists(exampleWebNuxtSrc)) await processAndCopyFiles("**/*", exampleWebNuxtSrc, webAppDir, context, false);
+			} else if (hasSvelteWeb) {
+				const exampleWebSvelteSrc = path.join(exampleBaseDir, "web/svelte");
+				if (await fs.pathExists(exampleWebSvelteSrc)) await processAndCopyFiles("**/*", exampleWebSvelteSrc, webAppDir, context, false);
+			} else if (hasSolidWeb) {
+				const exampleWebSolidSrc = path.join(exampleBaseDir, "web/solid");
+				if (await fs.pathExists(exampleWebSolidSrc)) await processAndCopyFiles("**/*", exampleWebSolidSrc, webAppDir, context, false);
+			}
+		}
+		if (nativeAppDirExists) {
+			const hasNativeWind = context.frontend.includes("native-nativewind");
+			const hasUnistyles = context.frontend.includes("native-unistyles");
+			if (hasNativeWind || hasUnistyles) {
+				let nativeFramework = "";
+				if (hasNativeWind) nativeFramework = "nativewind";
+				else if (hasUnistyles) nativeFramework = "unistyles";
+				const exampleNativeSrc = path.join(exampleBaseDir, `native/${nativeFramework}`);
+				if (await fs.pathExists(exampleNativeSrc)) await processAndCopyFiles("**/*", exampleNativeSrc, nativeAppDir, context, false);
+			}
+		}
+	}
+}
+async function handleExtras(projectDir, context) {
+	const extrasDir = path.join(PKG_ROOT, "templates/extras");
+	const hasNativeWind = context.frontend.includes("native-nativewind");
+	const hasUnistyles = context.frontend.includes("native-unistyles");
+	const hasNative = hasNativeWind || hasUnistyles;
+	if (context.packageManager === "pnpm") {
+		const pnpmWorkspaceSrc = path.join(extrasDir, "pnpm-workspace.yaml");
+		const pnpmWorkspaceDest = path.join(projectDir, "pnpm-workspace.yaml");
+		if (await fs.pathExists(pnpmWorkspaceSrc)) await fs.copy(pnpmWorkspaceSrc, pnpmWorkspaceDest);
+	}
+	if (context.packageManager === "pnpm" && (hasNative || context.frontend.includes("nuxt"))) {
+		const npmrcTemplateSrc = path.join(extrasDir, "_npmrc.hbs");
+		const npmrcDest = path.join(projectDir, ".npmrc");
+		if (await fs.pathExists(npmrcTemplateSrc)) await processTemplate(npmrcTemplateSrc, npmrcDest, context);
+	}
+	if (context.runtime === "workers") {
+		const runtimeWorkersDir = path.join(PKG_ROOT, "templates/runtime/workers");
+		if (await fs.pathExists(runtimeWorkersDir)) await processAndCopyFiles("**/*", runtimeWorkersDir, projectDir, context, false);
+	}
+}
+
+//#endregion
+//#region src/helpers/project-generation/add-addons.ts
+function exitWithError(message) {
+	cancel(pc.red(message));
+	process.exit(1);
+}
+async function addAddonsToProject(input) {
+	try {
+		const projectDir = input.projectDir || process.cwd();
+		const isBetterTStack = await isBetterTStackProject(projectDir);
+		if (!isBetterTStack) exitWithError("This doesn't appear to be a tvi project. Please run this command from the root of a tvi project.");
+		const detectedConfig = await detectProjectConfig(projectDir);
+		if (!detectedConfig) exitWithError("Could not detect the project configuration. Please ensure this is a valid tvi project.");
+		const config = {
+			projectName: detectedConfig.projectName || path.basename(projectDir),
+			projectDir,
+			relativePath: ".",
+			database: detectedConfig.database || "none",
+			orm: detectedConfig.orm || "none",
+			backend: detectedConfig.backend || "none",
+			runtime: detectedConfig.runtime || "none",
+			frontend: detectedConfig.frontend || [],
+			addons: input.addons,
+			examples: detectedConfig.examples || [],
+			auth: detectedConfig.auth || false,
+			git: false,
+			packageManager: input.packageManager || detectedConfig.packageManager || "npm",
+			install: input.install || false,
+			dbSetup: detectedConfig.dbSetup || "none",
+			api: detectedConfig.api || "none"
+		};
+		for (const addon of input.addons) {
+			const { isCompatible, reason } = validateAddonCompatibility(addon, config.frontend);
+			if (!isCompatible) exitWithError(reason || `${addon} addon is not compatible with current frontend configuration`);
+		}
+		log.info(pc.green(`Adding ${input.addons.join(", ")} to ${config.frontend.join("/")}`));
+		await setupAddonsTemplate(projectDir, config);
+		await setupAddons(config, true);
+		const currentAddons = detectedConfig.addons || [];
+		const mergedAddons = [...new Set([...currentAddons, ...input.addons])];
+		await updateTviConfig(projectDir, { addons: mergedAddons });
+		if (config.install) await installDependencies({
+			projectDir,
+			packageManager: config.packageManager
+		});
+		else log.info(pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		exitWithError(`Error adding addons: ${message}`);
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/api-setup.ts
+async function setupApi(config) {
+	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
+	const isConvex = backend === "convex";
+	const webDir = path.join(projectDir, "apps/web");
+	const nativeDir = path.join(projectDir, "apps/native");
+	const webDirExists = await fs.pathExists(webDir);
+	const nativeDirExists = await fs.pathExists(nativeDir);
+	const hasReactWeb = frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	].includes(f));
+	const hasNuxtWeb = frontend.includes("nuxt");
+	const hasSvelteWeb = frontend.includes("svelte");
+	const hasSolidWeb = frontend.includes("solid");
+	if (!isConvex && api !== "none") {
+		const serverDir = path.join(projectDir, "apps/server");
+		const serverDirExists = await fs.pathExists(serverDir);
+		if (serverDirExists) {
+			if (api === "orpc") await addPackageDependency({
+				dependencies: ["@orpc/server", "@orpc/client"],
+				projectDir: serverDir
+			});
+			else if (api === "trpc") {
+				await addPackageDependency({
+					dependencies: ["@trpc/server", "@trpc/client"],
+					projectDir: serverDir
+				});
+				if (config.backend === "hono") await addPackageDependency({
+					dependencies: ["@hono/trpc-server"],
+					projectDir: serverDir
+				});
+				else if (config.backend === "elysia") await addPackageDependency({
+					dependencies: ["@elysiajs/trpc"],
+					projectDir: serverDir
+				});
+			}
+		}
+		if (webDirExists) {
+			if (hasReactWeb) {
+				if (api === "orpc") await addPackageDependency({
+					dependencies: [
+						"@orpc/tanstack-query",
+						"@orpc/client",
+						"@orpc/server"
+					],
+					projectDir: webDir
+				});
+				else if (api === "trpc") await addPackageDependency({
+					dependencies: [
+						"@trpc/tanstack-react-query",
+						"@trpc/client",
+						"@trpc/server"
+					],
+					projectDir: webDir
+				});
+			} else if (hasNuxtWeb) {
+				if (api === "orpc") await addPackageDependency({
+					dependencies: [
+						"@orpc/tanstack-query",
+						"@orpc/client",
+						"@orpc/server"
+					],
+					projectDir: webDir
+				});
+			} else if (hasSvelteWeb) {
+				if (api === "orpc") await addPackageDependency({
+					dependencies: [
+						"@orpc/tanstack-query",
+						"@orpc/client",
+						"@orpc/server",
+						"@tanstack/svelte-query"
+					],
+					projectDir: webDir
+				});
+			} else if (hasSolidWeb) {
+				if (api === "orpc") await addPackageDependency({
+					dependencies: [
+						"@orpc/tanstack-query",
+						"@orpc/client",
+						"@orpc/server",
+						"@tanstack/solid-query"
+					],
+					projectDir: webDir
+				});
+			}
+		}
+		if (nativeDirExists) {
+			if (api === "trpc") await addPackageDependency({
+				dependencies: [
+					"@trpc/tanstack-react-query",
+					"@trpc/client",
+					"@trpc/server"
+				],
+				projectDir: nativeDir
+			});
+			else if (api === "orpc") await addPackageDependency({
+				dependencies: [
+					"@orpc/tanstack-query",
+					"@orpc/client",
+					"@orpc/server"
+				],
+				projectDir: nativeDir
+			});
+		}
+	}
+	const reactBasedFrontends = [
+		"react-router",
+		"tanstack-router",
+		"tanstack-start",
+		"next",
+		"native-nativewind",
+		"native-unistyles"
+	];
+	const needsSolidQuery = frontend.includes("solid");
+	const needsReactQuery = frontend.some((f) => reactBasedFrontends.includes(f));
+	if (needsReactQuery && !isConvex) {
+		const reactQueryDeps = ["@tanstack/react-query"];
+		const reactQueryDevDeps = ["@tanstack/react-query-devtools"];
+		const hasReactWeb$1 = frontend.some((f) => f !== "native-nativewind" && f !== "native-unistyles" && reactBasedFrontends.includes(f));
+		const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+		if (hasReactWeb$1 && webDirExists) {
+			const webPkgJsonPath = path.join(webDir, "package.json");
+			if (await fs.pathExists(webPkgJsonPath)) try {
+				await addPackageDependency({
+					dependencies: reactQueryDeps,
+					devDependencies: reactQueryDevDeps,
+					projectDir: webDir
+				});
+			} catch (_error) {}
+		}
+		if (hasNative && nativeDirExists) {
+			const nativePkgJsonPath = path.join(nativeDir, "package.json");
+			if (await fs.pathExists(nativePkgJsonPath)) try {
+				await addPackageDependency({
+					dependencies: reactQueryDeps,
+					projectDir: nativeDir
+				});
+			} catch (_error) {}
+		}
+	}
+	if (needsSolidQuery && !isConvex) {
+		const solidQueryDeps = ["@tanstack/solid-query"];
+		const solidQueryDevDeps = ["@tanstack/solid-query-devtools"];
+		if (webDirExists) {
+			const webPkgJsonPath = path.join(webDir, "package.json");
+			if (await fs.pathExists(webPkgJsonPath)) try {
+				await addPackageDependency({
+					dependencies: solidQueryDeps,
+					devDependencies: solidQueryDevDeps,
+					projectDir: webDir
+				});
+			} catch (_error) {}
+		}
+	}
+	if (isConvex) {
+		if (webDirExists) {
+			const webPkgJsonPath = path.join(webDir, "package.json");
+			if (await fs.pathExists(webPkgJsonPath)) try {
+				const webDepsToAdd = ["convex"];
+				if (frontend.includes("tanstack-start")) webDepsToAdd.push("@convex-dev/react-query");
+				if (hasSvelteWeb) webDepsToAdd.push("convex-svelte");
+				await addPackageDependency({
+					dependencies: webDepsToAdd,
+					projectDir: webDir
+				});
+			} catch (_error) {}
+		}
+		if (nativeDirExists) {
+			const nativePkgJsonPath = path.join(nativeDir, "package.json");
+			if (await fs.pathExists(nativePkgJsonPath)) try {
+				await addPackageDependency({
+					dependencies: ["convex"],
+					projectDir: nativeDir
+				});
+			} catch (_error) {}
+		}
+		const backendPackageName = `@${projectName}/backend`;
+		const backendWorkspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
+		const addWorkspaceDepManually = async (pkgJsonPath, depName, depVersion) => {
+			try {
+				const pkgJson = await fs.readJson(pkgJsonPath);
+				if (!pkgJson.dependencies) pkgJson.dependencies = {};
+				if (pkgJson.dependencies[depName] !== depVersion) {
+					pkgJson.dependencies[depName] = depVersion;
+					await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+				}
+			} catch (_error) {}
+		};
+		if (webDirExists) {
+			const webPkgJsonPath = path.join(webDir, "package.json");
+			if (await fs.pathExists(webPkgJsonPath)) await addWorkspaceDepManually(webPkgJsonPath, backendPackageName, backendWorkspaceVersion);
+		}
+		if (nativeDirExists) {
+			const nativePkgJsonPath = path.join(nativeDir, "package.json");
+			if (await fs.pathExists(nativePkgJsonPath)) await addWorkspaceDepManually(nativePkgJsonPath, backendPackageName, backendWorkspaceVersion);
+		}
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/auth-setup.ts
+async function setupAuth(config) {
+	const { auth, frontend, backend, projectDir } = config;
+	if (backend === "convex" || !auth) return;
+	const serverDir = path.join(projectDir, "apps/server");
+	const clientDir = path.join(projectDir, "apps/web");
+	const nativeDir = path.join(projectDir, "apps/native");
+	const clientDirExists = await fs.pathExists(clientDir);
+	const nativeDirExists = await fs.pathExists(nativeDir);
+	const serverDirExists = await fs.pathExists(serverDir);
+	try {
+		if (serverDirExists) await addPackageDependency({
+			dependencies: ["better-auth"],
+			projectDir: serverDir
+		});
+		const hasWebFrontend = frontend.some((f) => [
+			"react-router",
+			"tanstack-router",
+			"tanstack-start",
+			"next",
+			"nuxt",
+			"svelte",
+			"solid"
+		].includes(f));
+		if (hasWebFrontend && clientDirExists) await addPackageDependency({
+			dependencies: ["better-auth"],
+			projectDir: clientDir
+		});
+		if ((frontend.includes("native-nativewind") || frontend.includes("native-unistyles")) && nativeDirExists) {
+			await addPackageDependency({
+				dependencies: ["better-auth", "@better-auth/expo"],
+				projectDir: nativeDir
+			});
+			if (serverDirExists) await addPackageDependency({
+				dependencies: ["@better-auth/expo"],
+				projectDir: serverDir
+			});
+		}
+	} catch (error) {
+		consola.error(pc.red("Failed to configure authentication dependencies"));
+		if (error instanceof Error) consola.error(pc.red(error.message));
+	}
+}
+function generateAuthSecret(length = 32) {
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let result = "";
+	const charactersLength = characters.length;
+	for (let i = 0; i < length; i++) result += characters.charAt(Math.floor(Math.random() * charactersLength));
+	return result;
+}
+
+//#endregion
+//#region src/helpers/setup/backend-setup.ts
+async function setupBackendDependencies(config) {
+	const { backend, runtime, api, projectDir } = config;
+	if (backend === "convex") return;
+	const framework = backend;
+	const serverDir = path.join(projectDir, "apps/server");
+	const dependencies = [];
+	const devDependencies = [];
+	if (framework === "hono") {
+		dependencies.push("hono");
+		if (api === "trpc") dependencies.push("@hono/trpc-server");
+		if (runtime === "node") {
+			dependencies.push("@hono/node-server");
+			devDependencies.push("tsx", "@types/node");
+		}
+	} else if (framework === "elysia") {
+		dependencies.push("elysia", "@elysiajs/cors");
+		if (api === "trpc") dependencies.push("@elysiajs/trpc");
+		if (runtime === "node") {
+			dependencies.push("@elysiajs/node");
+			devDependencies.push("tsx", "@types/node");
+		}
+	} else if (framework === "express") {
+		dependencies.push("express", "cors");
+		devDependencies.push("@types/express", "@types/cors");
+		if (runtime === "node") devDependencies.push("tsx", "@types/node");
+	} else if (framework === "fastify") {
+		dependencies.push("fastify", "@fastify/cors");
+		if (runtime === "node") devDependencies.push("tsx", "@types/node");
+	}
+	if (runtime === "bun") devDependencies.push("@types/bun");
+	if (dependencies.length > 0 || devDependencies.length > 0) await addPackageDependency({
+		dependencies,
+		devDependencies,
+		projectDir: serverDir
+	});
+}
+
+//#endregion
+//#region src/helpers/project-generation/env-setup.ts
+async function addEnvVariablesToFile(filePath, variables) {
+	await fs.ensureDir(path.dirname(filePath));
+	let envContent = "";
+	if (await fs.pathExists(filePath)) envContent = await fs.readFile(filePath, "utf8");
+	let modified = false;
+	let contentToAdd = "";
+	const exampleVariables = [];
+	for (const { key, value, condition } of variables) if (condition) {
+		const regex = new RegExp(`^${key}=.*$`, "m");
+		const valueToWrite = value ?? "";
+		exampleVariables.push(`${key}=`);
+		if (regex.test(envContent)) {
+			const existingMatch = envContent.match(regex);
+			if (existingMatch && existingMatch[0] !== `${key}=${valueToWrite}`) {
+				envContent = envContent.replace(regex, `${key}=${valueToWrite}`);
+				modified = true;
+			}
+		} else {
+			contentToAdd += `${key}=${valueToWrite}\n`;
+			modified = true;
+		}
+	}
+	if (contentToAdd) {
+		if (envContent.length > 0 && !envContent.endsWith("\n")) envContent += "\n";
+		envContent += contentToAdd;
+	}
+	if (modified) await fs.writeFile(filePath, envContent.trimEnd());
+	const exampleFilePath = filePath.replace(/\.env$/, ".env.example");
+	let exampleEnvContent = "";
+	if (await fs.pathExists(exampleFilePath)) exampleEnvContent = await fs.readFile(exampleFilePath, "utf8");
+	let exampleModified = false;
+	let exampleContentToAdd = "";
+	for (const exampleVar of exampleVariables) {
+		const key = exampleVar.split("=")[0];
+		const regex = new RegExp(`^${key}=.*$`, "m");
+		if (!regex.test(exampleEnvContent)) {
+			exampleContentToAdd += `${exampleVar}\n`;
+			exampleModified = true;
+		}
+	}
+	if (exampleContentToAdd) {
+		if (exampleEnvContent.length > 0 && !exampleEnvContent.endsWith("\n")) exampleEnvContent += "\n";
+		exampleEnvContent += exampleContentToAdd;
+	}
+	if (exampleModified || !await fs.pathExists(exampleFilePath)) await fs.writeFile(exampleFilePath, exampleEnvContent.trimEnd());
+}
+async function setupEnvironmentVariables(config) {
+	const { backend, frontend, database, auth, examples, dbSetup, projectDir } = config;
+	const hasReactRouter = frontend.includes("react-router");
+	const hasTanStackRouter = frontend.includes("tanstack-router");
+	const hasTanStackStart = frontend.includes("tanstack-start");
+	const hasNextJs = frontend.includes("next");
+	const hasNuxt = frontend.includes("nuxt");
+	const hasSvelte = frontend.includes("svelte");
+	const hasSolid = frontend.includes("solid");
+	const hasWebFrontend = hasReactRouter || hasTanStackRouter || hasTanStackStart || hasNextJs || hasNuxt || hasSolid || hasSvelte;
+	if (hasWebFrontend) {
+		const clientDir = path.join(projectDir, "apps/web");
+		if (await fs.pathExists(clientDir)) {
+			let envVarName = "VITE_SERVER_URL";
+			let serverUrl = "http://localhost:3000";
+			if (hasNextJs) envVarName = "NEXT_PUBLIC_SERVER_URL";
+			else if (hasNuxt) envVarName = "NUXT_PUBLIC_SERVER_URL";
+			else if (hasSvelte) envVarName = "PUBLIC_SERVER_URL";
+			if (backend === "convex") {
+				if (hasNextJs) envVarName = "NEXT_PUBLIC_CONVEX_URL";
+				else if (hasNuxt) envVarName = "NUXT_PUBLIC_CONVEX_URL";
+				else if (hasSvelte) envVarName = "PUBLIC_CONVEX_URL";
+				else envVarName = "VITE_CONVEX_URL";
+				serverUrl = "https://<YOUR_CONVEX_URL>";
+			}
+			const clientVars = [{
+				key: envVarName,
+				value: serverUrl,
+				condition: true
+			}];
+			await addEnvVariablesToFile(path.join(clientDir, ".env"), clientVars);
+		}
+	}
+	if (frontend.includes("native-nativewind") || frontend.includes("native-unistyles")) {
+		const nativeDir = path.join(projectDir, "apps/native");
+		if (await fs.pathExists(nativeDir)) {
+			let envVarName = "EXPO_PUBLIC_SERVER_URL";
+			let serverUrl = "http://localhost:3000";
+			if (backend === "convex") {
+				envVarName = "EXPO_PUBLIC_CONVEX_URL";
+				serverUrl = "https://<YOUR_CONVEX_URL>";
+			}
+			const nativeVars = [{
+				key: envVarName,
+				value: serverUrl,
+				condition: true
+			}];
+			await addEnvVariablesToFile(path.join(nativeDir, ".env"), nativeVars);
+		}
+	}
+	if (backend === "convex") return;
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	const envPath = path.join(serverDir, ".env");
+	let corsOrigin = "http://localhost:3001";
+	if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
+	let databaseUrl = null;
+	const specializedSetup = dbSetup === "turso" || dbSetup === "prisma-postgres" || dbSetup === "mongodb-atlas" || dbSetup === "neon" || dbSetup === "supabase" || dbSetup === "d1";
+	if (database !== "none" && !specializedSetup) switch (database) {
+		case "postgres":
+			databaseUrl = "postgresql://postgres:password@localhost:5432/postgres";
+			break;
+		case "mysql":
+			databaseUrl = "mysql://root:password@localhost:3306/mydb";
+			break;
+		case "mongodb":
+			databaseUrl = "mongodb://localhost:27017/mydatabase";
+			break;
+		case "sqlite":
+			if (config.runtime === "workers") databaseUrl = "http://127.0.0.1:8080";
+			else databaseUrl = "file:./local.db";
+			break;
+	}
+	const serverVars = [
+		{
+			key: "CORS_ORIGIN",
+			value: corsOrigin,
+			condition: true
+		},
+		{
+			key: "BETTER_AUTH_SECRET",
+			value: generateAuthSecret(),
+			condition: !!auth
+		},
+		{
+			key: "BETTER_AUTH_URL",
+			value: "http://localhost:3000",
+			condition: !!auth
+		},
+		{
+			key: "DATABASE_URL",
+			value: databaseUrl,
+			condition: database !== "none" && !specializedSetup
+		},
+		{
+			key: "GOOGLE_GENERATIVE_AI_API_KEY",
+			value: "",
+			condition: examples?.includes("ai") || false
+		}
+	];
+	await addEnvVariablesToFile(envPath, serverVars);
+	if (config.runtime === "workers") {
+		const devVarsPath = path.join(serverDir, ".dev.vars");
+		try {
+			await fs.copy(envPath, devVarsPath);
+		} catch (_err) {}
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/d1-setup.ts
+async function setupCloudflareD1(config) {
+	const { projectDir } = config;
+	const envPath = path.join(projectDir, "apps/server", ".env");
+	const variables = [
+		{
+			key: "CLOUDFLARE_ACCOUNT_ID",
+			value: "",
+			condition: true
+		},
+		{
+			key: "CLOUDFLARE_DATABASE_ID",
+			value: "",
+			condition: true
+		},
+		{
+			key: "CLOUDFLARE_D1_TOKEN",
+			value: "",
+			condition: true
+		}
+	];
+	try {
+		await addEnvVariablesToFile(envPath, variables);
+	} catch (_err) {}
+}
+
+//#endregion
+//#region src/utils/command-exists.ts
+async function commandExists(command) {
+	try {
+		const isWindows = process.platform === "win32";
+		if (isWindows) {
+			const result$1 = await execa("where", [command]);
+			return result$1.exitCode === 0;
+		}
+		const result = await execa("which", [command]);
+		return result.exitCode === 0;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/mongodb-atlas-setup.ts
+async function checkAtlasCLI() {
+	const s = spinner();
+	s.start("Checking for MongoDB Atlas CLI...");
+	try {
+		const exists = await commandExists("atlas");
+		s.stop(exists ? "MongoDB Atlas CLI found" : pc.yellow("MongoDB Atlas CLI not found"));
+		return exists;
+	} catch (_error) {
+		s.stop(pc.red("Error checking MongoDB Atlas CLI"));
+		return false;
+	}
+}
+async function initMongoDBAtlas(serverDir) {
+	try {
+		const hasAtlas = await checkAtlasCLI();
+		if (!hasAtlas) {
+			consola.error(pc.red("MongoDB Atlas CLI not found."));
+			log.info(pc.yellow("Please install it from: https://www.mongodb.com/docs/atlas/cli/current/install-atlas-cli/"));
+			return null;
+		}
+		log.info(pc.blue("Running MongoDB Atlas setup..."));
+		await execa("atlas", ["deployments", "setup"], {
+			cwd: serverDir,
+			stdio: "inherit"
+		});
+		log.info(pc.green("MongoDB Atlas deployment ready"));
+		const connectionString = await text({
+			message: "Enter your MongoDB connection string:",
+			placeholder: "mongodb+srv://username:password@cluster.mongodb.net/database",
+			validate(value) {
+				if (!value) return "Please enter a connection string";
+				if (!value.startsWith("mongodb")) return "URL should start with mongodb:// or mongodb+srv://";
+			}
+		});
+		if (isCancel(connectionString)) {
+			cancel("MongoDB setup cancelled");
+			return null;
+		}
+		return { connectionString };
+	} catch (error) {
+		if (error instanceof Error) consola.error(pc.red(error.message));
+		return null;
+	}
+}
+async function writeEnvFile$3(projectDir, config) {
+	try {
+		const envPath = path.join(projectDir, "apps/server", ".env");
+		const variables = [{
+			key: "DATABASE_URL",
+			value: config?.connectionString ?? "mongodb://localhost:27017/mydb",
+			condition: true
+		}];
+		await addEnvVariablesToFile(envPath, variables);
+	} catch (_error) {
+		consola.error("Failed to update environment configuration");
+	}
+}
+function displayManualSetupInstructions$3() {
+	log.info(`
+${pc.green("MongoDB Atlas Manual Setup Instructions:")}
+
+1. Install Atlas CLI:
+   ${pc.blue("https://www.mongodb.com/docs/atlas/cli/stable/install-atlas-cli/")}
+
+2. Run the following command and follow the prompts:
+   ${pc.blue("atlas deployments setup")}
+
+3. Get your connection string from the Atlas dashboard:
+   Format: ${pc.dim("mongodb+srv://USERNAME:PASSWORD@CLUSTER.mongodb.net/DATABASE_NAME")}
+
+4. Add the connection string to your .env file:
+   ${pc.dim("DATABASE_URL=\"your_connection_string\"")}
+`);
+}
+async function setupMongoDBAtlas(config) {
+	const { projectDir } = config;
+	const mainSpinner = spinner();
+	mainSpinner.start("Setting up MongoDB Atlas...");
+	const serverDir = path.join(projectDir, "apps/server");
+	try {
+		await fs.ensureDir(serverDir);
+		mainSpinner.stop("MongoDB Atlas setup ready");
+		const config$1 = await initMongoDBAtlas(serverDir);
+		if (config$1) {
+			await writeEnvFile$3(projectDir, 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);
+			displayManualSetupInstructions$3();
+		}
+	} catch (error) {
+		mainSpinner.stop(pc.red("MongoDB Atlas setup failed"));
+		consola.error(pc.red(`Error during MongoDB Atlas setup: ${error instanceof Error ? error.message : String(error)}`));
+		try {
+			await writeEnvFile$3(projectDir);
+			displayManualSetupInstructions$3();
+		} catch {}
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/neon-setup.ts
+const NEON_REGIONS = [
+	{
+		label: "AWS US East (N. Virginia)",
+		value: "aws-us-east-1"
+	},
+	{
+		label: "AWS US East (Ohio)",
+		value: "aws-us-east-2"
+	},
+	{
+		label: "AWS US West (Oregon)",
+		value: "aws-us-west-2"
+	},
+	{
+		label: "AWS Europe (Frankfurt)",
+		value: "aws-eu-central-1"
+	},
+	{
+		label: "AWS Asia Pacific (Singapore)",
+		value: "aws-ap-southeast-1"
+	},
+	{
+		label: "AWS Asia Pacific (Sydney)",
+		value: "aws-ap-southeast-2"
+	},
+	{
+		label: "Azure East US 2 region (Virginia)",
+		value: "azure-eastus2"
+	}
+];
+async function executeNeonCommand(packageManager, commandArgsString, spinnerText) {
+	const s = spinner();
+	try {
+		const fullCommand = getPackageExecutionCommand(packageManager, commandArgsString);
+		if (spinnerText) s.start(spinnerText);
+		const result = await execa(fullCommand, { shell: true });
+		if (spinnerText) s.stop(pc.green(spinnerText.replace("...", "").replace("ing ", "ed ").trim()));
+		return result;
+	} catch (error) {
+		if (s) s.stop(pc.red(`Failed: ${spinnerText || "Command execution"}`));
+		throw error;
+	}
+}
+async function createNeonProject(projectName, regionId, packageManager) {
+	try {
+		const commandArgsString = `neonctl projects create --name ${projectName} --region-id ${regionId} --output json`;
+		const { stdout } = await executeNeonCommand(packageManager, commandArgsString, `Creating Neon project "${projectName}"...`);
+		const response = JSON.parse(stdout);
+		if (response.project && response.connection_uris && response.connection_uris.length > 0) {
+			const projectId = response.project.id;
+			const connectionUri = response.connection_uris[0].connection_uri;
+			const params = response.connection_uris[0].connection_parameters;
+			return {
+				connectionString: connectionUri,
+				projectId,
+				dbName: params.database,
+				roleName: params.role
+			};
+		}
+		consola$1.error(pc.red("Failed to extract connection information from response"));
+		return null;
+	} catch (_error) {
+		consola$1.error(pc.red("Failed to create Neon project"));
+	}
+}
+async function writeEnvFile$2(projectDir, config) {
+	const envPath = path.join(projectDir, "apps/server", ".env");
+	const variables = [{
+		key: "DATABASE_URL",
+		value: config?.connectionString ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
+		condition: true
+	}];
+	await addEnvVariablesToFile(envPath, variables);
+	return true;
+}
+async function setupWithNeonDb(projectDir, packageManager) {
+	try {
+		const s = spinner();
+		s.start("Creating Neon database using neondb...");
+		const serverDir = path.join(projectDir, "apps/server");
+		await fs.ensureDir(serverDir);
+		const packageCmd = getPackageExecutionCommand(packageManager, "neondb --yes");
+		await execa(packageCmd, {
+			shell: true,
+			cwd: serverDir
+		});
+		s.stop(pc.green("Neon database created successfully!"));
+		return true;
+	} catch (error) {
+		consola$1.error(pc.red("Failed to create database with neondb"));
+		throw error;
+	}
+}
+function displayManualSetupInstructions$2() {
+	log.info(`Manual Neon PostgreSQL Setup Instructions:
+
+1. Visit https://neon.tech and create an account
+2. Create a new project from the dashboard
+3. Get your connection string
+4. Add the database URL to the .env file in apps/server/.env
+
+DATABASE_URL="your_connection_string"`);
+}
+async function setupNeonPostgres(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		const setupMethod = await select({
+			message: "Choose your Neon setup method:",
+			options: [{
+				label: "Quick setup with neondb",
+				value: "neondb",
+				hint: "fastest, no auth required"
+			}, {
+				label: "Custom setup with neonctl",
+				value: "neonctl",
+				hint: "More control - choose project name and region"
+			}],
+			initialValue: "neondb"
+		});
+		if (isCancel(setupMethod)) {
+			cancel(pc.red("Operation cancelled"));
+			process.exit(0);
+		}
+		if (setupMethod === "neondb") await setupWithNeonDb(projectDir, packageManager);
+		else {
+			const suggestedProjectName = path.basename(projectDir);
+			const projectName = await text({
+				message: "Enter a name for your Neon project:",
+				defaultValue: suggestedProjectName,
+				initialValue: suggestedProjectName
+			});
+			const regionId = await select({
+				message: "Select a region for your Neon project:",
+				options: NEON_REGIONS,
+				initialValue: NEON_REGIONS[0].value
+			});
+			if (isCancel(projectName) || isCancel(regionId)) {
+				cancel(pc.red("Operation cancelled"));
+				process.exit(0);
+			}
+			const neonConfig = await createNeonProject(projectName, regionId, packageManager);
+			if (!neonConfig) throw new Error("Failed to create project - couldn't get connection information");
+			const finalSpinner = spinner();
+			finalSpinner.start("Configuring database connection");
+			await fs.ensureDir(path.join(projectDir, "apps/server"));
+			await writeEnvFile$2(projectDir, neonConfig);
+			finalSpinner.stop("Neon database configured!");
+		}
+	} catch (error) {
+		if (error instanceof Error) consola$1.error(pc.red(error.message));
+		await writeEnvFile$2(projectDir);
+		displayManualSetupInstructions$2();
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/prisma-postgres-setup.ts
+async function initPrismaDatabase(serverDir, packageManager) {
+	const s = spinner();
+	try {
+		s.start("Initializing Prisma PostgreSQL...");
+		const prismaDir = path.join(serverDir, "prisma");
+		await fs.ensureDir(prismaDir);
+		s.stop("Prisma PostgreSQL initialized. Follow the prompts below:");
+		const prismaInitCommand = getPackageExecutionCommand(packageManager, "prisma init --db");
+		await execa(prismaInitCommand, {
+			cwd: serverDir,
+			stdio: "inherit",
+			shell: true
+		});
+		log.info(pc.yellow("Please copy the Prisma Postgres URL from the output above.\nIt looks like: prisma+postgres://accelerate.prisma-data.net/?api_key=..."));
+		const databaseUrl = await password({
+			message: "Paste your Prisma Postgres database URL:",
+			validate(value) {
+				if (!value) return "Please enter a database URL";
+				if (!value.startsWith("prisma+postgres://")) return "URL should start with prisma+postgres://";
+			}
+		});
+		if (isCancel(databaseUrl)) {
+			cancel("Database setup cancelled");
+			return null;
+		}
+		return { databaseUrl };
+	} catch (error) {
+		s.stop(pc.red("Prisma PostgreSQL initialization failed"));
+		if (error instanceof Error) consola$1.error(error.message);
+		return null;
+	}
+}
+async function writeEnvFile$1(projectDir, config) {
+	try {
+		const envPath = path.join(projectDir, "apps/server", ".env");
+		const variables = [{
+			key: "DATABASE_URL",
+			value: config?.databaseUrl ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
+			condition: true
+		}];
+		await addEnvVariablesToFile(envPath, variables);
+	} catch (_error) {
+		consola$1.error("Failed to update environment configuration");
+	}
+}
+function displayManualSetupInstructions$1() {
+	log.info(`Manual Prisma PostgreSQL Setup Instructions:
+
+1. Visit https://console.prisma.io and create an account
+2. Create a new PostgreSQL database from the dashboard
+3. Get your database URL
+4. Add the database URL to the .env file in apps/server/.env
+
+DATABASE_URL="your_database_url"`);
+}
+async function addPrismaAccelerateExtension(serverDir) {
+	try {
+		await addPackageDependency({
+			dependencies: ["@prisma/extension-accelerate"],
+			projectDir: serverDir
+		});
+		const prismaIndexPath = path.join(serverDir, "prisma/index.ts");
+		const prismaIndexContent = `
+import { PrismaClient } from "./generated/client";
+import { withAccelerate } from "@prisma/extension-accelerate";
+
+const prisma = new PrismaClient().$extends(withAccelerate());
+
+export default prisma;
+`;
+		await fs.writeFile(prismaIndexPath, prismaIndexContent.trim());
+		const dbFilePath = path.join(serverDir, "src/db/index.ts");
+		if (await fs.pathExists(dbFilePath)) {
+			let dbFileContent = await fs.readFile(dbFilePath, "utf8");
+			if (!dbFileContent.includes("@prisma/extension-accelerate")) {
+				dbFileContent = `import { withAccelerate } from "@prisma/extension-accelerate";\n${dbFileContent}`;
+				dbFileContent = dbFileContent.replace("export const db = new PrismaClient();", "export const db = new PrismaClient().$extends(withAccelerate());");
+				await fs.writeFile(dbFilePath, dbFileContent);
+			}
+		}
+		return true;
+	} catch (_error) {
+		log.warn(pc.yellow("Could not add Prisma Accelerate extension automatically"));
+		return false;
+	}
+}
+async function setupPrismaPostgres(config) {
+	const { packageManager, projectDir } = config;
+	const serverDir = path.join(projectDir, "apps/server");
+	const s = spinner();
+	s.start("Setting up Prisma PostgreSQL...");
+	try {
+		await fs.ensureDir(serverDir);
+		s.stop("Prisma PostgreSQL setup ready");
+		const config$1 = await initPrismaDatabase(serverDir, packageManager);
+		if (config$1) {
+			await writeEnvFile$1(projectDir, config$1);
+			await addPrismaAccelerateExtension(serverDir);
+			log.success(pc.green("Prisma PostgreSQL database configured successfully!"));
+			log.info(pc.cyan("NOTE: Make sure to uncomment `import \"dotenv/config\";` in `apps/server/src/prisma.config.ts` to load environment variables."));
+		} else {
+			const fallbackSpinner = spinner();
+			fallbackSpinner.start("Setting up fallback configuration...");
+			await writeEnvFile$1(projectDir);
+			fallbackSpinner.stop("Fallback configuration ready");
+			displayManualSetupInstructions$1();
+		}
+	} catch (error) {
+		s.stop(pc.red("Prisma PostgreSQL setup failed"));
+		consola$1.error(pc.red(`Error during Prisma PostgreSQL setup: ${error instanceof Error ? error.message : String(error)}`));
+		try {
+			await writeEnvFile$1(projectDir);
+			displayManualSetupInstructions$1();
+		} catch {}
+		log.info("Setup completed with manual configuration required.");
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/supabase-setup.ts
+async function writeSupabaseEnvFile(projectDir, databaseUrl) {
+	try {
+		const envPath = path.join(projectDir, "apps/server", ".env");
+		const dbUrlToUse = databaseUrl || "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+		const variables = [{
+			key: "DATABASE_URL",
+			value: dbUrlToUse,
+			condition: true
+		}, {
+			key: "DIRECT_URL",
+			value: dbUrlToUse,
+			condition: true
+		}];
+		await addEnvVariablesToFile(envPath, variables);
+		return true;
+	} catch (error) {
+		consola$1.error(pc.red("Failed to update .env file for Supabase."));
+		if (error instanceof Error) consola$1.error(error.message);
+		return false;
+	}
+}
+function extractDbUrl(output) {
+	const dbUrlMatch = output.match(/DB URL:\s*(postgresql:\/\/[^\s]+)/);
+	const url = dbUrlMatch?.[1];
+	if (url) return url;
+	return null;
+}
+async function initializeSupabase(serverDir, packageManager) {
+	log.info("Initializing Supabase project...");
+	try {
+		const supabaseInitCommand = getPackageExecutionCommand(packageManager, "supabase init");
+		await execa(supabaseInitCommand, {
+			cwd: serverDir,
+			stdio: "inherit",
+			shell: true
+		});
+		log.success("Supabase project initialized");
+		return true;
+	} catch (error) {
+		consola$1.error(pc.red("Failed to initialize Supabase project."));
+		if (error instanceof Error) consola$1.error(error.message);
+		else consola$1.error(String(error));
+		if (error instanceof Error && error.message.includes("ENOENT")) {
+			log.error(pc.red("Supabase CLI not found. Please install it globally or ensure it's in your PATH."));
+			log.info("You can install it using: npm install -g supabase");
+		}
+		return false;
+	}
+}
+async function startSupabase(serverDir, packageManager) {
+	log.info("Starting Supabase services (this may take a moment)...");
+	const supabaseStartCommand = getPackageExecutionCommand(packageManager, "supabase start");
+	try {
+		const subprocess = execa(supabaseStartCommand, {
+			cwd: serverDir,
+			shell: true
+		});
+		let stdoutData = "";
+		if (subprocess.stdout) subprocess.stdout.on("data", (data) => {
+			const text$1 = data.toString();
+			process.stdout.write(text$1);
+			stdoutData += text$1;
+		});
+		if (subprocess.stderr) subprocess.stderr.pipe(process.stderr);
+		await subprocess;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+		return stdoutData;
+	} catch (error) {
+		consola$1.error(pc.red("Failed to start Supabase services."));
+		const execaError = error;
+		if (execaError?.message) {
+			consola$1.error(`Error details: ${execaError.message}`);
+			if (execaError.message.includes("Docker is not running")) log.error(pc.red("Docker is not running. Please start Docker and try again."));
+		} else consola$1.error(String(error));
+		return null;
+	}
+}
+function displayManualSupabaseInstructions(output) {
+	log.info(`"Manual Supabase Setup Instructions:"
+1. Ensure Docker is installed and running.
+2. Install the Supabase CLI (e.g., \`npm install -g supabase\`).
+3. Run \`supabase init\` in your project's \`apps/server\` directory.
+4. Run \`supabase start\` in your project's \`apps/server\` directory.
+5. Copy the 'DB URL' from the output.${output ? `
+${pc.bold("Relevant output from `supabase start`:")}
+${pc.dim(output)}` : ""}
+6. Add the DB URL to the .env file in \`apps/server/.env\` as \`DATABASE_URL\`:
+			${pc.gray("DATABASE_URL=\"your_supabase_db_url\"")}`);
+}
+async function setupSupabase(config) {
+	const { projectDir, packageManager } = config;
+	const serverDir = path.join(projectDir, "apps", "server");
+	try {
+		await fs.ensureDir(serverDir);
+		const initialized = await initializeSupabase(serverDir, packageManager);
+		if (!initialized) {
+			displayManualSupabaseInstructions();
+			return;
+		}
+		const supabaseOutput = await startSupabase(serverDir, packageManager);
+		if (!supabaseOutput) {
+			displayManualSupabaseInstructions();
+			return;
+		}
+		const dbUrl = extractDbUrl(supabaseOutput);
+		if (dbUrl) {
+			const envUpdated = await writeSupabaseEnvFile(projectDir, dbUrl);
+			if (envUpdated) log.success(pc.green("Supabase local development setup ready!"));
+			else {
+				log.error(pc.red("Supabase setup completed, but failed to update .env automatically."));
+				displayManualSupabaseInstructions(supabaseOutput);
+			}
+		} else {
+			log.error(pc.yellow("Supabase started, but could not extract DB URL automatically."));
+			displayManualSupabaseInstructions(supabaseOutput);
+		}
+	} catch (error) {
+		if (error instanceof Error) consola$1.error(pc.red(`Error during Supabase setup: ${error.message}`));
+		else consola$1.error(pc.red(`An unknown error occurred during Supabase setup: ${String(error)}`));
+		displayManualSupabaseInstructions();
+	}
+}
+
+//#endregion
+//#region src/helpers/database-providers/turso-setup.ts
+async function isTursoInstalled() {
+	return commandExists("turso");
+}
+async function isTursoLoggedIn() {
+	try {
+		const output = await $`turso auth whoami`;
+		return !output.stdout.includes("You are not logged in");
+	} catch {
+		return false;
+	}
+}
+async function loginToTurso() {
+	const s = spinner();
+	try {
+		s.start("Logging in to Turso...");
+		await $`turso auth login`;
+		s.stop("Logged into Turso");
+		return true;
+	} catch (_error) {
+		s.stop(pc.red("Failed to log in to Turso"));
+	}
+}
+async function installTursoCLI(isMac) {
+	const s = spinner();
+	try {
+		s.start("Installing Turso CLI...");
+		if (isMac) await $`brew install tursodatabase/tap/turso`;
+		else {
+			const { stdout: installScript } = await $`curl -sSfL https://get.tur.so/install.sh`;
+			await $`bash -c '${installScript}'`;
+		}
+		s.stop("Turso CLI installed");
+		return true;
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("User force closed")) {
+			s.stop("Turso CLI installation cancelled");
+			log.warn(pc.yellow("Turso CLI installation cancelled by user"));
+			throw new Error("Installation cancelled");
+		}
+		s.stop(pc.red("Failed to install Turso CLI"));
+	}
+}
+async function getTursoGroups() {
+	const s = spinner();
+	try {
+		s.start("Fetching Turso groups...");
+		const { stdout } = await $`turso group list`;
+		const lines = stdout.trim().split("\n");
+		if (lines.length <= 1) {
+			s.stop("No Turso groups found");
+			return [];
+		}
+		const groups = lines.slice(1).map((line) => {
+			const [name, locations, version, status] = line.trim().split(/\s{2,}/);
+			return {
+				name,
+				locations,
+				version,
+				status
+			};
+		});
+		s.stop(`Found ${groups.length} Turso groups`);
+		return groups;
+	} catch (error) {
+		s.stop(pc.red("Error fetching Turso groups"));
+		console.error("Error fetching Turso groups:", error);
+		return [];
+	}
+}
+async function selectTursoGroup() {
+	const groups = await getTursoGroups();
+	if (groups.length === 0) return null;
+	if (groups.length === 1) {
+		log.info(`Using the only available group: ${pc.blue(groups[0].name)}`);
+		return groups[0].name;
+	}
+	const groupOptions = groups.map((group$1) => ({
+		value: group$1.name,
+		label: `${group$1.name} (${group$1.locations})`
+	}));
+	const selectedGroup = await select({
+		message: "Select a Turso database group:",
+		options: groupOptions
+	});
+	if (isCancel(selectedGroup)) {
+		cancel(pc.red("Operation cancelled"));
+		process.exit(0);
+	}
+	return selectedGroup;
+}
+async function createTursoDatabase(dbName, groupName) {
+	const s = spinner();
+	try {
+		s.start(`Creating Turso database "${dbName}"${groupName ? ` in group "${groupName}"` : ""}...`);
+		if (groupName) await $`turso db create ${dbName} --group ${groupName}`;
+		else await $`turso db create ${dbName}`;
+		s.stop(`Turso database "${dbName}" created`);
+	} catch (error) {
+		s.stop(pc.red(`Failed to create database "${dbName}"`));
+		if (error instanceof Error && error.message.includes("already exists")) throw new Error("DATABASE_EXISTS");
+	}
+	s.start("Retrieving database connection details...");
+	try {
+		const { stdout: dbUrl } = await $`turso db show ${dbName} --url`;
+		const { stdout: authToken } = await $`turso db tokens create ${dbName}`;
+		s.stop("Database connection details retrieved");
+		return {
+			dbUrl: dbUrl.trim(),
+			authToken: authToken.trim()
+		};
+	} catch (_error) {
+		s.stop(pc.red("Failed to retrieve database connection details"));
+	}
+}
+async function writeEnvFile(projectDir, config) {
+	const envPath = path.join(projectDir, "apps/server", ".env");
+	const variables = [{
+		key: "DATABASE_URL",
+		value: config?.dbUrl ?? "",
+		condition: true
+	}, {
+		key: "DATABASE_AUTH_TOKEN",
+		value: config?.authToken ?? "",
+		condition: true
+	}];
+	await addEnvVariablesToFile(envPath, variables);
+}
+function displayManualSetupInstructions() {
+	log.info(`Manual Turso Setup Instructions:
+
+1. Visit https://turso.tech and create an account
+2. Create a new database from the dashboard
+3. Get your database URL and authentication token
+4. Add these credentials to the .env file in apps/server/.env
+
+DATABASE_URL=your_database_url
+DATABASE_AUTH_TOKEN=your_auth_token`);
+}
+async function setupTurso(config) {
+	const { orm, projectDir } = config;
+	const _isDrizzle = orm === "drizzle";
+	const setupSpinner = spinner();
+	setupSpinner.start("Checking Turso CLI availability...");
+	try {
+		const platform = os.platform();
+		const isMac = platform === "darwin";
+		const _isLinux = platform === "linux";
+		const isWindows = platform === "win32";
+		if (isWindows) {
+			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);
+			displayManualSetupInstructions();
+			return;
+		}
+		setupSpinner.stop("Turso CLI availability checked");
+		const isCliInstalled = await isTursoInstalled();
+		if (!isCliInstalled) {
+			const shouldInstall = await confirm({
+				message: "Would you like to install Turso CLI?",
+				initialValue: true
+			});
+			if (isCancel(shouldInstall)) {
+				cancel(pc.red("Operation cancelled"));
+				process.exit(0);
+			}
+			if (!shouldInstall) {
+				await writeEnvFile(projectDir);
+				displayManualSetupInstructions();
+				return;
+			}
+			await installTursoCLI(isMac);
+		}
+		const isLoggedIn = await isTursoLoggedIn();
+		if (!isLoggedIn) await loginToTurso();
+		const selectedGroup = await selectTursoGroup();
+		let success = false;
+		let dbName = "";
+		let suggestedName = path.basename(projectDir);
+		while (!success) {
+			const dbNameResponse = await text({
+				message: "Enter a name for your database:",
+				defaultValue: suggestedName,
+				initialValue: suggestedName,
+				placeholder: suggestedName
+			});
+			if (isCancel(dbNameResponse)) {
+				cancel(pc.red("Operation cancelled"));
+				process.exit(0);
+			}
+			dbName = dbNameResponse;
+			try {
+				const config$1 = await createTursoDatabase(dbName, selectedGroup);
+				await writeEnvFile(projectDir, config$1);
+				success = true;
+			} catch (error) {
+				if (error instanceof Error && error.message === "DATABASE_EXISTS") {
+					log.warn(pc.yellow(`Database "${pc.red(dbName)}" already exists`));
+					suggestedName = `${dbName}-${Math.floor(Math.random() * 1e3)}`;
+				} else throw error;
+			}
+		}
+		log.success("Turso database setup completed successfully!");
+	} catch (error) {
+		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);
+		displayManualSetupInstructions();
+		log.success("Setup completed with manual configuration required.");
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/db-setup.ts
+async function setupDatabase(config) {
+	const { database, orm, dbSetup, backend, projectDir } = config;
+	if (backend === "convex" || database === "none") {
+		if (backend !== "convex") {
+			const serverDir$1 = path.join(projectDir, "apps/server");
+			const serverDbDir = path.join(serverDir$1, "src/db");
+			if (await fs.pathExists(serverDbDir)) await fs.remove(serverDbDir);
+		}
+		return;
+	}
+	const s = spinner();
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	try {
+		if (orm === "prisma") await addPackageDependency({
+			dependencies: ["@prisma/client"],
+			devDependencies: ["prisma"],
+			projectDir: serverDir
+		});
+		else if (orm === "drizzle") {
+			if (database === "sqlite") await addPackageDependency({
+				dependencies: ["drizzle-orm", "@libsql/client"],
+				devDependencies: ["drizzle-kit"],
+				projectDir: serverDir
+			});
+			else if (database === "postgres") await addPackageDependency({
+				dependencies: ["drizzle-orm", "pg"],
+				devDependencies: ["drizzle-kit", "@types/pg"],
+				projectDir: serverDir
+			});
+			else if (database === "mysql") await addPackageDependency({
+				dependencies: ["drizzle-orm", "mysql2"],
+				devDependencies: ["drizzle-kit"],
+				projectDir: serverDir
+			});
+		} else if (orm === "mongoose") await addPackageDependency({
+			dependencies: ["mongoose"],
+			devDependencies: [],
+			projectDir: serverDir
+		});
+		if (database === "sqlite" && dbSetup === "turso") await setupTurso(config);
+		else if (database === "sqlite" && dbSetup === "d1") await setupCloudflareD1(config);
+		else if (database === "postgres") {
+			if (orm === "prisma" && dbSetup === "prisma-postgres") await setupPrismaPostgres(config);
+			else if (dbSetup === "neon") await setupNeonPostgres(config);
+			else if (dbSetup === "supabase") await setupSupabase(config);
+		} else if (database === "mongodb" && dbSetup === "mongodb-atlas") await setupMongoDBAtlas(config);
+	} catch (error) {
+		s.stop(pc.red("Failed to set up database"));
+		if (error instanceof Error) consola.error(pc.red(error.message));
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/examples-setup.ts
+async function setupExamples(config) {
+	const { examples, frontend, backend, projectDir } = config;
+	if (backend === "convex" || !examples || examples.length === 0 || examples[0] === "none") return;
+	if (examples.includes("ai")) {
+		const clientDir = path.join(projectDir, "apps/web");
+		const serverDir = path.join(projectDir, "apps/server");
+		const clientDirExists = await fs.pathExists(clientDir);
+		const serverDirExists = await fs.pathExists(serverDir);
+		const hasNuxt = frontend.includes("nuxt");
+		const hasSvelte = frontend.includes("svelte");
+		const hasReact = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next") || frontend.includes("tanstack-start") || frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+		if (clientDirExists) {
+			const dependencies = ["ai"];
+			if (hasNuxt) dependencies.push("@ai-sdk/vue");
+			else if (hasSvelte) dependencies.push("@ai-sdk/svelte");
+			else if (hasReact) dependencies.push("@ai-sdk/react");
+			await addPackageDependency({
+				dependencies,
+				projectDir: clientDir
+			});
+		}
+		if (serverDirExists && backend !== "none") await addPackageDependency({
+			dependencies: ["ai", "@ai-sdk/google"],
+			projectDir: serverDir
+		});
+	}
+}
+
+//#endregion
+//#region src/helpers/setup/runtime-setup.ts
+async function setupRuntime(config) {
+	const { runtime, backend, projectDir } = config;
+	if (backend === "convex" || backend === "next" || runtime === "none") return;
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	if (runtime === "bun") await setupBunRuntime(serverDir, backend);
+	else if (runtime === "node") await setupNodeRuntime(serverDir, backend);
+	else if (runtime === "workers") await setupWorkersRuntime(serverDir);
+}
+async function generateCloudflareWorkerTypes(config) {
+	if (config.runtime !== "workers") return;
+	const serverDir = path.join(config.projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	const s = spinner();
+	try {
+		s.start("Generating Cloudflare Workers types...");
+		const runCmd = config.packageManager === "npm" ? "npm" : config.packageManager;
+		await execa(runCmd, ["run", "cf-typegen"], { cwd: serverDir });
+		s.stop("Cloudflare Workers types generated successfully!");
+	} catch {
+		s.stop(pc.yellow("Failed to generate Cloudflare Workers types"));
+		const managerCmd = config.packageManager === "npm" ? "npm run" : `${config.packageManager} run`;
+		console.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
+	}
+}
+async function setupBunRuntime(serverDir, _backend) {
+	const packageJsonPath = path.join(serverDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts = {
+		...packageJson.scripts,
+		dev: "bun run --hot src/index.ts",
+		start: "bun run dist/src/index.js"
+	};
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	await addPackageDependency({
+		devDependencies: ["@types/bun"],
+		projectDir: serverDir
+	});
+}
+async function setupNodeRuntime(serverDir, backend) {
+	const packageJsonPath = path.join(serverDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts = {
+		...packageJson.scripts,
+		dev: "tsx watch src/index.ts",
+		start: "node dist/src/index.js"
+	};
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	await addPackageDependency({
+		devDependencies: ["tsx", "@types/node"],
+		projectDir: serverDir
+	});
+	if (backend === "hono") await addPackageDependency({
+		dependencies: ["@hono/node-server"],
+		projectDir: serverDir
+	});
+	else if (backend === "elysia") await addPackageDependency({
+		dependencies: ["@elysiajs/node"],
+		projectDir: serverDir
+	});
+}
+async function setupWorkersRuntime(serverDir) {
+	const packageJsonPath = path.join(serverDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts = {
+		...packageJson.scripts,
+		dev: "wrangler dev --port=3000",
+		start: "wrangler dev",
+		deploy: "wrangler deploy",
+		build: "wrangler deploy --dry-run",
+		"cf-typegen": "wrangler types --env-interface CloudflareBindings"
+	};
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	await addPackageDependency({
+		devDependencies: ["wrangler"],
+		projectDir: serverDir
+	});
+}
+
+//#endregion
+//#region src/helpers/project-generation/create-readme.ts
+async function createReadme(projectDir, options) {
+	const readmePath = path.join(projectDir, "README.md");
+	const content = generateReadmeContent(options);
+	try {
+		await fs.writeFile(readmePath, content);
+	} catch (error) {
+		consola.error("Failed to create README.md file:", error);
+	}
+}
+function generateReadmeContent(options) {
+	const { projectName, packageManager, database, auth, addons = [], orm = "drizzle", runtime = "bun", frontend = ["tanstack-router"], backend = "hono", api = "trpc" } = options;
+	const isConvex = backend === "convex";
+	const hasReactRouter = frontend.includes("react-router");
+	const hasTanstackRouter = frontend.includes("tanstack-router");
+	const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+	const hasNext = frontend.includes("next");
+	const hasTanstackStart = frontend.includes("tanstack-start");
+	const hasSvelte = frontend.includes("svelte");
+	const hasSolid = frontend.includes("solid");
+	const hasNuxt = frontend.includes("nuxt");
+	const packageManagerRunCmd = packageManager === "npm" ? "npm run" : packageManager;
+	let webPort = "3001";
+	if (hasReactRouter || hasSvelte) webPort = "5173";
+	return `# ${projectName}
+
+This project was created with [tvi](https://github.com//shaneholloman/tvi), a modern TypeScript stack that combines ${hasTanstackRouter ? "React, TanStack Router" : hasReactRouter ? "React, React Router" : hasNext ? "Next.js" : hasTanstackStart ? "React, TanStack Start" : hasSvelte ? "SvelteKit" : hasNuxt ? "Nuxt" : hasSolid ? "SolidJS" : ""}, ${backend[0].toUpperCase() + backend.slice(1)}${isConvex ? "" : `, ${api.toUpperCase()}`}, and more.
+
+## Features
+
+${generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api)}
+
+## Getting Started
+
+First, install the dependencies:
+
+\`\`\`bash
+${packageManager} install
+\`\`\`
+${isConvex ? `
+## Convex Setup
+
+This project uses Convex as a backend. You'll need to set up Convex before running the app:
+
+\`\`\`bash
+${packageManagerRunCmd} dev:setup
+\`\`\`
+
+Follow the prompts to create a new Convex project and connect it to your application.` : generateDatabaseSetup(database, auth, packageManagerRunCmd, orm)}
+
+Then, run the development server:
+
+\`\`\`bash
+${packageManagerRunCmd} dev
+\`\`\`
+
+${hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid ? `Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see the web application.` : ""}
+${hasNative ? "Use the Expo Go app to run the mobile application.\n" : ""}
+${isConvex ? "Your app will connect to the Convex cloud backend automatically." : "The API is running at [http://localhost:3000](http://localhost:3000)."}
+
+${addons.includes("pwa") && hasReactRouter ? "\n## PWA Support with React Router v7\n\nThere is a known compatibility issue between VitePWA and React Router v7.\nSee: https://github.com/vite-pwa/vite-plugin-pwa/issues/809\n" : ""}
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+├── apps/
+${hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid ? `│   ├── web/         # Frontend application (${hasTanstackRouter ? "React + TanStack Router" : hasReactRouter ? "React + React Router" : hasNext ? "Next.js" : hasTanstackStart ? "React + TanStack Start" : hasSvelte ? "SvelteKit" : hasNuxt ? "Nuxt" : hasSolid ? "SolidJS" : ""})\n` : ""}${hasNative ? "│   ├── native/      # Mobile application (React Native, Expo)\n" : ""}${addons.includes("starlight") ? "│   ├── docs/        # Documentation site (Astro Starlight)\n" : ""}${isConvex ? "├── packages/\n│   └── backend/     # Convex backend functions and schema\n" : `│   └── server/      # Backend API (${backend[0].toUpperCase() + backend.slice(1)}, ${api.toUpperCase()})`}
+\`\`\`
+
+## Available Scripts
+
+${generateScriptsList(packageManagerRunCmd, database, orm, auth, hasNative, addons, backend)}
+`;
+}
+function generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api) {
+	const isConvex = backend === "convex";
+	const hasTanstackRouter = frontend.includes("tanstack-router");
+	const hasReactRouter = frontend.includes("react-router");
+	const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+	const hasNext = frontend.includes("next");
+	const hasTanstackStart = frontend.includes("tanstack-start");
+	const hasSvelte = frontend.includes("svelte");
+	const hasNuxt = frontend.includes("nuxt");
+	const hasSolid = frontend.includes("solid");
+	const addonsList = ["- **TypeScript** - For type safety and improved developer experience"];
+	if (hasTanstackRouter) addonsList.push("- **TanStack Router** - File-based routing with full type safety");
+	else if (hasReactRouter) addonsList.push("- **React Router** - Declarative routing for React");
+	else if (hasNext) addonsList.push("- **Next.js** - Full-stack React framework");
+	else if (hasTanstackStart) addonsList.push("- **TanStack Start** - SSR framework with TanStack Router");
+	else if (hasSvelte) addonsList.push("- **SvelteKit** - Web framework for building Svelte apps");
+	else if (hasNuxt) addonsList.push("- **Nuxt** - The Intuitive Vue Framework");
+	else if (hasSolid) addonsList.push("- **SolidJS** - Simple and performant reactivity");
+	if (hasNative) {
+		addonsList.push("- **React Native** - Build mobile apps using React");
+		addonsList.push("- **Expo** - Tools for React Native development");
+	}
+	addonsList.push("- **TailwindCSS** - Utility-first CSS for rapid UI development", "- **shadcn/ui** - Reusable UI components");
+	if (isConvex) addonsList.push("- **Convex** - Reactive backend-as-a-service platform");
+	else {
+		if (backend === "hono") addonsList.push("- **Hono** - Lightweight, performant server framework");
+		else if (backend === "express") addonsList.push("- **Express** - Fast, unopinionated web framework");
+		else if (backend === "fastify") addonsList.push("- **Fastify** - Fast, low-overhead web framework");
+		else if (backend === "elysia") addonsList.push("- **Elysia** - Type-safe, high-performance framework");
+		else if (backend === "next") addonsList.push("- **Next.js** - Full-stack React framework");
+		if (api === "trpc") addonsList.push("- **tRPC** - End-to-end type-safe APIs");
+		else if (api === "orpc") addonsList.push("- **oRPC** - End-to-end type-safe APIs with OpenAPI integration");
+		addonsList.push(`- **${runtime === "bun" ? "Bun" : "Node.js"}** - Runtime environment`);
+	}
+	if (database !== "none" && !isConvex) addonsList.push(`- **${orm === "drizzle" ? "Drizzle" : orm === "prisma" ? "Prisma" : "Mongoose"}** - TypeScript-first ORM`, `- **${database === "sqlite" ? "SQLite/Turso" : database === "postgres" ? "PostgreSQL" : database === "mysql" ? "MySQL" : "MongoDB"}** - Database engine`);
+	if (auth && !isConvex) addonsList.push("- **Authentication** - Email & password authentication with Better Auth");
+	for (const addon of addons) if (addon === "pwa") addonsList.push("- **PWA** - Progressive Web App support");
+	else if (addon === "tauri") addonsList.push("- **Tauri** - Build native desktop applications");
+	else if (addon === "biome") addonsList.push("- **Biome** - Linting and formatting");
+	else if (addon === "husky") addonsList.push("- **Husky** - Git hooks for code quality");
+	else if (addon === "starlight") addonsList.push("- **Starlight** - Documentation site with Astro");
+	else if (addon === "turborepo") addonsList.push("- **Turborepo** - Optimized monorepo build system");
+	return addonsList.join("\n");
+}
+function generateDatabaseSetup(database, auth, packageManagerRunCmd, orm) {
+	if (database === "none") return "";
+	let setup = "## Database Setup\n\n";
+	if (database === "sqlite") setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+
+1. Start the local SQLite database:
+\`\`\`bash
+cd apps/server && ${packageManagerRunCmd} db:local
+\`\`\`
+
+2. Update your \`.env\` file in the \`apps/server\` directory with the appropriate connection details if needed.
+`;
+	else if (database === "postgres") setup += `This project uses PostgreSQL${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+
+1. Make sure you have a PostgreSQL database set up.
+2. Update your \`apps/server/.env\` file with your PostgreSQL connection details.
+`;
+	else if (database === "mysql") setup += `This project uses MySQL${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+
+1. Make sure you have a MySQL database set up.
+2. Update your \`apps/server/.env\` file with your MySQL connection details.
+`;
+	else if (database === "mongodb") setup += `This project uses MongoDB ${orm === "mongoose" ? "with Mongoose" : "with Prisma ORM"}.
+
+1. Make sure you have MongoDB set up.
+2. Update your \`apps/server/.env\` file with your MongoDB connection URI.
+`;
+	setup += `
+${auth ? "3" : "3"}. ${orm === "prisma" ? `Generate the Prisma client and push the schema:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\`` : orm === "drizzle" ? `Apply the schema to your database:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\`` : `Apply the schema to your database:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\``}
+`;
+	return setup;
+}
+function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNative, addons, backend) {
+	const isConvex = backend === "convex";
+	let scripts = `- \`${packageManagerRunCmd} dev\`: Start all applications in development mode
+- \`${packageManagerRunCmd} build\`: Build all applications
+- \`${packageManagerRunCmd} dev:web\`: Start only the web application`;
+	if (isConvex) scripts += `
+- \`${packageManagerRunCmd} dev:setup\`: Setup and configure your Convex project`;
+	else scripts += `
+- \`${packageManagerRunCmd} dev:server\`: Start only the server`;
+	scripts += `
+- \`${packageManagerRunCmd} check-types\`: Check TypeScript types across all apps`;
+	if (hasNative) scripts += `
+- \`${packageManagerRunCmd} dev:native\`: Start the React Native/Expo development server`;
+	if (database !== "none" && !isConvex) {
+		scripts += `
+- \`${packageManagerRunCmd} db:push\`: Push schema changes to database
+- \`${packageManagerRunCmd} db:studio\`: Open database studio UI`;
+		if (database === "sqlite" && orm === "drizzle") scripts += `
+- \`cd apps/server && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
+	}
+	if (addons.includes("biome")) scripts += `
+- \`${packageManagerRunCmd} check\`: Run Biome formatting and linting`;
+	if (addons.includes("pwa")) scripts += `
+- \`cd apps/web && ${packageManagerRunCmd} generate-pwa-assets\`: Generate PWA assets`;
+	if (addons.includes("tauri")) scripts += `
+- \`cd apps/web && ${packageManagerRunCmd} desktop:dev\`: Start Tauri desktop app in development
+- \`cd apps/web && ${packageManagerRunCmd} desktop:build\`: Build Tauri desktop app`;
+	if (addons.includes("starlight")) scripts += `
+- \`cd apps/docs && ${packageManagerRunCmd} dev\`: Start documentation site
+- \`cd apps/docs && ${packageManagerRunCmd} build\`: Build documentation site`;
+	return scripts;
+}
+
+//#endregion
+//#region src/helpers/project-generation/post-installation.ts
+function displayPostInstallInstructions(config) {
+	const { database, relativePath, packageManager, depsInstalled, orm, addons, runtime, frontend, backend, dbSetup } = config;
+	const isConvex = backend === "convex";
+	const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+	const cdCmd = `cd ${relativePath}`;
+	const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
+	const databaseInstructions = !isConvex && database !== "none" ? getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) : "";
+	const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
+	const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
+	const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
+	const pwaInstructions = addons?.includes("pwa") && (frontend?.includes("react-router") || frontend?.includes("tanstack-router")) ? getPwaInstructions() : "";
+	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
+	const hasWeb = frontend?.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"next",
+		"tanstack-start",
+		"nuxt",
+		"svelte",
+		"solid"
+	].includes(f));
+	const hasNative = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles");
+	const bunWebNativeWarning = packageManager === "bun" && hasNative && hasWeb ? getBunWebNativeWarning() : "";
+	const noOrmWarning = !isConvex && database !== "none" && orm === "none" ? getNoOrmWarning() : "";
+	const hasReactRouter = frontend?.includes("react-router");
+	const hasSvelte = frontend?.includes("svelte");
+	const webPort = hasReactRouter || hasSvelte ? "5173" : "3001";
+	const tazeCommand = getPackageExecutionCommand(packageManager, "taze -r");
+	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
+	let stepCounter = 2;
+	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
+	if (isConvex) {
+		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev:setup ${pc.dim("(this will guide you through Convex project setup)")}\n`;
+		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n\n`;
+	} else {
+		if (runtime !== "workers") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
+		if (runtime === "workers") {
+			if (dbSetup === "d1") output += `${pc.yellow("IMPORTANT:")} Complete D1 database setup first (see Database commands below)\n`;
+			output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
+			output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} run cf-typegen\n\n`;
+		} else output += "\n";
+	}
+	output += `${pc.bold("Your project will be available at:")}\n`;
+	if (hasWeb) output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
+	else if (!hasNative && !addons?.includes("starlight")) output += `${pc.yellow("NOTE:")} You are creating a backend-only app (no frontend selected)\n`;
+	if (!isConvex) output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
+	if (addons?.includes("starlight")) output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
+	if (nativeInstructions) output += `\n${nativeInstructions.trim()}\n`;
+	if (databaseInstructions) output += `\n${databaseInstructions.trim()}\n`;
+	if (tauriInstructions) output += `\n${tauriInstructions.trim()}\n`;
+	if (lintingInstructions) output += `\n${lintingInstructions.trim()}\n`;
+	if (pwaInstructions) output += `\n${pwaInstructions.trim()}\n`;
+	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
+	if (noOrmWarning) output += `\n${noOrmWarning.trim()}\n`;
+	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
+	output += `\n${pc.bold("Update all dependencies:\n")}${pc.cyan(tazeCommand)}\n\n`;
+	output += `${pc.bold("Like tvi?")} Please consider giving us a star on GitHub:\n`;
+	output += pc.cyan("https://github.com//shaneholloman/tvi");
+	consola$1.box(output);
+}
+function getNativeInstructions(isConvex) {
+	const envVar = isConvex ? "EXPO_PUBLIC_CONVEX_URL" : "EXPO_PUBLIC_SERVER_URL";
+	const exampleUrl = isConvex ? "https://<YOUR_CONVEX_URL>" : "http://<YOUR_LOCAL_IP>:3000";
+	const envFileName = ".env";
+	const ipNote = isConvex ? "your Convex deployment URL (find after running 'dev:setup')" : "your local IP address";
+	let instructions = `${pc.yellow("NOTE:")} For Expo connectivity issues, update apps/native/${envFileName} \nwith ${ipNote}:\n${`${envVar}=${exampleUrl}`}\n`;
+	if (isConvex) instructions += `\n${pc.yellow("IMPORTANT:")} When using local development with Convex and native apps, ensure you use your local IP address \ninstead of localhost or 127.0.0.1 for proper connectivity.\n`;
+	return instructions;
+}
+function getLintingInstructions(runCmd) {
+	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
+}
+function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
+	const instructions = [];
+	if (runtime === "workers" && dbSetup === "d1") {
+		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
+		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
+		instructions.push(`${pc.cyan("2.")} Create D1 database: ${pc.white(`${packageManager} wrangler d1 create your-database-name`)}`);
+		instructions.push(`${pc.cyan("3.")} Update apps/server/wrangler.jsonc with database_id and database_name`);
+		instructions.push(`${pc.cyan("4.")} Generate migrations: ${pc.white("cd apps/server && bun db:generate")}`);
+		instructions.push(`${pc.cyan("5.")} Apply migrations locally: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME --local`)}`);
+		instructions.push(`${pc.cyan("6.")} Apply migrations to production: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME`)}`);
+		instructions.push("");
+	}
+	if (orm === "prisma") {
+		if (database === "sqlite") instructions.push(`${pc.yellow("NOTE:")} Turso support with Prisma is in Early Access and requires additional setup.`, `Learn more at: https://www.prisma.io/docs/orm/overview/databases/turso`);
+		if (runtime === "bun") instructions.push(`${pc.yellow("NOTE:")} Prisma with Bun may require additional configuration. If you encounter errors,\nfollow the guidance provided in the error messages`);
+		instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+	} else if (orm === "drizzle") {
+		instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+		if (database === "sqlite" && dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Start local DB (if needed): ${`cd apps/server && ${runCmd} db:local`}`);
+	} else if (orm === "none") instructions.push(`${pc.yellow("NOTE:")} Manual database schema setup required.`);
+	return instructions.length ? `${pc.bold("Database commands:")}\n${instructions.join("\n")}` : "";
+}
+function getTauriInstructions(runCmd) {
+	return `\n${pc.bold("Desktop app with Tauri:")}\n${pc.cyan("•")} Start desktop app: ${`cd apps/web && ${runCmd} desktop:dev`}\n${pc.cyan("•")} Build desktop app: ${`cd apps/web && ${runCmd} desktop:build`}\n${pc.yellow("NOTE:")} Tauri requires Rust and platform-specific dependencies.\nSee: https://v2.tauri.app/start/prerequisites/`;
+}
+function getPwaInstructions() {
+	return `\n${pc.bold("PWA with React Router v7:")}\n${pc.yellow("NOTE:")} There is a known compatibility issue between VitePWA and React Router v7.\nSee: https://github.com/vite-pwa/vite-plugin-pwa/issues/809`;
+}
+function getStarlightInstructions(runCmd) {
+	return `\n${pc.bold("Documentation with Starlight:")}\n${pc.cyan("•")} Start docs site: ${`cd apps/docs && ${runCmd} dev`}\n${pc.cyan("•")} Build docs site: ${`cd apps/docs && ${runCmd} build`}`;
+}
+function getNoOrmWarning() {
+	return `\n${pc.yellow("WARNING:")} Database selected without an ORM. Features requiring database access (e.g., examples, auth) need manual setup.`;
+}
+function getBunWebNativeWarning() {
+	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo. Use 'pnpm' if problems arise.`;
+}
+
+//#endregion
+//#region src/helpers/project-generation/project-config.ts
+async function updatePackageConfigurations(projectDir, options) {
+	await updateRootPackageJson(projectDir, options);
+	if (options.backend !== "convex") await updateServerPackageJson(projectDir, options);
+	else await updateConvexPackageJson(projectDir, options);
+}
+async function updateRootPackageJson(projectDir, options) {
+	const rootPackageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(rootPackageJsonPath)) return;
+	const packageJson = await fs.readJson(rootPackageJsonPath);
+	packageJson.name = options.projectName;
+	if (!packageJson.scripts) packageJson.scripts = {};
+	const scripts = packageJson.scripts;
+	const backendPackageName = options.backend === "convex" ? `@${options.projectName}/backend` : "server";
+	let serverDevScript = "";
+	if (options.addons.includes("turborepo")) serverDevScript = `turbo -F ${backendPackageName} dev`;
+	else if (options.packageManager === "bun") serverDevScript = `bun run --filter ${backendPackageName} dev`;
+	else if (options.packageManager === "pnpm") serverDevScript = `pnpm --filter ${backendPackageName} dev`;
+	else if (options.packageManager === "npm") serverDevScript = `npm run dev --workspace ${backendPackageName}`;
+	let devScript = "";
+	if (options.packageManager === "pnpm") devScript = "pnpm -r dev";
+	else if (options.packageManager === "npm") devScript = "npm run dev --workspaces";
+	else if (options.packageManager === "bun") devScript = "bun run --filter '*' dev";
+	const needsDbScripts = options.backend !== "convex" && options.database !== "none" && options.orm !== "none" && options.orm !== "mongoose";
+	if (options.addons.includes("turborepo")) {
+		scripts.dev = "turbo dev";
+		scripts.build = "turbo build";
+		scripts["check-types"] = "turbo check-types";
+		scripts["dev:native"] = "turbo -F native dev";
+		scripts["dev:web"] = "turbo -F web dev";
+		scripts["dev:server"] = serverDevScript;
+		if (options.backend === "convex") scripts["dev:setup"] = `turbo -F ${backendPackageName} setup`;
+		if (needsDbScripts) {
+			scripts["db:push"] = `turbo -F ${backendPackageName} db:push`;
+			scripts["db:studio"] = `turbo -F ${backendPackageName} db:studio`;
+			if (options.orm === "prisma") {
+				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+			} else if (options.orm === "drizzle") {
+				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+			}
+		}
+	} else if (options.packageManager === "pnpm") {
+		scripts.dev = devScript;
+		scripts.build = "pnpm -r build";
+		scripts["check-types"] = "pnpm -r check-types";
+		scripts["dev:native"] = "pnpm --filter native dev";
+		scripts["dev:web"] = "pnpm --filter web dev";
+		scripts["dev:server"] = serverDevScript;
+		if (options.backend === "convex") scripts["dev:setup"] = `pnpm --filter ${backendPackageName} setup`;
+		if (needsDbScripts) {
+			scripts["db:push"] = `pnpm --filter ${backendPackageName} db:push`;
+			scripts["db:studio"] = `pnpm --filter ${backendPackageName} db:studio`;
+			if (options.orm === "prisma") {
+				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+			} else if (options.orm === "drizzle") {
+				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+			}
+		}
+	} else if (options.packageManager === "npm") {
+		scripts.dev = devScript;
+		scripts.build = "npm run build --workspaces";
+		scripts["check-types"] = "npm run check-types --workspaces";
+		scripts["dev:native"] = "npm run dev --workspace native";
+		scripts["dev:web"] = "npm run dev --workspace web";
+		scripts["dev:server"] = serverDevScript;
+		if (options.backend === "convex") scripts["dev:setup"] = `npm run setup --workspace ${backendPackageName}`;
+		if (needsDbScripts) {
+			scripts["db:push"] = `npm run db:push --workspace ${backendPackageName}`;
+			scripts["db:studio"] = `npm run db:studio --workspace ${backendPackageName}`;
+			if (options.orm === "prisma") {
+				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+				scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+			} else if (options.orm === "drizzle") {
+				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
+				scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+			}
+		}
+	} else if (options.packageManager === "bun") {
+		scripts.dev = devScript;
+		scripts.build = "bun run --filter '*' build";
+		scripts["check-types"] = "bun run --filter '*' check-types";
+		scripts["dev:native"] = "bun run --filter native dev";
+		scripts["dev:web"] = "bun run --filter web dev";
+		scripts["dev:server"] = serverDevScript;
+		if (options.backend === "convex") scripts["dev:setup"] = `bun run --filter ${backendPackageName} setup`;
+		if (needsDbScripts) {
+			scripts["db:push"] = `bun run --filter ${backendPackageName} db:push`;
+			scripts["db:studio"] = `bun run --filter ${backendPackageName} db:studio`;
+			if (options.orm === "prisma") {
+				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+			} else if (options.orm === "drizzle") {
+				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
+				scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+			}
+		}
+	}
+	if (options.addons.includes("biome")) scripts.check = "biome check --write .";
+	if (options.addons.includes("husky")) {
+		scripts.prepare = "husky";
+		packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
+	}
+	try {
+		const { stdout } = await execa(options.packageManager, ["-v"], { cwd: projectDir });
+		packageJson.packageManager = `${options.packageManager}@${stdout.trim()}`;
+	} catch (_e) {
+		log.warn(`Could not determine ${options.packageManager} version.`);
+	}
+	if (!packageJson.workspaces) packageJson.workspaces = [];
+	const workspaces = packageJson.workspaces;
+	if (options.backend === "convex") {
+		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
+		const needsAppsDir = options.frontend.length > 0 || options.addons.includes("starlight");
+		if (needsAppsDir && !workspaces.includes("apps/*")) workspaces.push("apps/*");
+	} else {
+		if (!workspaces.includes("apps/*")) workspaces.push("apps/*");
+		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
+	}
+	await fs.writeJson(rootPackageJsonPath, packageJson, { spaces: 2 });
+}
+async function updateServerPackageJson(projectDir, options) {
+	const serverPackageJsonPath = path.join(projectDir, "apps/server/package.json");
+	if (!await fs.pathExists(serverPackageJsonPath)) return;
+	const serverPackageJson = await fs.readJson(serverPackageJsonPath);
+	if (!serverPackageJson.scripts) serverPackageJson.scripts = {};
+	const scripts = serverPackageJson.scripts;
+	if (options.database !== "none") {
+		if (options.database === "sqlite" && options.orm === "drizzle") scripts["db:local"] = "turso dev --db-file local.db";
+		if (options.orm === "prisma") {
+			scripts["db:push"] = "prisma db push --schema ./prisma/schema";
+			scripts["db:studio"] = "prisma studio";
+			scripts["db:generate"] = "prisma generate --schema ./prisma/schema";
+			scripts["db:migrate"] = "prisma migrate dev";
+		} else if (options.orm === "drizzle") {
+			scripts["db:push"] = "drizzle-kit push";
+			scripts["db:studio"] = "drizzle-kit studio";
+			scripts["db:generate"] = "drizzle-kit generate";
+			scripts["db:migrate"] = "drizzle-kit migrate";
+		}
+	}
+	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
+}
+async function updateConvexPackageJson(projectDir, options) {
+	const convexPackageJsonPath = path.join(projectDir, "packages/backend/package.json");
+	if (!await fs.pathExists(convexPackageJsonPath)) return;
+	const convexPackageJson = await fs.readJson(convexPackageJsonPath);
+	convexPackageJson.name = `@${options.projectName}/backend`;
+	if (!convexPackageJson.scripts) convexPackageJson.scripts = {};
+	await fs.writeJson(convexPackageJsonPath, convexPackageJson, { spaces: 2 });
+}
+async function initializeGit(projectDir, useGit) {
+	if (!useGit) return;
+	const gitVersionResult = await $({
+		cwd: projectDir,
+		reject: false,
+		stderr: "pipe"
+	})`git --version`;
+	if (gitVersionResult.exitCode !== 0) {
+		log.warn(pc.yellow("Git is not installed"));
+		return;
+	}
+	const result = await $({
+		cwd: projectDir,
+		reject: false,
+		stderr: "pipe"
+	})`git init`;
+	if (result.exitCode !== 0) throw new Error(`Git initialization failed: ${result.stderr}`);
+}
+
+//#endregion
+//#region src/helpers/project-generation/create-project.ts
+async function createProject(options) {
+	const projectDir = options.projectDir;
+	const isConvex = options.backend === "convex";
+	try {
+		await fs.ensureDir(projectDir);
+		await copyBaseTemplate(projectDir, options);
+		await setupFrontendTemplates(projectDir, options);
+		await setupBackendFramework(projectDir, options);
+		if (!isConvex) {
+			await setupDbOrmTemplates(projectDir, options);
+			await setupAuthTemplate(projectDir, options);
+		}
+		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);
+		await setupAddonsTemplate(projectDir, options);
+		await setupApi(options);
+		if (!isConvex) {
+			await setupBackendDependencies(options);
+			await setupDatabase(options);
+			await setupRuntime(options);
+			if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamples(options);
+		}
+		if (options.addons.length > 0 && options.addons[0] !== "none") await setupAddons(options);
+		if (!isConvex && options.auth) await setupAuth(options);
+		await handleExtras(projectDir, options);
+		await setupEnvironmentVariables(options);
+		await updatePackageConfigurations(projectDir, options);
+		await createReadme(projectDir, options);
+		await writeTviConfig(options);
+		await initializeGit(projectDir, options.git);
+		log.success("Project template successfully scaffolded!");
+		if (options.install) {
+			await installDependencies({
+				projectDir,
+				packageManager: options.packageManager
+			});
+			await generateCloudflareWorkerTypes(options);
+		}
+		displayPostInstallInstructions({
+			...options,
+			depsInstalled: options.install
+		});
+		return projectDir;
+	} catch (error) {
+		if (error instanceof Error) {
+			cancel(pc.red(`Error during project creation: ${error.message}`));
+			console.error(error.stack);
+			process.exit(1);
+		} else {
+			cancel(pc.red(`An unexpected error occurred: ${String(error)}`));
+			console.error(error);
+			process.exit(1);
+		}
+	}
+}
+
+//#endregion
+//#region src/helpers/project-generation/command-handlers.ts
+async function createProjectHandler(input) {
+	const startTime = Date.now();
+	try {
+		renderTitle();
+		intro(pc.magenta("Creating a new tvi project"));
+		let currentPathInput;
+		if (input.yes && input.projectName) currentPathInput = input.projectName;
+		else if (input.yes) {
+			let defaultName = DEFAULT_CONFIG.relativePath;
+			let counter = 1;
+			while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
+				defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
+				counter++;
+			}
+			currentPathInput = defaultName;
+		} else currentPathInput = await getProjectName(input.projectName);
+		const { finalPathInput, shouldClearDirectory } = await handleDirectoryConflict(currentPathInput);
+		const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(finalPathInput, shouldClearDirectory);
+		const cliInput = {
+			...input,
+			projectDirectory: input.projectName
+		};
+		const providedFlags = getProvidedFlags(cliInput);
+		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+		const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
+		if (!input.yes && Object.keys(otherFlags).length > 0) {
+			log.info(pc.yellow("Using these pre-selected options:"));
+			log.message(displayConfig(otherFlags));
+			log.message("");
+		}
+		let config;
+		if (input.yes) {
+			config = {
+				...DEFAULT_CONFIG,
+				...flagConfig,
+				projectName: finalBaseName,
+				projectDir: finalResolvedPath,
+				relativePath: finalPathInput
+			};
+			if (config.backend === "convex") log.info("Due to '--backend convex' flag, the following options have been automatically set: auth=false, database=none, orm=none, api=none, runtime=none, dbSetup=none, examples=todo");
+			else if (config.backend === "none") log.info("Due to '--backend none', the following options have been automatically set: --auth=false, --database=none, --orm=none, --api=none, --runtime=none, --db-setup=none, --examples=none");
+			log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
+			log.message(displayConfig(config));
+			log.message("");
+		} else config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+		await createProject(config);
+		const reproducibleCommand = generateReproducibleCommand(config);
+		log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
+		await trackProjectCreation(config);
+		const elapsedTimeInSeconds = ((Date.now() - startTime) / 1e3).toFixed(2);
+		outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+}
+async function addAddonsHandler(input) {
+	try {
+		if (!input.addons || input.addons.length === 0) {
+			const projectDir = input.projectDir || process.cwd();
+			const detectedConfig = await detectProjectConfig(projectDir);
+			if (!detectedConfig) {
+				cancel(pc.red("Could not detect project configuration. Please ensure this is a valid tvi project."));
+				process.exit(1);
+			}
+			const addonsPrompt = await getAddonsToAdd(detectedConfig.frontend || [], detectedConfig.addons || []);
+			if (addonsPrompt.length === 0) {
+				outro(pc.yellow("No addons to add or all compatible addons are already present."));
+				return;
+			}
+			input.addons = addonsPrompt;
+		}
+		if (!input.addons || input.addons.length === 0) {
+			outro(pc.yellow("No addons specified to add."));
+			return;
+		}
+		await addAddonsToProject({
+			...input,
+			addons: input.addons
+		});
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/utils/open-url.ts
+async function openUrl(url) {
+	const platform = process.platform;
+	let command;
+	let args = [];
+	if (platform === "darwin") {
+		command = "open";
+		args = [url];
+	} else if (platform === "win32") {
+		command = "cmd";
+		args = [
+			"/c",
+			"start",
+			"",
+			url.replace(/&/g, "^&")
+		];
+	} else {
+		command = "xdg-open";
+		args = [url];
+	}
+	try {
+		await execa(command, args, { stdio: "ignore" });
+	} catch {
+		log.message(`Please open ${url} in your browser.`);
+	}
+}
+
+//#endregion
+//#region src/utils/sponsors.ts
+const SPONSORS_JSON_URL = "https://sponsors.shaneholloman.dev/sponsors.json";
+async function fetchSponsors(url = SPONSORS_JSON_URL) {
+	const s = spinner();
+	s.start("Fetching sponsors…");
+	const response = await fetch(url);
+	if (!response.ok) {
+		s.stop(pc.red(`Failed to fetch sponsors: ${response.statusText}`));
+		throw new Error(`Failed to fetch sponsors: ${response.statusText}`);
+	}
+	const sponsors = await response.json();
+	s.stop("Sponsors fetched successfully!");
+	return sponsors;
+}
+function displaySponsors(sponsors) {
+	if (sponsors.length === 0) {
+		log.info("No sponsors found. You can be the first one! SPARKLE");
+		outro(pc.cyan("Visit https://github.com/sponsors/shaneholloman to become a sponsor."));
+		return;
+	}
+	sponsors.forEach((entry, idx) => {
+		const sponsor = entry.sponsor;
+		const displayName = sponsor.name ?? sponsor.login;
+		const tier = entry.tierName ? ` (${entry.tierName})` : "";
+		log.step(`${idx + 1}. ${pc.green(displayName)}${pc.yellow(tier)}`);
+		log.message(`   ${pc.dim("GitHub:")} https://github.com/${sponsor.login}`);
+		const website = sponsor.websiteUrl ?? sponsor.linkUrl;
+		if (website) log.message(`   ${pc.dim("Website:")} ${website}`);
+	});
+	log.message("");
+	outro(pc.magenta("Visit https://github.com/sponsors/shaneholloman to become a sponsor."));
+}
+
+//#endregion
+//#region src/index.ts
+const t = trpcServer.initTRPC.create();
+const router = t.router({
+	init: t.procedure.meta({
+		description: "Create a new tvi project",
+		default: true
+	}).input(zod.tuple([ProjectNameSchema.optional(), zod.object({
+		yes: zod.boolean().optional().default(false).describe("Use default configuration"),
+		database: DatabaseSchema.optional(),
+		orm: ORMSchema.optional(),
+		auth: zod.boolean().optional(),
+		frontend: zod.array(FrontendSchema).optional(),
+		addons: zod.array(AddonsSchema).optional(),
+		examples: zod.array(ExamplesSchema).optional(),
+		git: zod.boolean().optional(),
+		packageManager: PackageManagerSchema.optional(),
+		install: zod.boolean().optional(),
+		dbSetup: DatabaseSetupSchema.optional(),
+		backend: BackendSchema.optional(),
+		runtime: RuntimeSchema.optional(),
+		api: APISchema.optional()
+	}).optional().default({})])).mutation(async ({ input }) => {
+		const [projectName, options] = input;
+		const combinedInput = {
+			projectName,
+			...options
+		};
+		await createProjectHandler(combinedInput);
+	}),
+	add: t.procedure.meta({ description: "Add addons to an existing tvi project" }).input(zod.tuple([zod.object({
+		addons: zod.array(AddonsSchema).optional().default([]),
+		projectDir: zod.string().optional(),
+		install: zod.boolean().optional().default(false).describe("Install dependencies after adding addons"),
+		packageManager: PackageManagerSchema.optional()
+	}).optional().default({})])).mutation(async ({ input }) => {
+		const [options] = input;
+		await addAddonsHandler(options);
+	}),
+	sponsors: t.procedure.meta({ description: "Show tvi sponsors" }).mutation(async () => {
+		try {
+			renderTitle();
+			intro(pc.magenta("tvi Sponsors"));
+			const sponsors = await fetchSponsors();
+			displaySponsors(sponsors);
+		} catch (error) {
+			consola$1.error(error);
+			process.exit(1);
+		}
+	}),
+	docs: t.procedure.meta({ description: "Open tvi documentation" }).mutation(async () => {
+		const DOCS_URL = "https://github.com/shaneholloman/tvi";
+		try {
+			await openUrl(DOCS_URL);
+			log.success(pc.blue("Opened docs in your default browser."));
+		} catch {
+			log.message(`Please visit ${DOCS_URL}`);
+		}
+	}),
+	builder: t.procedure.meta({ description: "Open the web-based stack builder" }).mutation(async () => {
+		const BUILDER_URL = "https://github.com/shaneholloman/tvi-web";
+		try {
+			await openUrl(BUILDER_URL);
+			log.success(pc.blue("Opened builder in your default browser."));
+		} catch {
+			log.message(`Please visit ${BUILDER_URL}`);
+		}
+	})
+});
+createCli({
+	router,
+	name: "tvi",
+	version: getLatestCLIVersion()
+}).run();
+
+//#endregion