create-better-t-stack 2.21.1 → 2.22.0

package/dist/index.js

@@ -6,10 +6,11 @@ import fs from "fs-extra";
 import pc from "picocolors";
 import { createCli, trpcServer, zod } from "trpc-cli";
 import { fileURLToPath } from "node:url";
+import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
-import os from "node:os";
 import { globby } from "globby";
 import handlebars from "handlebars";
+import os from "node:os";
 import { z } from "zod";
 import { PostHog } from "posthog-node";
 import gradient from "gradient-string";
@@ -102,6 +103,143 @@ const dependencyVersionMap = {
 	"@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/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/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/bts-config.ts
+const BTS_CONFIG_FILE = "bts.jsonc";
+async function writeBtsConfig(projectConfig) {
+	const btsConfig = {
+		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://better-t-stack.dev/schema.json",
+		version: btsConfig.version,
+		createdAt: btsConfig.createdAt,
+		database: btsConfig.database,
+		orm: btsConfig.orm,
+		backend: btsConfig.backend,
+		runtime: btsConfig.runtime,
+		frontend: btsConfig.frontend,
+		addons: btsConfig.addons,
+		examples: btsConfig.examples,
+		auth: btsConfig.auth,
+		packageManager: btsConfig.packageManager,
+		dbSetup: btsConfig.dbSetup,
+		api: btsConfig.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 = `// Better-T-Stack configuration file
+// safe to delete
+
+${configContent}`;
+	const configPath = path.join(projectConfig.projectDir, BTS_CONFIG_FILE);
+	await fs.writeFile(configPath, finalContent, "utf-8");
+}
+async function readBtsConfig(projectDir) {
+	try {
+		const configPath = path.join(projectDir, BTS_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 bts.jsonc:", errors);
+			return null;
+		}
+		return config;
+	} catch (_error) {
+		return null;
+	}
+}
+async function updateBtsConfig(projectDir, updates) {
+	try {
+		const configPath = path.join(projectDir, BTS_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
@@ -232,17 +370,26 @@ async function setupTauri(config) {
 
 //#endregion
 //#region src/helpers/setup/addons-setup.ts
-async function setupAddons(config) {
+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 (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);
@@ -316,453 +463,922 @@ async function setupPwa(projectDir, frontends) {
 }
 
 //#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) => [
+//#region src/helpers/project-generation/detect-project-config.ts
+async function detectProjectConfig(projectDir) {
+	try {
+		const btsConfig = await readBtsConfig(projectDir);
+		if (btsConfig) return {
+			projectDir,
+			projectName: path.basename(projectDir),
+			database: btsConfig.database,
+			orm: btsConfig.orm,
+			backend: btsConfig.backend,
+			runtime: btsConfig.runtime,
+			frontend: btsConfig.frontend,
+			addons: btsConfig.addons,
+			examples: btsConfig.examples,
+			auth: btsConfig.auth,
+			packageManager: btsConfig.packageManager,
+			dbSetup: btsConfig.dbSetup,
+			api: btsConfig.api
+		};
+		return null;
+	} catch (_error) {
+		return null;
+	}
+}
+async function isBetterTStackProject(projectDir) {
+	try {
+		return await fs.pathExists(path.join(projectDir, "bts.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 = 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
-				});
+	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);
+				}
 			}
-		}
-		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
-				});
+		} 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 (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",
+	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",
-		"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) {}
+		"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 (hasNative && nativeDirExists) {
-			const nativePkgJsonPath = path.join(nativeDir, "package.json");
-			if (await fs.pathExists(nativePkgJsonPath)) try {
-				await addPackageDependency({
-					dependencies: reactQueryDeps,
-					projectDir: nativeDir
-				});
-			} catch (_error) {}
+		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 (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 ((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 (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 (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);
 		}
-		if (nativeDirExists) {
-			const nativePkgJsonPath = path.join(nativeDir, "package.json");
-			if (await fs.pathExists(nativePkgJsonPath)) await addWorkspaceDepManually(nativePkgJsonPath, backendPackageName, backendWorkspaceVersion);
+	}
+}
+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);
 	}
 }
-
-//#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
+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);
+			}
 		}
-	} 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;
+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/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");
+//#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 Better-T Stack project. Please run this command from the root of a Better-T Stack project.");
+		const detectedConfig = await detectProjectConfig(projectDir);
+		if (!detectedConfig) exitWithError("Could not detect the project configuration. Please ensure this is a valid Better-T Stack 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`);
 		}
-	} 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");
+		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 updateBtsConfig(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}`);
 	}
-	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;
+//#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
+				});
 			}
-		} 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>";
+		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
+				});
 			}
-			const clientVars = [{
-				key: envVarName,
-				value: serverUrl,
-				condition: true
-			}];
-			await addEnvVariablesToFile(path.join(clientDir, ".env"), clientVars);
+		}
+		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
+			});
 		}
 	}
-	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);
+	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 (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;
+	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) {}
+		}
 	}
-	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
+	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);
 		}
-	];
-	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/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) {}
 	}
 }
 
@@ -1891,23 +2507,6 @@ function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNati
 	return scripts;
 }
 
-//#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/helpers/project-generation/post-installation.ts
 function displayPostInstallInstructions(config) {
@@ -2018,549 +2617,182 @@ function getStarlightInstructions(runCmd) {
 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/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);
-		}
-	}
+function getBunWebNativeWarning() {
+	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo. Use 'pnpm' if problems arise.`;
 }
-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);
-	}
+
+//#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 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);
+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`;
 			}
-			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) {}
+		}
+	} 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`;
 			}
 		}
-		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);
+	} 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}`;
 			}
 		}
-		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);
+	} 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`;
 			}
 		}
 	}
-}
-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 (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 ."] };
 	}
-	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);
+	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 (context.runtime === "workers") {
-		const runtimeWorkersDir = path.join(PKG_ROOT, "templates/runtime/workers");
-		if (await fs.pathExists(runtimeWorkersDir)) await processAndCopyFiles("**/*", runtimeWorkersDir, projectDir, context, false);
+	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
@@ -2592,6 +2824,7 @@ async function createProject(options) {
 		await setupEnvironmentVariables(options);
 		await updatePackageConfigurations(projectDir, options);
 		await createReadme(projectDir, options);
+		await writeBtsConfig(options);
 		await initializeGit(projectDir, options.git);
 		log.success("Project template successfully scaffolded!");
 		if (options.install) {
@@ -2619,48 +2852,145 @@ async function createProject(options) {
 	}
 }
 
+//#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/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 hasCompatiblePwaFrontend = frontends?.includes("react-router") || frontends?.includes("tanstack-router") || frontends?.includes("solid") || frontends?.includes("next");
-	const hasCompatibleTauriFrontend = frontends?.includes("react-router") || frontends?.includes("tanstack-router") || frontends?.includes("nuxt") || frontends?.includes("svelte") || frontends?.includes("solid") || frontends?.includes("next");
-	const allPossibleOptions = [
-		{
-			value: "turborepo",
-			label: "Turborepo (Recommended)",
-			hint: "Optimize builds for monorepos"
-		},
-		{
-			value: "starlight",
-			label: "Starlight",
-			hint: "Add Astro Starlight documentation site"
-		},
-		{
-			value: "biome",
-			label: "Biome",
-			hint: "Add Biome for linting and formatting"
-		},
-		{
-			value: "husky",
-			label: "Husky",
-			hint: "Add Git hooks with Husky, lint-staged (requires Biome)"
-		},
-		{
-			value: "pwa",
-			label: "PWA (Progressive Web App)",
-			hint: "Make your app installable and work offline"
-		},
-		{
-			value: "tauri",
-			label: "Tauri Desktop App",
-			hint: "Build native desktop apps from your web frontend"
+	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.filter((option) => {
-		if (option.value === "pwa") return hasCompatiblePwaFrontend;
-		if (option.value === "tauri") return hasCompatibleTauriFrontend;
-		return true;
+	}
+	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({
@@ -2676,6 +3006,30 @@ async function getAddonsChoice(addons, frontends) {
 	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
@@ -3233,94 +3587,6 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 	};
 }
 
-//#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/prompts/project-name.ts
 function validateDirectoryName(name) {
@@ -3372,14 +3638,6 @@ async function getProjectName(initialName) {
 	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 = "phc_8ZUxEwwfKMajJLvxz1daGd931dYbQrwKNficBmsdIrs";
@@ -3957,6 +4215,35 @@ async function createProjectHandler(input) {
 		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 Better-T Stack 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);
+	}
+}
 const router = t.router({
 	init: t.procedure.meta({
 		description: "Create a new Better-T Stack project",
@@ -3984,6 +4271,15 @@ const router = t.router({
 		};
 		await createProjectHandler(combinedInput);
 	}),
+	add: t.procedure.meta({ description: "Add addons to an existing Better-T Stack 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 Better-T Stack sponsors" }).mutation(async () => {
 		try {
 			renderTitle();