create-better-t-stack 3.13.2 → 3.14.1

package/dist/{src-kvJQuDe_.mjs → src-CSz9J82Z.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as __reExport } from "./chunk-Dt3mZKp0.mjs";
+import { t as __reExport } from "./chunk-DPg_XC7m.mjs";
 import { autocompleteMultiselect, cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
@@ -9,16 +9,14 @@ import consola, { consola as consola$1 } from "consola";
 import fs from "fs-extra";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
+import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, TEMPLATE_COUNT, VirtualFileSystem, dependencyVersionMap, generateVirtualProject, generateVirtualProject as generateVirtualProject$1 } from "@better-t-stack/template-generator";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
 import gradient from "gradient-string";
-import * as JSONC from "jsonc-parser";
+import { writeTreeToFilesystem } from "@better-t-stack/template-generator/fs-writer";
 import { $, execa } from "execa";
-import { IndentationText, Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
-import { glob } from "tinyglobby";
-import handlebars from "handlebars";
+import * as JSONC from "jsonc-parser";
 import { format } from "oxfmt";
-import yaml from "yaml";
 import os$1 from "node:os";
 
 //#region src/utils/get-package-manager.ts
@@ -64,111 +62,6 @@ function getDefaultConfig() {
 	};
 }
 const DEFAULT_CONFIG = getDefaultConfig();
-const dependencyVersionMap = {
-	typescript: "^5",
-	"better-auth": "^1.4.9",
-	"@better-auth/expo": "^1.4.9",
-	"@clerk/nextjs": "^6.31.5",
-	"@clerk/clerk-react": "^5.45.0",
-	"@clerk/tanstack-react-start": "^0.26.3",
-	"@clerk/clerk-expo": "^2.14.25",
-	"drizzle-orm": "^0.45.1",
-	"drizzle-kit": "^0.31.8",
-	"@planetscale/database": "^1.19.0",
-	"@libsql/client": "0.15.15",
-	libsql: "0.5.22",
-	"@neondatabase/serverless": "^1.0.2",
-	pg: "^8.16.3",
-	"@types/pg": "^8.15.6",
-	"@types/ws": "^8.18.1",
-	ws: "^8.18.3",
-	mysql2: "^3.14.0",
-	"@prisma/client": "^7.1.0",
-	prisma: "^7.1.0",
-	"@prisma/adapter-d1": "^7.1.0",
-	"@prisma/adapter-neon": "^7.1.0",
-	"@prisma/adapter-mariadb": "^7.1.0",
-	"@prisma/adapter-libsql": "^7.1.0",
-	"@prisma/adapter-better-sqlite3": "^7.1.0",
-	"@prisma/adapter-pg": "^7.1.0",
-	"@prisma/adapter-planetscale": "^7.1.0",
-	mongoose: "^8.14.0",
-	"vite-plugin-pwa": "^1.0.1",
-	"@vite-pwa/assets-generator": "^1.0.0",
-	"@tauri-apps/cli": "^2.4.0",
-	"@biomejs/biome": "^2.2.0",
-	oxlint: "^1.34.0",
-	oxfmt: "^0.19.0",
-	husky: "^9.1.7",
-	"lint-staged": "^16.1.2",
-	tsx: "^4.19.2",
-	"@types/node": "^22.13.14",
-	"@types/bun": "^1.3.4",
-	"@elysiajs/node": "^1.3.1",
-	"@elysiajs/cors": "^1.3.3",
-	"@elysiajs/trpc": "^1.1.0",
-	elysia: "^1.3.21",
-	"@hono/node-server": "^1.14.4",
-	"@hono/trpc-server": "^0.4.0",
-	hono: "^4.8.2",
-	cors: "^2.8.5",
-	express: "^5.1.0",
-	"@types/express": "^5.0.1",
-	"@types/cors": "^2.8.17",
-	fastify: "^5.3.3",
-	"@fastify/cors": "^11.0.1",
-	turbo: "^2.6.3",
-	ai: "^6.0.3",
-	"@ai-sdk/google": "^3.0.1",
-	"@ai-sdk/vue": "^3.0.3",
-	"@ai-sdk/svelte": "^4.0.3",
-	"@ai-sdk/react": "^3.0.3",
-	"@ai-sdk/devtools": "^0.0.2",
-	streamdown: "^1.6.10",
-	shiki: "^3.20.0",
-	"@orpc/server": "^1.12.2",
-	"@orpc/client": "^1.12.2",
-	"@orpc/openapi": "^1.12.2",
-	"@orpc/zod": "^1.12.2",
-	"@orpc/tanstack-query": "^1.12.2",
-	"@trpc/tanstack-react-query": "^11.7.2",
-	"@trpc/server": "^11.7.2",
-	"@trpc/client": "^11.7.2",
-	next: "^16.1.1",
-	convex: "^1.31.2",
-	"@convex-dev/react-query": "^0.1.0",
-	"@convex-dev/agent": "^0.3.2",
-	"convex-svelte": "^0.0.12",
-	"convex-nuxt": "0.1.5",
-	"convex-vue": "^0.1.5",
-	"@convex-dev/better-auth": "^0.10.9",
-	"@tanstack/svelte-query": "^5.85.3",
-	"@tanstack/svelte-query-devtools": "^5.85.3",
-	"@tanstack/vue-query-devtools": "^5.90.2",
-	"@tanstack/vue-query": "^5.90.2",
-	"@tanstack/react-query-devtools": "^5.91.1",
-	"@tanstack/react-query": "^5.90.12",
-	"@tanstack/react-router-ssr-query": "^1.142.7",
-	"@tanstack/solid-query": "^5.87.4",
-	"@tanstack/solid-query-devtools": "^5.87.4",
-	"@tanstack/solid-router-devtools": "^1.131.44",
-	wrangler: "^4.54.0",
-	"@cloudflare/vite-plugin": "^1.17.1",
-	"@opennextjs/cloudflare": "^1.14.6",
-	"nitro-cloudflare-dev": "^0.2.2",
-	"@sveltejs/adapter-cloudflare": "^7.2.4",
-	"@cloudflare/workers-types": "^4.20251213.0",
-	alchemy: "^0.82.1",
-	dotenv: "^17.2.2",
-	tsdown: "^0.16.5",
-	zod: "^4.1.13",
-	"@t3-oss/env-core": "^0.13.1",
-	"@t3-oss/env-nextjs": "^0.13.1",
-	"@t3-oss/env-nuxt": "^0.13.1",
-	srvx: "0.8.15",
-	"@polar-sh/better-auth": "^1.1.3",
-	"@polar-sh/sdk": "^0.34.16"
-};
 const ADDON_COMPATIBILITY = {
 	pwa: [
 		"tanstack-router",
@@ -198,22 +91,57 @@ const ADDON_COMPATIBILITY = {
 };
 
 //#endregion
-//#region src/types.ts
-var types_exports = {};
-import * as import__better_t_stack_types from "@better-t-stack/types";
-__reExport(types_exports, import__better_t_stack_types);
-
-//#endregion
-//#region src/utils/compatibility.ts
-const WEB_FRAMEWORKS = [
-	"tanstack-router",
-	"react-router",
-	"tanstack-start",
-	"next",
-	"nuxt",
-	"svelte",
-	"solid"
-];
+//#region src/utils/context.ts
+const cliStorage = new AsyncLocalStorage();
+function defaultContext() {
+	return {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: false,
+		verbose: false
+	};
+}
+function getContext() {
+	const ctx = cliStorage.getStore();
+	if (!ctx) return defaultContext();
+	return ctx;
+}
+function tryGetContext() {
+	return cliStorage.getStore();
+}
+function isSilent() {
+	return getContext().silent;
+}
+function isFirstPrompt() {
+	return getContext().navigation.isFirstPrompt;
+}
+function didLastPromptShowUI() {
+	return getContext().navigation.lastPromptShownUI;
+}
+function setIsFirstPrompt$1(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.isFirstPrompt = value;
+}
+function setLastPromptShownUI(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.lastPromptShownUI = value;
+}
+async function runWithContextAsync(options, fn) {
+	const ctx = {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: options.silent ?? false,
+		verbose: options.verbose ?? false,
+		projectDir: options.projectDir,
+		projectName: options.projectName,
+		packageManager: options.packageManager
+	};
+	return cliStorage.run(ctx, fn);
+}
 
 //#endregion
 //#region src/utils/errors.ts
@@ -230,19 +158,40 @@ var CLIError = class extends Error {
 	}
 };
 function exitWithError(message) {
+	if (isSilent()) throw new CLIError(message);
 	consola.error(pc.red(message));
-	throw new CLIError(message);
+	process.exit(1);
 }
 function exitCancelled(message = "Operation cancelled") {
+	if (isSilent()) throw new UserCancelledError(message);
 	cancel(pc.red(message));
-	throw new UserCancelledError(message);
+	process.exit(1);
 }
 function handleError(error, fallbackMessage) {
 	const message = error instanceof Error ? error.message : fallbackMessage || String(error);
+	if (isSilent()) throw error instanceof Error ? error : new Error(message);
 	consola.error(pc.red(message));
-	throw error instanceof Error ? error : new Error(message);
+	process.exit(1);
 }
 
+//#endregion
+//#region src/types.ts
+var types_exports = {};
+import * as import__better_t_stack_types from "@better-t-stack/types";
+__reExport(types_exports, import__better_t_stack_types);
+
+//#endregion
+//#region src/utils/compatibility.ts
+const WEB_FRAMEWORKS = [
+	"tanstack-router",
+	"react-router",
+	"tanstack-start",
+	"next",
+	"nuxt",
+	"svelte",
+	"solid"
+];
+
 //#endregion
 //#region src/utils/compatibility-rules.ts
 function isWebFrontend(value) {
@@ -337,14 +286,6 @@ function validateAddonCompatibility(addon, frontend, _auth) {
 	}
 	return { isCompatible: true };
 }
-function getCompatibleAddons(allAddons, frontend, existingAddons = [], auth) {
-	return allAddons.filter((addon) => {
-		if (existingAddons.includes(addon)) return false;
-		if (addon === "none") return false;
-		const { isCompatible } = validateAddonCompatibility(addon, frontend, auth);
-		return isCompatible;
-	});
-}
 function validateAddonsAgainstFrontends(addons = [], frontends = [], auth) {
 	for (const addon of addons) {
 		if (addon === "none") continue;
@@ -376,64 +317,8 @@ function validateExamplesCompatibility(examples, backend, database, frontend, ap
 	}
 }
 
-//#endregion
-//#region src/utils/context.ts
-const cliStorage = new AsyncLocalStorage();
-function defaultContext() {
-	return {
-		navigation: {
-			isFirstPrompt: false,
-			lastPromptShownUI: false
-		},
-		silent: false,
-		verbose: false
-	};
-}
-function getContext() {
-	const ctx = cliStorage.getStore();
-	if (!ctx) return defaultContext();
-	return ctx;
-}
-function tryGetContext() {
-	return cliStorage.getStore();
-}
-function isSilent() {
-	return getContext().silent;
-}
-function isFirstPrompt() {
-	return getContext().navigation.isFirstPrompt;
-}
-function didLastPromptShowUI() {
-	return getContext().navigation.lastPromptShownUI;
-}
-function setIsFirstPrompt$1(value) {
-	const ctx = tryGetContext();
-	if (ctx) ctx.navigation.isFirstPrompt = value;
-}
-function setLastPromptShownUI(value) {
-	const ctx = tryGetContext();
-	if (ctx) ctx.navigation.lastPromptShownUI = value;
-}
-async function runWithContextAsync(options, fn) {
-	const ctx = {
-		navigation: {
-			isFirstPrompt: false,
-			lastPromptShownUI: false
-		},
-		silent: options.silent ?? false,
-		verbose: options.verbose ?? false,
-		projectDir: options.projectDir,
-		projectName: options.projectName,
-		packageManager: options.packageManager
-	};
-	return cliStorage.run(ctx, fn);
-}
-
 //#endregion
 //#region src/utils/navigation.ts
-/**
-* Navigation symbols and utilities for prompt navigation
-*/
 const GO_BACK_SYMBOL = Symbol("clack:goBack");
 function isGoBack(value) {
 	return value === GO_BACK_SYMBOL;
@@ -729,29 +614,29 @@ function getAddonDisplay(addon) {
 	};
 }
 const ADDON_GROUPS = {
-	Documentation: ["starlight", "fumadocs"],
-	Linting: [
+	Tooling: [
+		"turborepo",
 		"biome",
 		"oxlint",
-		"ultracite"
+		"ultracite",
+		"husky"
 	],
-	Other: [
-		"ruler",
+	Documentation: ["starlight", "fumadocs"],
+	Extensions: [
 		"pwa",
 		"tauri",
-		"husky",
 		"opentui",
 		"wxt",
-		"turborepo"
+		"ruler"
 	]
 };
 async function getAddonsChoice(addons, frontends, auth) {
 	if (addons !== void 0) return addons;
 	const allAddons = types_exports.AddonsSchema.options.filter((addon) => addon !== "none");
 	const groupedOptions = {
+		Tooling: [],
 		Documentation: [],
-		Linting: [],
-		Other: []
+		Extensions: []
 	};
 	const frontendsArray = frontends || [];
 	for (const addon of allAddons) {
@@ -763,9 +648,9 @@ async function getAddonsChoice(addons, frontends, auth) {
 			label,
 			hint
 		};
-		if (ADDON_GROUPS.Documentation.includes(addon)) groupedOptions.Documentation.push(option);
-		else if (ADDON_GROUPS.Linting.includes(addon)) groupedOptions.Linting.push(option);
-		else if (ADDON_GROUPS.Other.includes(addon)) groupedOptions.Other.push(option);
+		if (ADDON_GROUPS.Tooling.includes(addon)) groupedOptions.Tooling.push(option);
+		else if (ADDON_GROUPS.Documentation.includes(addon)) groupedOptions.Documentation.push(option);
+		else if (ADDON_GROUPS.Extensions.includes(addon)) groupedOptions.Extensions.push(option);
 	}
 	Object.keys(groupedOptions).forEach((group$1) => {
 		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
@@ -785,43 +670,6 @@ async function getAddonsChoice(addons, frontends, auth) {
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
-async function getAddonsToAdd(frontend, existingAddons = [], auth) {
-	const groupedOptions = {
-		Documentation: [],
-		Linting: [],
-		Other: []
-	};
-	const frontendArray = frontend || [];
-	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, existingAddons, auth);
-	for (const addon of compatibleAddons) {
-		const { label, hint } = getAddonDisplay(addon);
-		const option = {
-			value: addon,
-			label,
-			hint
-		};
-		if (ADDON_GROUPS.Documentation.includes(addon)) groupedOptions.Documentation.push(option);
-		else if (ADDON_GROUPS.Linting.includes(addon)) groupedOptions.Linting.push(option);
-		else if (ADDON_GROUPS.Other.includes(addon)) groupedOptions.Other.push(option);
-	}
-	Object.keys(groupedOptions).forEach((group$1) => {
-		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
-		else {
-			const groupOrder = ADDON_GROUPS[group$1] || [];
-			groupedOptions[group$1].sort((a, b) => {
-				return groupOrder.indexOf(a.value) - groupOrder.indexOf(b.value);
-			});
-		}
-	});
-	if (Object.keys(groupedOptions).length === 0) return [];
-	const response = await navigableGroupMultiselect({
-		message: "Select addons to add",
-		options: groupedOptions,
-		required: false
-	});
-	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
-	return response;
-}
 
 //#endregion
 //#region src/prompts/api.ts
@@ -1441,16 +1289,6 @@ async function getRuntimeChoice(runtime, backend) {
 
 //#endregion
 //#region src/prompts/server-deploy.ts
-function getDeploymentDisplay$1(deployment) {
-	if (deployment === "cloudflare") return {
-		label: "Cloudflare",
-		hint: "Deploy to Cloudflare Workers using Alchemy"
-	};
-	return {
-		label: deployment,
-		hint: `Add ${deployment} deployment`
-	};
-}
 async function getServerDeploymentChoice(deployment, runtime, backend, _webDeploy) {
 	if (deployment !== void 0) return deployment;
 	if (backend === "none" || backend === "convex") return "none";
@@ -1458,29 +1296,6 @@ async function getServerDeploymentChoice(deployment, runtime, backend, _webDeplo
 	if (runtime === "workers") return "cloudflare";
 	return "none";
 }
-async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
-	if (backend !== "hono") return "none";
-	const options = [];
-	if (runtime === "workers") {
-		if (existingDeployment !== "cloudflare") {
-			const { label, hint } = getDeploymentDisplay$1("cloudflare");
-			options.push({
-				value: "cloudflare",
-				label,
-				hint
-			});
-		}
-	}
-	if (existingDeployment && existingDeployment !== "none") return "none";
-	if (options.length === 0) return "none";
-	const response = await navigableSelect({
-		message: "Select server deployment",
-		options,
-		initialValue: DEFAULT_CONFIG.serverDeploy
-	});
-	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
-	return response;
-}
 
 //#endregion
 //#region src/prompts/web-deploy.ts
@@ -1515,32 +1330,6 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
-async function getDeploymentToAdd(frontend, existingDeployment) {
-	if (!hasWebFrontend(frontend)) return "none";
-	const options = [];
-	if (existingDeployment !== "cloudflare") {
-		const { label, hint } = getDeploymentDisplay("cloudflare");
-		options.push({
-			value: "cloudflare",
-			label,
-			hint
-		});
-	}
-	if (existingDeployment && existingDeployment !== "none") return "none";
-	if (options.length > 0) options.push({
-		value: "none",
-		label: "None",
-		hint: "Skip deployment setup"
-	});
-	if (options.length === 0) return "none";
-	const response = await navigableSelect({
-		message: "Select web deployment",
-		options,
-		initialValue: DEFAULT_CONFIG.webDeploy
-	});
-	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
-	return response;
-}
 
 //#endregion
 //#region src/prompts/config-prompts.ts
@@ -2302,40 +2091,36 @@ ${configContent}`;
 	const configPath = path.join(projectConfig.projectDir, BTS_CONFIG_FILE);
 	await fs.writeFile(configPath, finalContent, "utf-8");
 }
-async function readBtsConfig(projectDir) {
+
+//#endregion
+//#region src/utils/file-formatter.ts
+const formatOptions = {
+	experimentalSortPackageJson: true,
+	experimentalSortImports: { order: "asc" }
+};
+async function formatCode(filePath, content) {
 	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;
+		const result = await format(path.basename(filePath), content, formatOptions);
+		if (result.errors && result.errors.length > 0) return null;
+		return result.code;
 	} catch {
 		return null;
 	}
 }
-async function updateBtsConfig(projectDir, updates) {
-	try {
-		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
-		if (!await fs.pathExists(configPath)) return;
-		let modifiedContent = await fs.readFile(configPath, "utf-8");
-		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 {}
+async function formatProject(projectDir) {
+	async function formatDirectory(dir) {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		await Promise.all(entries.map(async (entry) => {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) await formatDirectory(fullPath);
+			else if (entry.isFile()) try {
+				const content = await fs.readFile(fullPath, "utf-8");
+				const formatted = await formatCode(fullPath, content);
+				if (formatted && formatted !== content) await fs.writeFile(fullPath, formatted, "utf-8");
+			} catch {}
+		}));
+	}
+	await formatDirectory(projectDir);
 }
 
 //#endregion
@@ -2530,32 +2315,35 @@ async function setupRuler(config) {
 		const selectedEditors = await autocompleteMultiselect({
 			message: "Select AI assistants for Ruler",
 			options: Object.entries({
+				agentsmd: { label: "Agents.md" },
+				aider: { label: "Aider" },
+				amazonqcli: { label: "Amazon Q CLI" },
 				amp: { label: "AMP" },
-				copilot: { label: "GitHub Copilot" },
+				antigravity: { label: "Antigravity" },
+				augmentcode: { label: "AugmentCode" },
 				claude: { label: "Claude Code" },
+				cline: { label: "Cline" },
 				codex: { label: "OpenAI Codex CLI" },
+				copilot: { label: "GitHub Copilot" },
+				crush: { label: "Crush" },
 				cursor: { label: "Cursor" },
-				windsurf: { label: "Windsurf" },
-				cline: { label: "Cline" },
-				aider: { label: "Aider" },
 				firebase: { label: "Firebase Studio" },
-				"gemini-cli": { label: "Gemini CLI" },
-				junie: { label: "Junie" },
-				kilocode: { label: "Kilo Code" },
-				opencode: { label: "OpenCode" },
-				crush: { label: "Crush" },
-				zed: { label: "Zed" },
-				qwen: { label: "Qwen" },
-				amazonqcli: { label: "Amazon Q CLI" },
-				augmentcode: { label: "AugmentCode" },
 				firebender: { label: "Firebender" },
+				"gemini-cli": { label: "Gemini CLI" },
 				goose: { label: "Goose" },
 				jules: { label: "Jules" },
+				junie: { label: "Junie" },
+				kilocode: { label: "Kilo Code" },
 				kiro: { label: "Kiro" },
+				mistral: { label: "Mistral" },
+				opencode: { label: "OpenCode" },
 				openhands: { label: "Open Hands" },
+				qwen: { label: "Qwen" },
 				roo: { label: "RooCode" },
 				trae: { label: "Trae AI" },
-				warp: { label: "Warp" }
+				warp: { label: "Warp" },
+				windsurf: { label: "Windsurf" },
+				zed: { label: "Zed" }
 			}).map(([key, v]) => ({
 				value: key,
 				label: v.label
@@ -2643,26 +2431,9 @@ async function setupTauri(config) {
 	if (!await fs.pathExists(clientPackageDir)) return;
 	try {
 		s.start("Setting up Tauri desktop app support...");
-		await addPackageDependency({
-			devDependencies: ["@tauri-apps/cli"],
-			projectDir: clientPackageDir
-		});
-		const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
-		if (await fs.pathExists(clientPackageJsonPath)) {
-			const packageJson = await fs.readJson(clientPackageJsonPath);
-			packageJson.scripts = {
-				...packageJson.scripts,
-				tauri: "tauri",
-				"desktop:dev": "tauri dev",
-				"desktop:build": "tauri build"
-			};
-			await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
-		}
-		frontend.includes("tanstack-router");
 		const hasReactRouter = frontend.includes("react-router");
 		const hasNuxt = frontend.includes("nuxt");
 		const hasSvelte = frontend.includes("svelte");
-		frontend.includes("solid");
 		const hasNext = frontend.includes("next");
 		const devUrl = hasReactRouter || hasSvelte ? "http://localhost:5173" : hasNext ? "http://localhost:3001" : "http://localhost:3001";
 		const frontendDist = hasNuxt ? "../.output/public" : hasSvelte ? "../build" : hasNext ? "../.next" : hasReactRouter ? "../build/client" : "../dist";
@@ -2736,33 +2507,57 @@ async function setupTui(config) {
 
 //#endregion
 //#region src/helpers/addons/ultracite-setup.ts
+const LINTERS = {
+	biome: {
+		label: "Biome",
+		hint: "Fast formatter and linter"
+	},
+	eslint: {
+		label: "ESLint",
+		hint: "Traditional JavaScript linter"
+	},
+	oxlint: {
+		label: "Oxlint",
+		hint: "Oxidation compiler linter"
+	}
+};
 const EDITORS = {
-	vscode: { label: "VSCode / Cursor / Windsurf" },
+	vscode: { label: "VS Code" },
+	cursor: { label: "Cursor" },
+	windsurf: { label: "Windsurf" },
+	antigravity: { label: "Antigravity" },
+	kiro: { label: "Kiro" },
+	trae: { label: "Trae" },
+	void: { label: "Void" },
 	zed: { label: "Zed" }
 };
 const AGENTS = {
-	"vscode-copilot": { label: "VS Code Copilot" },
-	cursor: { label: "Cursor" },
-	windsurf: { label: "Windsurf" },
-	zed: { label: "Zed" },
 	claude: { label: "Claude" },
 	codex: { label: "Codex" },
-	kiro: { label: "Kiro" },
+	jules: { label: "Jules" },
+	copilot: { label: "GitHub Copilot" },
 	cline: { label: "Cline" },
 	amp: { label: "Amp" },
 	aider: { label: "Aider" },
 	"firebase-studio": { label: "Firebase Studio" },
 	"open-hands": { label: "Open Hands" },
-	"gemini-cli": { label: "Gemini CLI" },
+	gemini: { label: "Gemini" },
 	junie: { label: "Junie" },
 	augmentcode: { label: "AugmentCode" },
 	"kilo-code": { label: "Kilo Code" },
 	goose: { label: "Goose" },
-	"roo-code": { label: "Roo Code" }
+	"roo-code": { label: "Roo Code" },
+	warp: { label: "Warp" },
+	droid: { label: "Droid" },
+	opencode: { label: "OpenCode" },
+	crush: { label: "Crush" },
+	qwen: { label: "Qwen" },
+	"amazon-q-cli": { label: "Amazon Q CLI" },
+	firebender: { label: "Firebender" }
 };
 const HOOKS = {
 	cursor: { label: "Cursor" },
-	claude: { label: "Claude" }
+	windsurf: { label: "Windsurf" }
 };
 function getFrameworksFromFrontend(frontend) {
 	const frameworkMap = {
@@ -2785,8 +2580,16 @@ async function setupUltracite(config, hasHusky) {
 	const { packageManager, projectDir, frontend } = config;
 	try {
 		log.info("Setting up Ultracite...");
-		await setupBiome(projectDir);
 		const result = await group({
+			linter: () => select({
+				message: "Choose linter/formatter",
+				options: Object.entries(LINTERS).map(([key, linter$1]) => ({
+					value: key,
+					label: linter$1.label,
+					hint: linter$1.hint
+				})),
+				initialValue: "biome"
+			}),
 			editors: () => multiselect({
 				message: "Choose editors",
 				options: Object.entries(EDITORS).map(([key, editor]) => ({
@@ -2795,7 +2598,7 @@ async function setupUltracite(config, hasHusky) {
 				})),
 				required: true
 			}),
-			agents: () => autocompleteMultiselect({
+			agents: () => multiselect({
 				message: "Choose agents",
 				options: Object.entries(AGENTS).map(([key, agent]) => ({
 					value: key,
@@ -2803,7 +2606,7 @@ async function setupUltracite(config, hasHusky) {
 				})),
 				required: true
 			}),
-			hooks: () => autocompleteMultiselect({
+			hooks: () => multiselect({
 				message: "Choose hooks",
 				options: Object.entries(HOOKS).map(([key, hook]) => ({
 					value: key,
@@ -2813,6 +2616,7 @@ async function setupUltracite(config, hasHusky) {
 		}, { onCancel: () => {
 			exitCancelled("Operation cancelled");
 		} });
+		const linter = result.linter;
 		const editors = result.editors;
 		const agents = result.agents;
 		const hooks = result.hooks;
@@ -2820,7 +2624,9 @@ async function setupUltracite(config, hasHusky) {
 		const ultraciteArgs = [
 			"init",
 			"--pm",
-			packageManager
+			packageManager,
+			"--linter",
+			linter
 		];
 		if (frameworks.length > 0) ultraciteArgs.push("--frameworks", ...frameworks);
 		if (editors.length > 0) ultraciteArgs.push("--editors", ...editors);
@@ -2834,2298 +2640,168 @@ async function setupUltracite(config, hasHusky) {
 			cwd: projectDir,
 			env: { CI: "true" }
 		})`${args}`;
-		if (hasHusky) await addPackageDependency({
-			devDependencies: ["husky", "lint-staged"],
-			projectDir
-		});
-		s.stop("Ultracite setup successfully!");
-	} catch (error) {
-		log.error(pc.red("Failed to set up Ultracite"));
-		if (error instanceof Error) console.error(pc.red(error.message));
-	}
-}
-
-//#endregion
-//#region src/utils/ts-morph.ts
-const tsProject = new Project({
-	useInMemoryFileSystem: false,
-	skipAddingFilesFromTsConfig: true,
-	manipulationSettings: {
-		quoteKind: QuoteKind.Single,
-		indentationText: IndentationText.TwoSpaces
-	}
-});
-function ensureArrayProperty(obj, name) {
-	return obj.getProperty(name)?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) ?? obj.addPropertyAssignment({
-		name,
-		initializer: "[]"
-	}).getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-}
-
-//#endregion
-//#region src/helpers/addons/vite-pwa-setup.ts
-async function addPwaToViteConfig(viteConfigPath, projectName) {
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) throw new Error("vite config not found");
-	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa")) sourceFile.insertImportDeclaration(0, {
-		namedImports: ["VitePWA"],
-		moduleSpecifier: "vite-plugin-pwa"
-	});
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
-	const configObject = defineCall.getArguments()[0];
-	if (!configObject) throw new Error("defineConfig argument is not an object literal");
-	const pluginsArray = ensureArrayProperty(configObject, "plugins");
-	if (!pluginsArray.getElements().some((el) => el.getText().startsWith("VitePWA("))) pluginsArray.addElement(`VitePWA({
-  registerType: "autoUpdate",
-  manifest: {
-    name: "${projectName}",
-    short_name: "${projectName}",
-    description: "${projectName} - PWA Application",
-    theme_color: "#0c0c0c",
-  },
-  pwaAssets: { disabled: false, config: true },
-  devOptions: { enabled: true },
-})`);
-	await tsProject.save();
-}
-
-//#endregion
-//#region src/helpers/addons/wxt-setup.ts
-const TEMPLATES = {
-	vanilla: {
-		label: "Vanilla",
-		hint: "Vanilla JavaScript template"
-	},
-	vue: {
-		label: "Vue",
-		hint: "Vue.js template"
-	},
-	react: {
-		label: "React",
-		hint: "React template"
-	},
-	solid: {
-		label: "Solid",
-		hint: "SolidJS template"
-	},
-	svelte: {
-		label: "Svelte",
-		hint: "Svelte template"
-	}
-};
-async function setupWxt(config) {
-	const { packageManager, projectDir } = config;
-	try {
-		log.info("Setting up WXT...");
-		const template = await select({
-			message: "Choose a template",
-			options: Object.entries(TEMPLATES).map(([key, template$1]) => ({
-				value: key,
-				label: template$1.label,
-				hint: template$1.hint
-			})),
-			initialValue: "react"
-		});
-		if (isCancel(template)) return exitCancelled("Operation cancelled");
-		const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
-		const appsDir = path.join(projectDir, "apps");
-		await fs.ensureDir(appsDir);
-		const s = spinner();
-		s.start("Running WXT init command...");
-		await $({
-			cwd: appsDir,
-			env: { CI: "true" }
-		})`${args}`;
-		const extensionDir = path.join(projectDir, "apps", "extension");
-		const packageJsonPath = path.join(extensionDir, "package.json");
-		if (await fs.pathExists(packageJsonPath)) {
-			const packageJson = await fs.readJson(packageJsonPath);
-			packageJson.name = "extension";
-			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
-			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-		}
-		s.stop("WXT setup complete!");
-	} catch (error) {
-		log.error(pc.red("Failed to set up WXT"));
-		if (error instanceof Error) console.error(pc.red(error.message));
-	}
-}
-
-//#endregion
-//#region src/helpers/addons/addons-setup.ts
-async function setupAddons(config, isAddCommand = false) {
-	const { addons, frontend, projectDir, packageManager } = config;
-	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
-	const hasNuxtFrontend = frontend.includes("nuxt");
-	const hasSvelteFrontend = frontend.includes("svelte");
-	const hasSolidFrontend = frontend.includes("solid");
-	const hasNextFrontend = frontend.includes("next");
-	if (addons.includes("turborepo")) {
-		await addPackageDependency({
-			devDependencies: ["turbo"],
-			projectDir
-		});
-		if (isAddCommand) log.info(`${pc.yellow("Update your package.json scripts:")}
-
-${pc.dim("Replace:")} ${pc.yellow("\"pnpm -r dev\"")} ${pc.dim("→")} ${pc.green("\"turbo dev\"")}
-${pc.dim("Replace:")} ${pc.yellow("\"pnpm --filter web dev\"")} ${pc.dim("→")} ${pc.green("\"turbo -F web dev\"")}
-
-${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
-		`);
-	}
-	if (addons.includes("pwa") && (hasReactWebFrontend || hasSolidFrontend)) await setupPwa(projectDir, frontend);
-	if (addons.includes("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await setupTauri(config);
-	const hasUltracite = addons.includes("ultracite");
-	const hasBiome = addons.includes("biome");
-	const hasHusky = addons.includes("husky");
-	const hasOxlint = addons.includes("oxlint");
-	if (hasUltracite) await setupUltracite(config, hasHusky);
-	else {
-		if (hasBiome) await setupBiome(projectDir);
-		if (hasHusky) {
-			let linter;
-			if (hasOxlint) linter = "oxlint";
-			else if (hasBiome) linter = "biome";
-			await setupHusky(projectDir, linter);
-		}
-	}
-	if (hasOxlint) await setupOxlint(projectDir, packageManager);
-	if (addons.includes("starlight")) await setupStarlight(config);
-	if (addons.includes("ruler")) await setupRuler(config);
-	if (addons.includes("fumadocs")) await setupFumadocs(config);
-	if (addons.includes("opentui")) await setupTui(config);
-	if (addons.includes("wxt")) await setupWxt(config);
-}
-function getWebAppDir(projectDir, frontends) {
-	if (frontends.some((f) => [
-		"react-router",
-		"tanstack-router",
-		"nuxt",
-		"svelte",
-		"solid"
-	].includes(f))) return path.join(projectDir, "apps/web");
-	return path.join(projectDir, "apps/web");
-}
-async function setupBiome(projectDir) {
-	await addPackageDependency({
-		devDependencies: ["@biomejs/biome"],
-		projectDir
-	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			check: "biome check --write ."
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function setupHusky(projectDir, linter) {
-	await addPackageDependency({
-		devDependencies: ["husky", "lint-staged"],
-		projectDir
-	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			prepare: "husky"
-		};
-		if (linter === "oxlint") packageJson["lint-staged"] = { "*": ["oxlint", "oxfmt --write"] };
-		else if (linter === "biome") packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
-		else packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "" };
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function setupPwa(projectDir, frontends) {
-	if (!frontends.some((f) => [
-		"react-router",
-		"tanstack-router",
-		"solid"
-	].includes(f))) return;
-	const clientPackageDir = getWebAppDir(projectDir, frontends);
-	if (!await fs.pathExists(clientPackageDir)) return;
-	await addPackageDependency({
-		dependencies: ["vite-plugin-pwa"],
-		devDependencies: ["@vite-pwa/assets-generator"],
-		projectDir: clientPackageDir
-	});
-	const clientPackageJsonPath = path.join(clientPackageDir, "package.json");
-	if (await fs.pathExists(clientPackageJsonPath)) {
-		const packageJson = await fs.readJson(clientPackageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			"generate-pwa-assets": "pwa-assets-generator"
-		};
-		await fs.writeJson(clientPackageJsonPath, packageJson, { spaces: 2 });
-	}
-	const viteConfigTs = path.join(clientPackageDir, "vite.config.ts");
-	if (await fs.pathExists(viteConfigTs)) await addPwaToViteConfig(viteConfigTs, path.basename(projectDir));
-}
-
-//#endregion
-//#region src/helpers/core/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,
-			payments: btsConfig.payments,
-			packageManager: btsConfig.packageManager,
-			dbSetup: btsConfig.dbSetup,
-			api: btsConfig.api,
-			webDeploy: btsConfig.webDeploy,
-			serverDeploy: btsConfig.serverDeploy
-		};
-		return null;
-	} catch {
-		return null;
-	}
-}
-async function isBetterTStackProject(projectDir) {
-	try {
-		return await fs.pathExists(path.join(projectDir, "bts.jsonc"));
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-//#region src/helpers/core/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/file-formatter.ts
-const formatOptions = {
-	experimentalSortPackageJson: true,
-	experimentalSortImports: { order: "asc" }
-};
-async function formatFile(filePath, content) {
-	try {
-		const result = await format(path.basename(filePath), content, formatOptions);
-		if (result.errors && result.errors.length > 0) return null;
-		return result.code;
-	} catch {
-		return null;
-	}
-}
-
-//#endregion
-//#region src/utils/template-processor.ts
-const BINARY_EXTENSIONS = new Set([
-	".png",
-	".ico",
-	".svg"
-]);
-function isBinaryFile(filePath) {
-	const ext = path.extname(filePath).toLowerCase();
-	return BINARY_EXTENSIONS.has(ext);
-}
-async function processTemplate(srcPath, destPath, context) {
-	try {
-		await fs.ensureDir(path.dirname(destPath));
-		if (isBinaryFile(srcPath) && !srcPath.endsWith(".hbs")) {
-			await fs.copy(srcPath, destPath);
-			return;
-		}
-		let content;
-		if (srcPath.endsWith(".hbs")) {
-			const templateContent = await fs.readFile(srcPath, "utf-8");
-			content = handlebars.compile(templateContent)(context);
-		} else content = await fs.readFile(srcPath, "utf-8");
-		try {
-			const formattedContent = await formatFile(destPath, content);
-			if (formattedContent) content = formattedContent;
-		} catch (formatError) {
-			consola.debug(`Failed to format ${destPath}:`, formatError);
-		}
-		await fs.writeFile(destPath, content);
-	} 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("ne", (a, b) => a !== b);
-handlebars.registerHelper("and", (...args) => {
-	return args.slice(0, -1).every((value) => value);
-});
-handlebars.registerHelper("or", (...args) => {
-	return args.slice(0, -1).some((value) => value);
-});
-handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
-
-//#endregion
-//#region src/helpers/core/template-manager.ts
-async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
-	const sourceFiles = await glob(sourcePattern, {
-		cwd: baseSourceDir,
-		dot: true,
-		onlyFiles: true,
-		absolute: false,
-		ignore: ignorePatterns
-	});
-	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(relativeDestPath);
-		if (basename === "_gitignore") relativeDestPath = path.join(path.dirname(relativeDestPath), ".gitignore");
-		else if (basename === "_npmrc") relativeDestPath = path.join(path.dirname(relativeDestPath), ".npmrc");
-		const destPath = path.join(destDir, relativeDestPath);
-		await fs.ensureDir(path.dirname(destPath));
-		if (!overwrite && await fs.pathExists(destPath)) continue;
-		await processTemplate(srcPath, destPath, context);
-	}
-}
-async function copyBaseTemplate(projectDir, context) {
-	await processAndCopyFiles(["**/*"], path.join(PKG_ROOT, "templates/base"), projectDir, context);
-}
-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 hasNativeBare = context.frontend.includes("native-bare");
-	const hasNativeUniwind = context.frontend.includes("native-uniwind");
-	const hasUnistyles = context.frontend.includes("native-unistyles");
-	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 (context.backend === "self" && (reactFramework === "next" || reactFramework === "tanstack-start") && context.api !== "none") {
-					const apiFullstackDir = path.join(PKG_ROOT, `templates/api/${context.api}/fullstack/${reactFramework}`);
-					if (await fs.pathExists(apiFullstackDir)) await processAndCopyFiles("**/*", apiFullstackDir, 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 (hasNativeBare || hasNativeUniwind || hasUnistyles) {
-		const nativeAppDir = path.join(projectDir, "apps/native");
-		await fs.ensureDir(nativeAppDir);
-		const nativeBaseCommonDir = path.join(PKG_ROOT, "templates/frontend/native/base");
-		if (await fs.pathExists(nativeBaseCommonDir)) await processAndCopyFiles("**/*", nativeBaseCommonDir, nativeAppDir, context);
-		let nativeFrameworkPath = "";
-		if (hasNativeBare) nativeFrameworkPath = "bare";
-		else if (hasNativeUniwind) nativeFrameworkPath = "uniwind";
-		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 setupApiPackage$1(projectDir, context) {
-	if (context.api === "none") return;
-	const apiPackageDir = path.join(projectDir, "packages/api");
-	await fs.ensureDir(apiPackageDir);
-	const apiServerDir = path.join(PKG_ROOT, `templates/api/${context.api}/server`);
-	if (await fs.pathExists(apiServerDir)) await processAndCopyFiles("**/*", apiServerDir, apiPackageDir, context);
-}
-async function setupConfigPackage(projectDir, context) {
-	const configPackageDir = path.join(projectDir, "packages/config");
-	await fs.ensureDir(configPackageDir);
-	const configBaseDir = path.join(PKG_ROOT, "templates/packages/config");
-	if (await fs.pathExists(configBaseDir)) await processAndCopyFiles("**/*", configBaseDir, configPackageDir, context);
-}
-async function setupDbPackage$1(projectDir, context) {
-	if (context.database === "none" || context.orm === "none") return;
-	const dbPackageDir = path.join(projectDir, "packages/db");
-	await fs.ensureDir(dbPackageDir);
-	const dbBaseDir = path.join(PKG_ROOT, "templates/db/base");
-	if (await fs.pathExists(dbBaseDir)) await processAndCopyFiles("**/*", dbBaseDir, dbPackageDir, context);
-	const dbOrmBaseDir = path.join(PKG_ROOT, `templates/db/${context.orm}/base`);
-	if (await fs.pathExists(dbOrmBaseDir)) await processAndCopyFiles("**/*", dbOrmBaseDir, dbPackageDir, context);
-	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
-	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, dbPackageDir, context);
-}
-async function setupConvexBackend(projectDir, context) {
-	const serverAppDir = path.join(projectDir, "apps/server");
-	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);
-}
-async function setupServerApp(projectDir, context) {
-	const serverAppDir = path.join(projectDir, "apps/server");
-	await fs.ensureDir(serverAppDir);
-	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/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);
-}
-async function setupEnvPackage$1(projectDir, context) {
-	const hasWebFrontend$1 = context.frontend.some((f) => [
-		"tanstack-router",
-		"react-router",
-		"tanstack-start",
-		"next",
-		"nuxt",
-		"svelte",
-		"solid"
-	].includes(f));
-	const hasNative = context.frontend.some((f) => [
-		"native-bare",
-		"native-uniwind",
-		"native-unistyles"
-	].includes(f));
-	if (!hasWebFrontend$1 && !hasNative && context.backend === "none") return;
-	const envPackageDir = path.join(projectDir, "packages/env");
-	await fs.ensureDir(envPackageDir);
-	const envBaseDir = path.join(PKG_ROOT, "templates/packages/env");
-	const packageJsonSrc = path.join(envBaseDir, "package.json.hbs");
-	if (await fs.pathExists(packageJsonSrc)) await processAndCopyFiles("package.json.hbs", envBaseDir, envPackageDir, context);
-	const tsconfigSrc = path.join(envBaseDir, "tsconfig.json.hbs");
-	if (await fs.pathExists(tsconfigSrc)) await processAndCopyFiles("tsconfig.json.hbs", envBaseDir, envPackageDir, context);
-	const needsServerEnv = context.backend !== "none" && context.backend !== "convex";
-	if (needsServerEnv) {
-		const serverSrc = path.join(envBaseDir, "src/server.ts.hbs");
-		if (await fs.pathExists(serverSrc)) {
-			await fs.ensureDir(path.join(envPackageDir, "src"));
-			await processAndCopyFiles("src/server.ts.hbs", envBaseDir, envPackageDir, context);
-		}
-	}
-	if (hasWebFrontend$1) {
-		const webSrc = path.join(envBaseDir, "src/web.ts.hbs");
-		if (await fs.pathExists(webSrc)) {
-			await fs.ensureDir(path.join(envPackageDir, "src"));
-			await processAndCopyFiles("src/web.ts.hbs", envBaseDir, envPackageDir, context);
-		}
-	}
-	if (hasNative) {
-		const nativeSrc = path.join(envBaseDir, "src/native.ts.hbs");
-		if (await fs.pathExists(nativeSrc)) {
-			await fs.ensureDir(path.join(envPackageDir, "src"));
-			await processAndCopyFiles("src/native.ts.hbs", envBaseDir, envPackageDir, context);
-		}
-	}
-	const packageJsonPath = path.join(envPackageDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		const exports = {};
-		if (needsServerEnv) exports["./server"] = "./src/server.ts";
-		if (hasWebFrontend$1) exports["./web"] = "./src/web.ts";
-		if (hasNative) exports["./native"] = "./src/native.ts";
-		packageJson.exports = exports;
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function setupBackendFramework(projectDir, context) {
-	await setupConfigPackage(projectDir, context);
-	await setupEnvPackage$1(projectDir, context);
-	if (context.backend === "none") return;
-	if (context.backend === "convex") {
-		await setupConvexBackend(projectDir, context);
-		return;
-	}
-	if (context.backend === "self") {
-		await setupApiPackage$1(projectDir, context);
-		await setupDbPackage$1(projectDir, context);
-		return;
-	}
-	await setupServerApp(projectDir, context);
-	await setupApiPackage$1(projectDir, context);
-	await setupDbPackage$1(projectDir, context);
-}
-async function setupAuthTemplate(projectDir, context) {
-	if (!context.auth || context.auth === "none") 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 hasNativeBare = context.frontend.includes("native-bare");
-	const hasUniwind = context.frontend.includes("native-uniwind");
-	const hasUnistyles = context.frontend.includes("native-unistyles");
-	const hasNative = hasNativeBare || hasUniwind || hasUnistyles;
-	const authProvider = context.auth;
-	if (context.backend === "convex" && authProvider === "clerk") {
-		const convexBackendDestDir = path.join(projectDir, "packages/backend");
-		const convexClerkBackendSrc = path.join(PKG_ROOT, "templates/auth/clerk/convex/backend");
-		if (await fs.pathExists(convexClerkBackendSrc)) {
-			await fs.ensureDir(convexBackendDestDir);
-			await processAndCopyFiles("**/*", convexClerkBackendSrc, convexBackendDestDir, context);
-		}
-		if (webAppDirExists) {
-			const reactFramework = context.frontend.find((f) => [
-				"tanstack-router",
-				"react-router",
-				"tanstack-start",
-				"next"
-			].includes(f));
-			if (reactFramework) {
-				const convexClerkWebSrc = path.join(PKG_ROOT, `templates/auth/clerk/convex/web/react/${reactFramework}`);
-				if (await fs.pathExists(convexClerkWebSrc)) await processAndCopyFiles("**/*", convexClerkWebSrc, webAppDir, context);
-			}
-		}
-		if (nativeAppDirExists) {
-			const convexClerkNativeBaseSrc = path.join(PKG_ROOT, "templates/auth/clerk/convex/native/base");
-			if (await fs.pathExists(convexClerkNativeBaseSrc)) await processAndCopyFiles("**/*", convexClerkNativeBaseSrc, nativeAppDir, context);
-			let nativeFrameworkPath = "";
-			if (hasNativeBare) nativeFrameworkPath = "bare";
-			else if (hasUniwind) nativeFrameworkPath = "uniwind";
-			else if (hasUnistyles) nativeFrameworkPath = "unistyles";
-			if (nativeFrameworkPath) {
-				const convexClerkNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/clerk/convex/native/${nativeFrameworkPath}`);
-				if (await fs.pathExists(convexClerkNativeFrameworkSrc)) await processAndCopyFiles("**/*", convexClerkNativeFrameworkSrc, nativeAppDir, context);
-			}
-		}
-		return;
-	}
-	if (context.backend === "convex" && authProvider === "better-auth") {
-		const convexBackendDestDir = path.join(projectDir, "packages/backend");
-		const convexBetterAuthBackendSrc = path.join(PKG_ROOT, "templates/auth/better-auth/convex/backend");
-		if (await fs.pathExists(convexBetterAuthBackendSrc)) {
-			await fs.ensureDir(convexBackendDestDir);
-			await processAndCopyFiles("**/*", convexBetterAuthBackendSrc, convexBackendDestDir, context);
-		}
-		if (webAppDirExists && hasReactWeb) {
-			const convexBetterAuthWebBaseSrc = path.join(PKG_ROOT, "templates/auth/better-auth/convex/web/react/base");
-			if (await fs.pathExists(convexBetterAuthWebBaseSrc)) await processAndCopyFiles("**/*", convexBetterAuthWebBaseSrc, webAppDir, context);
-			const reactFramework = context.frontend.find((f) => [
-				"tanstack-router",
-				"react-router",
-				"tanstack-start",
-				"next"
-			].includes(f));
-			if (reactFramework) {
-				const convexBetterAuthWebSrc = path.join(PKG_ROOT, `templates/auth/better-auth/convex/web/react/${reactFramework}`);
-				if (await fs.pathExists(convexBetterAuthWebSrc)) await processAndCopyFiles("**/*", convexBetterAuthWebSrc, webAppDir, context);
-			}
-		}
-		if (nativeAppDirExists) {
-			const convexBetterAuthNativeBaseSrc = path.join(PKG_ROOT, "templates/auth/better-auth/convex/native/base");
-			if (await fs.pathExists(convexBetterAuthNativeBaseSrc)) await processAndCopyFiles("**/*", convexBetterAuthNativeBaseSrc, nativeAppDir, context);
-			let nativeFrameworkPath = "";
-			if (hasNativeBare) nativeFrameworkPath = "bare";
-			else if (hasUniwind) nativeFrameworkPath = "uniwind";
-			else if (hasUnistyles) nativeFrameworkPath = "unistyles";
-			if (nativeFrameworkPath) {
-				const convexBetterAuthNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/better-auth/convex/native/${nativeFrameworkPath}`);
-				if (await fs.pathExists(convexBetterAuthNativeFrameworkSrc)) await processAndCopyFiles("**/*", convexBetterAuthNativeFrameworkSrc, nativeAppDir, context);
-			}
-		}
-		return;
-	}
-	if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex") {
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		await fs.ensureDir(authPackageDir);
-		const authServerBaseSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/base`);
-		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, authPackageDir, context);
-		if (context.orm !== "none" && context.database !== "none") {
-			const dbPackageDir = path.join(projectDir, "packages/db");
-			await fs.ensureDir(dbPackageDir);
-			const orm = context.orm;
-			const db = context.database;
-			let authDbSrc = "";
-			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/drizzle/${db}`);
-			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/prisma/${db}`);
-			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/mongoose/${db}`);
-			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, dbPackageDir, context);
-		}
-	}
-	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
-		if (hasReactWeb) {
-			const authWebBaseSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/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/${authProvider}/web/react/${reactFramework}`);
-				if (await fs.pathExists(authWebFrameworkSrc)) await processAndCopyFiles("**/*", authWebFrameworkSrc, webAppDir, context);
-				if (context.backend === "self" && (reactFramework === "next" || reactFramework === "tanstack-start")) {
-					const authFullstackSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/fullstack/${reactFramework}`);
-					if (await fs.pathExists(authFullstackSrc)) await processAndCopyFiles("**/*", authFullstackSrc, webAppDir, context);
-				}
-			}
-		} else if (hasNuxtWeb) {
-			const authWebNuxtSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/web/nuxt`);
-			if (await fs.pathExists(authWebNuxtSrc)) await processAndCopyFiles("**/*", authWebNuxtSrc, webAppDir, context);
-		} else if (hasSvelteWeb) {
-			const authWebSvelteSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/web/svelte`);
-			if (await fs.pathExists(authWebSvelteSrc)) await processAndCopyFiles("**/*", authWebSvelteSrc, webAppDir, context);
-		} else if (hasSolidWeb) {
-			const authWebSolidSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/web/solid`);
-			if (await fs.pathExists(authWebSolidSrc)) await processAndCopyFiles("**/*", authWebSolidSrc, webAppDir, context);
-		}
-	}
-	if (hasNative && nativeAppDirExists) {
-		const authNativeBaseSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/native/base`);
-		if (await fs.pathExists(authNativeBaseSrc)) await processAndCopyFiles("**/*", authNativeBaseSrc, nativeAppDir, context);
-		let nativeFrameworkAuthPath = "";
-		if (hasNativeBare) nativeFrameworkAuthPath = "bare";
-		else if (hasUniwind) nativeFrameworkAuthPath = "uniwind";
-		else if (hasUnistyles) nativeFrameworkAuthPath = "unistyles";
-		if (nativeFrameworkAuthPath) {
-			const authNativeFrameworkSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/native/${nativeFrameworkAuthPath}`);
-			if (await fs.pathExists(authNativeFrameworkSrc)) await processAndCopyFiles("**/*", authNativeFrameworkSrc, nativeAppDir, context);
-		}
-	}
-}
-async function setupPaymentsTemplate(projectDir, context) {
-	if (!context.payments || context.payments === "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);
-	if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex") {
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		await fs.ensureDir(authPackageDir);
-		const paymentsServerSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/server/base`);
-		if (await fs.pathExists(paymentsServerSrc)) await processAndCopyFiles("**/*", paymentsServerSrc, authPackageDir, 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");
-	if (webAppDirExists && (hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb)) {
-		if (hasReactWeb) {
-			const reactFramework = context.frontend.find((f) => [
-				"tanstack-router",
-				"react-router",
-				"tanstack-start",
-				"next"
-			].includes(f));
-			if (reactFramework) {
-				const paymentsWebSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/web/react/${reactFramework}`);
-				if (await fs.pathExists(paymentsWebSrc)) await processAndCopyFiles("**/*", paymentsWebSrc, webAppDir, context);
-			}
-		} else if (hasNuxtWeb) {
-			const paymentsWebNuxtSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/web/nuxt`);
-			if (await fs.pathExists(paymentsWebNuxtSrc)) await processAndCopyFiles("**/*", paymentsWebNuxtSrc, webAppDir, context);
-		} else if (hasSvelteWeb) {
-			const paymentsWebSvelteSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/web/svelte`);
-			if (await fs.pathExists(paymentsWebSvelteSrc)) await processAndCopyFiles("**/*", paymentsWebSvelteSrc, webAppDir, context);
-		} else if (hasSolidWeb) {
-			const paymentsWebSolidSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/web/solid`);
-			if (await fs.pathExists(paymentsWebSolidSrc)) await processAndCopyFiles("**/*", paymentsWebSolidSrc, webAppDir, context);
-		}
-	}
-}
-async function setupAddonsTemplate(projectDir, context) {
-	if (!context.addons || context.addons.length === 0) return;
-	for (const addon of context.addons) {
-		if (addon === "none") continue;
-		let addonSrcDir = path.join(PKG_ROOT, `templates/addons/${addon}`);
-		let addonDestDir = projectDir;
-		if (addon === "pwa") {
-			const webAppDir = path.join(projectDir, "apps/web");
-			if (!await fs.pathExists(webAppDir)) continue;
-			addonDestDir = webAppDir;
-			if (context.frontend.includes("next")) addonSrcDir = path.join(PKG_ROOT, "templates/addons/pwa/apps/web/next");
-			else if (context.frontend.some((f) => [
-				"tanstack-router",
-				"react-router",
-				"solid"
-			].includes(f))) addonSrcDir = path.join(PKG_ROOT, "templates/addons/pwa/apps/web/vite");
-			else continue;
-		}
-		if (await fs.pathExists(addonSrcDir)) await processAndCopyFiles("**/*", addonSrcDir, addonDestDir, context);
-	}
-}
-async function setupExamplesTemplate(projectDir, context) {
-	if (!context.examples || context.examples.length === 0 || context.examples[0] === "none") return;
-	const serverAppDir = path.join(projectDir, "apps/server");
-	const webAppDir = path.join(projectDir, "apps/web");
-	const serverAppDirExists = await fs.pathExists(serverAppDir);
-	const webAppDirExists = await fs.pathExists(webAppDir);
-	const nativeAppDir = path.join(projectDir, "apps/native");
-	const nativeAppDirExists = await fs.pathExists(nativeAppDir);
-	const hasReactWeb = context.frontend.some((f) => [
-		"tanstack-router",
-		"react-router",
-		"tanstack-start",
-		"next"
-	].includes(f));
-	const hasNuxtWeb = context.frontend.includes("nuxt");
-	const hasSvelteWeb = context.frontend.includes("svelte");
-	const hasSolidWeb = context.frontend.includes("solid");
-	for (const example of context.examples) {
-		if (example === "none") continue;
-		const exampleBaseDir = path.join(PKG_ROOT, `templates/examples/${example}`);
-		if (context.backend === "convex") {
-			const convexBackendDestDir = path.join(projectDir, "packages/backend");
-			const convexExampleSrc = path.join(exampleBaseDir, "convex/packages/backend");
-			if (await fs.pathExists(convexExampleSrc)) await processAndCopyFiles("**/*", convexExampleSrc, convexBackendDestDir, context, false);
-		} else if ((serverAppDirExists || context.backend === "self") && context.backend !== "none") {
-			const exampleServerSrc = path.join(exampleBaseDir, "server");
-			if (context.api !== "none") {
-				const apiPackageDir = path.join(projectDir, "packages/api");
-				await fs.ensureDir(apiPackageDir);
-				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
-				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, apiPackageDir, context, false);
-			}
-			if (context.orm !== "none" && context.database !== "none") {
-				const dbPackageDir = path.join(projectDir, "packages/db");
-				await fs.ensureDir(dbPackageDir);
-				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
-				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, dbPackageDir, context, false);
-			}
-		}
-		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);
-						if (context.backend === "self" && (reactFramework === "next" || reactFramework === "tanstack-start")) {
-							const exampleFullstackSrc = path.join(exampleBaseDir, `fullstack/${reactFramework}`);
-							if (await fs.pathExists(exampleFullstackSrc)) await processAndCopyFiles("**/*", exampleFullstackSrc, 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 hasNativeBare = context.frontend.includes("native-bare");
-			const hasUniwind = context.frontend.includes("native-uniwind");
-			const hasUnistyles = context.frontend.includes("native-unistyles");
-			if (hasNativeBare || hasUniwind || hasUnistyles) {
-				let nativeFramework = "";
-				if (hasNativeBare) nativeFramework = "bare";
-				else if (hasUniwind) nativeFramework = "uniwind";
-				else if (hasUnistyles) nativeFramework = "unistyles";
-				const exampleNativeSrc = path.join(exampleBaseDir, `native/${nativeFramework}`);
-				if (await fs.pathExists(exampleNativeSrc)) await processAndCopyFiles("**/*", exampleNativeSrc, nativeAppDir, context, false);
-			}
-		}
-	}
-}
-async function handleExtras(projectDir, context) {
-	const extrasDir = path.join(PKG_ROOT, "templates/extras");
-	const hasNativeBare = context.frontend.includes("native-bare");
-	const hasUniwind = context.frontend.includes("native-uniwind");
-	const hasUnistyles = context.frontend.includes("native-unistyles");
-	const hasNative = hasNativeBare || hasUniwind || 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 processTemplate(pnpmWorkspaceSrc, pnpmWorkspaceDest, context);
-	}
-	if (context.packageManager === "bun") {
-		const bunfigSrc = path.join(extrasDir, "bunfig.toml.hbs");
-		if (await fs.pathExists(bunfigSrc)) await processAndCopyFiles("bunfig.toml.hbs", extrasDir, projectDir, context);
-	}
-	if (context.packageManager === "pnpm" && (hasNative || context.frontend.includes("nuxt"))) {
-		const npmrcTemplateSrc = path.join(extrasDir, "_npmrc.hbs");
-		if (await fs.pathExists(npmrcTemplateSrc)) await processAndCopyFiles("_npmrc.hbs", extrasDir, projectDir, context);
-	}
-}
-async function setupDockerComposeTemplates(projectDir, context) {
-	if (context.dbSetup !== "docker" || context.database === "none") return;
-	const dbPackageDir = path.join(projectDir, "packages/db");
-	const dockerSrcDir = path.join(PKG_ROOT, `templates/db-setup/docker-compose/${context.database}`);
-	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, dbPackageDir, context);
-}
-async function setupDeploymentTemplates(projectDir, context) {
-	const isBackendSelf = context.backend === "self";
-	if (context.webDeploy === "cloudflare" || context.serverDeploy === "cloudflare") {
-		const infraTemplateSrc = path.join(PKG_ROOT, "templates/packages/infra");
-		const infraDir = path.join(projectDir, "packages/infra");
-		if (await fs.pathExists(infraTemplateSrc)) {
-			await fs.ensureDir(infraDir);
-			await processAndCopyFiles("package.json.hbs", infraTemplateSrc, infraDir, context);
-			await processAndCopyFiles("alchemy.run.ts.hbs", infraTemplateSrc, infraDir, context);
-		}
-		if (!isBackendSelf) {
-			const envTemplateSrc = path.join(PKG_ROOT, "templates/packages/env");
-			const envDir = path.join(projectDir, "packages/env");
-			const envDtsTemplatePath = path.join(envTemplateSrc, "env.d.ts.hbs");
-			if (await fs.pathExists(envDtsTemplatePath)) await processTemplate(envDtsTemplatePath, path.join(envDir, "env.d.ts"), context);
-		}
-	}
-	if (context.webDeploy !== "none" && context.webDeploy !== "cloudflare") {
-		const webAppDir = path.join(projectDir, "apps/web");
-		if (await fs.pathExists(webAppDir)) {
-			const frontends = context.frontend;
-			const templateMap = {
-				"tanstack-router": "react/tanstack-router",
-				"tanstack-start": "react/tanstack-start",
-				"react-router": "react/react-router",
-				solid: "solid",
-				next: "react/next",
-				nuxt: "nuxt",
-				svelte: "svelte"
-			};
-			for (const f of frontends) if (templateMap[f]) {
-				const deployTemplateSrc = path.join(PKG_ROOT, `templates/deploy/${context.webDeploy}/web/${templateMap[f]}`);
-				if (await fs.pathExists(deployTemplateSrc)) await processAndCopyFiles("**/*", deployTemplateSrc, webAppDir, context);
-			}
-		}
-	}
-	if (context.serverDeploy !== "none" && context.serverDeploy !== "cloudflare" && !isBackendSelf) {
-		const serverAppDir = path.join(projectDir, "apps/server");
-		if (await fs.pathExists(serverAppDir)) {
-			const deployTemplateSrc = path.join(PKG_ROOT, `templates/deploy/${context.serverDeploy}/server`);
-			if (await fs.pathExists(deployTemplateSrc)) await processAndCopyFiles("**/*", deployTemplateSrc, serverAppDir, context);
-		}
-	}
-}
-
-//#endregion
-//#region src/helpers/core/add-addons.ts
-async function addAddonsToProject(input) {
-	try {
-		const projectDir = input.projectDir || process.cwd();
-		if (!await isBetterTStackProject(projectDir)) 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 || "none",
-			payments: detectedConfig.payments || "none",
-			git: false,
-			packageManager: input.packageManager || detectedConfig.packageManager || "npm",
-			install: input.install || false,
-			dbSetup: detectedConfig.dbSetup || "none",
-			api: detectedConfig.api || "none",
-			webDeploy: detectedConfig.webDeploy || "none",
-			serverDeploy: detectedConfig.serverDeploy || "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`);
-		}
-		await setupAddonsTemplate(projectDir, config);
-		await setupAddons(config, true);
-		const currentAddons = detectedConfig.addons || [];
-		await updateBtsConfig(projectDir, { addons: [...new Set([...currentAddons, ...input.addons])] });
-		if (config.install) await installDependencies({
-			projectDir,
-			packageManager: config.packageManager
-		});
-		else if (!input.suppressInstallMessage) log.info(pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`));
-	} catch (error) {
-		exitWithError(`Error adding addons: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-next-setup.ts
-async function setupNextAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		dependencies: ["@opennextjs/cloudflare"],
-		devDependencies: [
-			"alchemy",
-			"wrangler",
-			"@cloudflare/workers-types"
-		],
-		projectDir: webAppDir
-	});
-	const openNextConfigPath = path.join(webAppDir, "open-next.config.ts");
-	await fs.writeFile(openNextConfigPath, `import { defineCloudflareConfig } from "@opennextjs/cloudflare";
-
-export default defineCloudflareConfig({});
-`);
-	const gitignorePath = path.join(webAppDir, ".gitignore");
-	if (await fs.pathExists(gitignorePath)) {
-		if (!(await fs.readFile(gitignorePath, "utf-8")).includes("wrangler.jsonc")) await fs.appendFile(gitignorePath, "\nwrangler.jsonc\n");
-	} else await fs.writeFile(gitignorePath, "wrangler.jsonc\n");
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-nuxt-setup.ts
-async function setupNuxtAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: [
-			"alchemy",
-			"nitro-cloudflare-dev",
-			"wrangler"
-		],
-		projectDir: webAppDir
-	});
-	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
-	if (!await fs.pathExists(nuxtConfigPath)) return;
-	try {
-		const project = new Project({ manipulationSettings: {
-			indentationText: IndentationText.TwoSpaces,
-			quoteKind: QuoteKind.Double
-		} });
-		project.addSourceFileAtPath(nuxtConfigPath);
-		const exportAssignment = project.getSourceFileOrThrow(nuxtConfigPath).getExportAssignment((d) => !d.isExportEquals());
-		if (!exportAssignment) return;
-		const defineConfigCall = exportAssignment.getExpression();
-		if (!Node.isCallExpression(defineConfigCall) || defineConfigCall.getExpression().getText() !== "defineNuxtConfig") return;
-		let configObject = defineConfigCall.getArguments()[0];
-		if (!configObject) configObject = defineConfigCall.addArgument("{}");
-		if (Node.isObjectLiteralExpression(configObject)) {
-			if (!configObject.getProperty("nitro")) configObject.addPropertyAssignment({
-				name: "nitro",
-				initializer: `{
-    preset: "cloudflare_module",
-    cloudflare: {
-      deployConfig: true,
-      nodeCompat: true
-    }
-  }`
-			});
-			const modulesProperty = configObject.getProperty("modules");
-			if (modulesProperty && Node.isPropertyAssignment(modulesProperty)) {
-				const initializer = modulesProperty.getInitializer();
-				if (Node.isArrayLiteralExpression(initializer)) {
-					if (!initializer.getElements().some((el) => el.getText() === "\"nitro-cloudflare-dev\"" || el.getText() === "'nitro-cloudflare-dev'")) initializer.addElement("\"nitro-cloudflare-dev\"");
-				}
-			} else if (!modulesProperty) configObject.addPropertyAssignment({
-				name: "modules",
-				initializer: "[\"nitro-cloudflare-dev\"]"
-			});
-		}
-		await project.save();
-	} catch (error) {
-		console.warn("Failed to update nuxt.config.ts:", error);
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-react-router-setup.ts
-async function setupReactRouterAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy"],
-		projectDir: webAppDir
-	});
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-solid-setup.ts
-async function setupSolidAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy"],
-		projectDir: webAppDir
-	});
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-svelte-setup.ts
-async function setupSvelteAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy", "@sveltejs/adapter-cloudflare"],
-		projectDir: webAppDir
-	});
-	const svelteConfigPath = path.join(webAppDir, "svelte.config.js");
-	if (!await fs.pathExists(svelteConfigPath)) return;
-	try {
-		const project = new Project({ manipulationSettings: {
-			indentationText: IndentationText.TwoSpaces,
-			quoteKind: QuoteKind.Single
-		} });
-		project.addSourceFileAtPath(svelteConfigPath);
-		const sourceFile = project.getSourceFileOrThrow(svelteConfigPath);
-		const adapterImport = sourceFile.getImportDeclarations().find((imp) => imp.getModuleSpecifierValue().includes("@sveltejs/adapter"));
-		if (adapterImport) {
-			adapterImport.setModuleSpecifier("alchemy/cloudflare/sveltekit");
-			adapterImport.removeDefaultImport();
-			adapterImport.setDefaultImport("alchemy");
-		} else sourceFile.insertImportDeclaration(0, {
-			moduleSpecifier: "alchemy/cloudflare/sveltekit",
-			defaultImport: "alchemy"
-		});
-		const configVariable = sourceFile.getVariableDeclaration("config");
-		if (configVariable) {
-			const initializer = configVariable.getInitializer();
-			if (Node.isObjectLiteralExpression(initializer)) updateAdapterInConfig(initializer);
-		}
-		await project.save();
-	} catch (error) {
-		console.warn("Failed to update svelte.config.js:", error);
-	}
-}
-function updateAdapterInConfig(configObject) {
-	if (!Node.isObjectLiteralExpression(configObject)) return;
-	const kitProperty = configObject.getProperty("kit");
-	if (kitProperty && Node.isPropertyAssignment(kitProperty)) {
-		const kitInitializer = kitProperty.getInitializer();
-		if (Node.isObjectLiteralExpression(kitInitializer)) {
-			const adapterProperty = kitInitializer.getProperty("adapter");
-			if (adapterProperty && Node.isPropertyAssignment(adapterProperty)) {
-				const initializer = adapterProperty.getInitializer();
-				if (Node.isCallExpression(initializer)) {
-					const expression = initializer.getExpression();
-					if (Node.isIdentifier(expression) && expression.getText() === "adapter") expression.replaceWithText("alchemy");
-				}
-			}
-		}
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-tanstack-router-setup.ts
-async function setupTanStackRouterAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy"],
-		projectDir: webAppDir
-	});
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-tanstack-start-setup.ts
-async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, _options) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy", "@cloudflare/vite-plugin"],
-		projectDir: webAppDir
-	});
-	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
-	if (await fs.pathExists(viteConfigPath)) try {
-		const project = new Project({ manipulationSettings: {
-			indentationText: IndentationText.TwoSpaces,
-			quoteKind: QuoteKind.Double
-		} });
-		project.addSourceFileAtPath(viteConfigPath);
-		const sourceFile = project.getSourceFileOrThrow(viteConfigPath);
-		const alchemyImport = sourceFile.getImportDeclaration("alchemy/cloudflare/tanstack-start");
-		if (!alchemyImport) sourceFile.addImportDeclaration({
-			moduleSpecifier: "alchemy/cloudflare/tanstack-start",
-			defaultImport: "alchemy"
-		});
-		else alchemyImport.setModuleSpecifier("alchemy/cloudflare/tanstack-start");
-		const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
-		if (!exportAssignment) return;
-		const defineConfigCall = exportAssignment.getExpression();
-		if (!Node.isCallExpression(defineConfigCall) || defineConfigCall.getExpression().getText() !== "defineConfig") return;
-		let configObject = defineConfigCall.getArguments()[0];
-		if (!configObject) configObject = defineConfigCall.addArgument("{}");
-		if (Node.isObjectLiteralExpression(configObject)) {
-			const pluginsProperty = configObject.getProperty("plugins");
-			if (pluginsProperty && Node.isPropertyAssignment(pluginsProperty)) {
-				const initializer = pluginsProperty.getInitializer();
-				if (Node.isArrayLiteralExpression(initializer)) {
-					if (!initializer.getElements().some((el) => el.getText().includes("alchemy("))) initializer.addElement("alchemy()");
-				}
-			} else configObject.addPropertyAssignment({
-				name: "plugins",
-				initializer: "[alchemy()]"
-			});
-		}
-		await project.save();
-	} catch (error) {
-		console.warn("Failed to update vite.config.ts:", error);
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/alchemy/alchemy-combined-setup.ts
-function getInfraFilter(packageManager, hasTurborepo, infraWorkspace) {
-	if (hasTurborepo) return (script) => `turbo -F ${infraWorkspace} ${script}`;
-	switch (packageManager) {
-		case "pnpm": return (script) => `pnpm --filter ${infraWorkspace} ${script}`;
-		case "npm": return (script) => `npm run ${script} --workspace ${infraWorkspace}`;
-		case "bun": return (script) => `bun run --filter ${infraWorkspace} ${script}`;
-	}
-}
-async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
-	await setupInfraScripts(projectDir, packageManager, config);
-	const serverDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, projectDir);
-	const frontend = config.frontend;
-	const isNext = frontend.includes("next");
-	const isNuxt = frontend.includes("nuxt");
-	const isSvelte = frontend.includes("svelte");
-	const isTanstackRouter = frontend.includes("tanstack-router");
-	const isTanstackStart = frontend.includes("tanstack-start");
-	const isReactRouter = frontend.includes("react-router");
-	const isSolid = frontend.includes("solid");
-	if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
-}
-async function setupInfraScripts(projectDir, packageManager, config) {
-	const projectName = config.projectName;
-	const hasTurborepo = config.addons.includes("turborepo");
-	const infraWorkspace = `@${projectName}/infra`;
-	const rootPkgPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(rootPkgPath)) {
-		const pkg = await fs.readJson(rootPkgPath);
-		const filter = getInfraFilter(packageManager, hasTurborepo, infraWorkspace);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: filter("deploy"),
-			destroy: filter("destroy")
-		};
-		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
-	}
-	if (config.serverDeploy === "cloudflare") {
-		const serverPkgPath = path.join(projectDir, "apps/server/package.json");
-		if (await fs.pathExists(serverPkgPath)) {
-			const serverPkg = await fs.readJson(serverPkgPath);
-			if (serverPkg.scripts?.dev) {
-				serverPkg.scripts["dev:bare"] = serverPkg.scripts.dev;
-				delete serverPkg.scripts.dev;
-				await fs.writeJson(serverPkgPath, serverPkg, { spaces: 2 });
-			}
-		}
-	}
-	if (config.webDeploy === "cloudflare") {
-		const webPkgPath = path.join(projectDir, "apps/web/package.json");
-		if (await fs.pathExists(webPkgPath)) {
-			const webPkg = await fs.readJson(webPkgPath);
-			if (webPkg.scripts?.dev) {
-				webPkg.scripts["dev:bare"] = webPkg.scripts.dev;
-				delete webPkg.scripts.dev;
-				await fs.writeJson(webPkgPath, webPkg, { spaces: 2 });
-			}
-		}
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/server-deploy-setup.ts
-async function setupServerDeploy(config) {
-	const { serverDeploy, webDeploy, projectDir, packageManager } = config;
-	if (serverDeploy === "none") return;
-	if (serverDeploy === "cloudflare" && webDeploy === "cloudflare") return;
-	const serverDir = path.join(projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
-	if (serverDeploy === "cloudflare") {
-		await setupInfraScripts(projectDir, packageManager, config);
-		await setupAlchemyServerDeploy(serverDir, projectDir);
-	}
-}
-async function setupAlchemyServerDeploy(serverDir, projectDir) {
-	if (!await fs.pathExists(serverDir)) return;
-	await addPackageDependency({
-		devDependencies: [
-			"alchemy",
-			"wrangler",
-			"@types/node",
-			"@cloudflare/workers-types"
-		],
-		projectDir: serverDir
-	});
-	if (projectDir) await addAlchemyPackagesDependencies$1(projectDir);
-}
-async function addAlchemyPackagesDependencies$1(projectDir) {
-	await addPackageDependency({
-		devDependencies: ["@cloudflare/workers-types"],
-		projectDir
-	});
-}
-
-//#endregion
-//#region src/helpers/deployment/web-deploy-setup.ts
-async function setupWebDeploy(config) {
-	const { webDeploy, serverDeploy, frontend, projectDir } = config;
-	const { packageManager } = config;
-	if (webDeploy === "none") return;
-	if (webDeploy !== "cloudflare") return;
-	if (webDeploy === "cloudflare" && serverDeploy === "cloudflare") {
-		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
-		await addAlchemyPackagesDependencies(projectDir);
-		return;
-	}
-	await setupInfraScripts(projectDir, packageManager, config);
-	const isNext = frontend.includes("next");
-	const isNuxt = frontend.includes("nuxt");
-	const isSvelte = frontend.includes("svelte");
-	const isTanstackRouter = frontend.includes("tanstack-router");
-	const isTanstackStart = frontend.includes("tanstack-start");
-	const isReactRouter = frontend.includes("react-router");
-	const isSolid = frontend.includes("solid");
-	if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager);
-	else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager);
-	else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager);
-	else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
-	else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
-	else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
-	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
-	await addAlchemyPackagesDependencies(projectDir);
-}
-async function addAlchemyPackagesDependencies(projectDir) {
-	await addPackageDependency({
-		devDependencies: ["@cloudflare/workers-types"],
-		projectDir
-	});
-}
-
-//#endregion
-//#region src/helpers/core/add-deployment.ts
-async function addDeploymentToProject(input) {
-	try {
-		const projectDir = input.projectDir || process.cwd();
-		if (!await isBetterTStackProject(projectDir)) 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.");
-		if (input.webDeploy && detectedConfig.webDeploy === input.webDeploy) exitWithError(`${input.webDeploy} web deployment is already configured for this project.`);
-		if (input.serverDeploy && detectedConfig.serverDeploy === input.serverDeploy) exitWithError(`${input.serverDeploy} server deployment is already configured for this 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: detectedConfig.addons || [],
-			examples: detectedConfig.examples || [],
-			auth: detectedConfig.auth || "none",
-			payments: detectedConfig.payments || "none",
-			git: false,
-			packageManager: input.packageManager || detectedConfig.packageManager || "npm",
-			install: input.install || false,
-			dbSetup: detectedConfig.dbSetup || "none",
-			api: detectedConfig.api || "none",
-			webDeploy: input.webDeploy || detectedConfig.webDeploy || "none",
-			serverDeploy: input.serverDeploy || detectedConfig.serverDeploy || "none"
-		};
-		if (input.webDeploy && input.webDeploy !== "none") log.info(pc.green(`Adding ${input.webDeploy} web deployment to ${config.frontend.join("/")}`));
-		if (input.serverDeploy && input.serverDeploy !== "none") log.info(pc.green(`Adding ${input.serverDeploy} server deployment`));
-		await setupDeploymentTemplates(projectDir, config);
-		await setupWebDeploy(config);
-		await setupServerDeploy(config);
-		await updateBtsConfig(projectDir, {
-			webDeploy: input.webDeploy || config.webDeploy,
-			serverDeploy: input.serverDeploy || config.serverDeploy
-		});
-		if (config.install) await installDependencies({
-			projectDir,
-			packageManager: config.packageManager
-		});
-		else if (!input.suppressInstallMessage) log.info(pc.yellow(`Run ${pc.bold(`${config.packageManager} install`)} to install dependencies`));
-	} catch (error) {
-		exitWithError(`Error adding deployment: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-
-//#endregion
-//#region src/utils/setup-catalogs.ts
-async function setupCatalogs(projectDir, options) {
-	if (options.packageManager === "npm") return;
-	const packagePaths = [
-		".",
-		"apps/server",
-		"apps/web",
-		"apps/native",
-		"apps/fumadocs",
-		"apps/docs",
-		"packages/api",
-		"packages/db",
-		"packages/auth",
-		"packages/backend",
-		"packages/config",
-		"packages/env",
-		"packages/infra"
-	];
-	const packagesInfo = [];
-	for (const pkgPath of packagePaths) {
-		const fullPath = path.join(projectDir, pkgPath);
-		const pkgJsonPath = path.join(fullPath, "package.json");
-		if (await fs.pathExists(pkgJsonPath)) {
-			const pkgJson = await fs.readJson(pkgJsonPath);
-			packagesInfo.push({
-				path: fullPath,
-				dependencies: pkgJson.dependencies || {},
-				devDependencies: pkgJson.devDependencies || {}
-			});
-		}
-	}
-	const catalog = findDuplicateDependencies(packagesInfo, options.projectName);
-	if (Object.keys(catalog).length === 0) return;
-	if (options.packageManager === "bun") await setupBunCatalogs(projectDir, catalog);
-	else if (options.packageManager === "pnpm") await setupPnpmCatalogs(projectDir, catalog);
-	await updatePackageJsonsWithCatalogs(packagesInfo, catalog);
-}
-function findDuplicateDependencies(packagesInfo, projectName) {
-	const depCount = /* @__PURE__ */ new Map();
-	const projectScope = `@${projectName}/`;
-	for (const pkg of packagesInfo) {
-		const allDeps = {
-			...pkg.dependencies,
-			...pkg.devDependencies
-		};
-		for (const [depName, version] of Object.entries(allDeps)) {
-			if (depName.startsWith(projectScope)) continue;
-			if (version.startsWith("workspace:")) continue;
-			const existing = depCount.get(depName);
-			if (existing) {
-				existing.versions.add(version);
-				existing.packages.push(pkg.path);
-			} else depCount.set(depName, {
-				versions: new Set([version]),
-				packages: [pkg.path]
-			});
-		}
-	}
-	const catalog = {};
-	for (const [depName, info] of depCount.entries()) if (info.packages.length > 1 && info.versions.size === 1) catalog[depName] = Array.from(info.versions)[0];
-	return catalog;
-}
-async function setupBunCatalogs(projectDir, catalog) {
-	const rootPkgJsonPath = path.join(projectDir, "package.json");
-	const rootPkgJson = await fs.readJson(rootPkgJsonPath);
-	if (!rootPkgJson.workspaces) rootPkgJson.workspaces = {};
-	if (Array.isArray(rootPkgJson.workspaces)) rootPkgJson.workspaces = {
-		packages: rootPkgJson.workspaces,
-		catalog
-	};
-	else if (typeof rootPkgJson.workspaces === "object") {
-		if (!rootPkgJson.workspaces.catalog) rootPkgJson.workspaces.catalog = {};
-		rootPkgJson.workspaces.catalog = {
-			...rootPkgJson.workspaces.catalog,
-			...catalog
-		};
-	}
-	await fs.writeJson(rootPkgJsonPath, rootPkgJson, { spaces: 2 });
-}
-async function setupPnpmCatalogs(projectDir, catalog) {
-	const workspaceYamlPath = path.join(projectDir, "pnpm-workspace.yaml");
-	if (!await fs.pathExists(workspaceYamlPath)) return;
-	const workspaceContent = await fs.readFile(workspaceYamlPath, "utf-8");
-	const workspaceYaml = yaml.parse(workspaceContent);
-	if (!workspaceYaml.catalog) workspaceYaml.catalog = {};
-	workspaceYaml.catalog = {
-		...workspaceYaml.catalog,
-		...catalog
-	};
-	await fs.writeFile(workspaceYamlPath, yaml.stringify(workspaceYaml));
-}
-async function updatePackageJsonsWithCatalogs(packagesInfo, catalog) {
-	for (const pkg of packagesInfo) {
-		const pkgJsonPath = path.join(pkg.path, "package.json");
-		const pkgJson = await fs.readJson(pkgJsonPath);
-		let updated = false;
-		if (pkgJson.dependencies) {
-			for (const depName of Object.keys(pkgJson.dependencies)) if (catalog[depName]) {
-				pkgJson.dependencies[depName] = "catalog:";
-				updated = true;
-			}
-		}
-		if (pkgJson.devDependencies) {
-			for (const depName of Object.keys(pkgJson.devDependencies)) if (catalog[depName]) {
-				pkgJson.devDependencies[depName] = "catalog:";
-				updated = true;
-			}
-		}
-		if (updated) await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
-	}
-}
-
-//#endregion
-//#region src/helpers/addons/examples-setup.ts
-async function setupExamples(config) {
-	const { examples, backend } = config;
-	if (!examples || examples.length === 0 || examples[0] === "none") return;
-	if (examples.includes("todo") && backend !== "convex" && backend !== "none") await setupTodoDependencies(config);
-	if (examples.includes("ai")) await setupAIDependencies(config);
-}
-async function setupTodoDependencies(config) {
-	const { projectDir, orm, database, backend } = config;
-	const apiDir = path.join(projectDir, "packages/api");
-	if (!await fs.pathExists(apiDir) || backend === "none") return;
-	if (orm === "drizzle") {
-		const dependencies = ["drizzle-orm"];
-		if (database === "postgres") dependencies.push("@types/pg");
-		await addPackageDependency({
-			dependencies,
-			projectDir: apiDir
-		});
-	} else if (orm === "prisma") await addPackageDependency({
-		dependencies: ["@prisma/client"],
-		projectDir: apiDir
-	});
-	else if (orm === "mongoose") await addPackageDependency({
-		dependencies: ["mongoose"],
-		projectDir: apiDir
-	});
-}
-async function setupAIDependencies(config) {
-	const { frontend, backend, projectDir } = config;
-	const webClientDir = path.join(projectDir, "apps/web");
-	const nativeClientDir = path.join(projectDir, "apps/native");
-	const serverDir = path.join(projectDir, "apps/server");
-	const convexBackendDir = path.join(projectDir, "packages/backend");
-	const webClientDirExists = await fs.pathExists(webClientDir);
-	const nativeClientDirExists = await fs.pathExists(nativeClientDir);
-	const serverDirExists = await fs.pathExists(serverDir);
-	const convexBackendDirExists = await fs.pathExists(convexBackendDir);
-	const hasReactWeb = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next") || frontend.includes("tanstack-start");
-	const hasNuxt = frontend.includes("nuxt");
-	const hasSvelte = frontend.includes("svelte");
-	const hasReactNative = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-	if (backend === "convex" && convexBackendDirExists) await addPackageDependency({
-		dependencies: ["@convex-dev/agent"],
-		customDependencies: {
-			ai: "^5.0.117",
-			"@ai-sdk/google": "^2.0.52"
-		},
-		projectDir: convexBackendDir
-	});
-	else if (backend === "self" && webClientDirExists) await addPackageDependency({
-		dependencies: [
-			"ai",
-			"@ai-sdk/google",
-			"@ai-sdk/devtools"
-		],
-		projectDir: webClientDir
-	});
-	else if (serverDirExists && backend !== "none") await addPackageDependency({
-		dependencies: [
-			"ai",
-			"@ai-sdk/google",
-			"@ai-sdk/devtools"
-		],
-		projectDir: serverDir
-	});
-	if (webClientDirExists) {
-		const dependencies = [];
-		if (backend === "convex") {
-			if (hasReactWeb) dependencies.push("@convex-dev/agent", "streamdown");
-		} else {
-			dependencies.push("ai");
-			if (hasNuxt) dependencies.push("@ai-sdk/vue");
-			else if (hasSvelte) dependencies.push("@ai-sdk/svelte");
-			else if (hasReactWeb) dependencies.push("@ai-sdk/react", "streamdown");
-		}
-		if (dependencies.length > 0) await addPackageDependency({
-			dependencies,
-			projectDir: webClientDir
-		});
+		s.stop("Ultracite setup successfully!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up Ultracite"));
+		if (error instanceof Error) console.error(pc.red(error.message));
 	}
-	if (nativeClientDirExists && hasReactNative) if (backend === "convex") await addPackageDependency({
-		dependencies: ["@convex-dev/agent"],
-		projectDir: nativeClientDir
-	});
-	else await addPackageDependency({
-		dependencies: ["ai", "@ai-sdk/react"],
-		projectDir: nativeClientDir
-	});
 }
 
 //#endregion
-//#region src/helpers/core/api-setup.ts
-function getFrontendType(frontend) {
-	const reactBasedFrontends = [
-		"tanstack-router",
-		"react-router",
-		"tanstack-start",
-		"next"
-	];
-	const nativeFrontends = [
-		"native-bare",
-		"native-uniwind",
-		"native-unistyles"
-	];
-	return {
-		hasReactWeb: frontend.some((f) => reactBasedFrontends.includes(f)),
-		hasNuxtWeb: frontend.includes("nuxt"),
-		hasSvelteWeb: frontend.includes("svelte"),
-		hasSolidWeb: frontend.includes("solid"),
-		hasNative: frontend.some((f) => nativeFrontends.includes(f))
-	};
-}
-function getApiDependencies(api, frontendType, backend) {
-	const deps = {};
-	if (api === "orpc") deps.server = { dependencies: [
-		"@orpc/server",
-		"@orpc/client",
-		"@orpc/openapi",
-		"@orpc/zod"
-	] };
-	else if (api === "trpc") deps.server = { dependencies: ["@trpc/server", "@trpc/client"] };
-	if (backend !== "self" && backend !== "convex" && backend !== "none") {
-		if (!deps.server) deps.server = { dependencies: [] };
-		if (backend === "hono") deps.server.dependencies.push("hono");
-		else if (backend === "elysia") deps.server.dependencies.push("elysia");
-	}
-	if (frontendType.hasReactWeb) {
-		if (api === "orpc") deps.web = { dependencies: [
-			"@orpc/tanstack-query",
-			"@orpc/client",
-			"@orpc/server"
-		] };
-		else if (api === "trpc") deps.web = { dependencies: [
-			"@trpc/tanstack-react-query",
-			"@trpc/client",
-			"@trpc/server"
-		] };
-	} else if (frontendType.hasNuxtWeb && api === "orpc") deps.web = {
-		dependencies: [
-			"@tanstack/vue-query",
-			"@orpc/tanstack-query",
-			"@orpc/client",
-			"@orpc/server"
-		],
-		devDependencies: ["@tanstack/vue-query-devtools"]
-	};
-	else if (frontendType.hasSvelteWeb && api === "orpc") deps.web = {
-		dependencies: [
-			"@orpc/tanstack-query",
-			"@orpc/client",
-			"@orpc/server",
-			"@tanstack/svelte-query"
-		],
-		devDependencies: ["@tanstack/svelte-query-devtools"]
-	};
-	else if (frontendType.hasSolidWeb && api === "orpc") deps.web = {
-		dependencies: [
-			"@orpc/tanstack-query",
-			"@orpc/client",
-			"@orpc/server",
-			"@tanstack/solid-query"
-		],
-		devDependencies: ["@tanstack/solid-query-devtools", "@tanstack/solid-router-devtools"]
-	};
-	if (api === "trpc") deps.native = { dependencies: [
-		"@trpc/tanstack-react-query",
-		"@trpc/client",
-		"@trpc/server"
-	] };
-	else if (api === "orpc") deps.native = { dependencies: ["@orpc/tanstack-query", "@orpc/client"] };
-	return deps;
-}
-function getQueryDependencies(frontend) {
-	const reactBasedFrontends = [
-		"react-router",
-		"tanstack-router",
-		"tanstack-start",
-		"next",
-		"native-bare",
-		"native-uniwind",
-		"native-unistyles"
-	];
-	const deps = {};
-	if (frontend.some((f) => reactBasedFrontends.includes(f))) {
-		const hasReactWeb = frontend.some((f) => f !== "native-bare" && f !== "native-uniwind" && f !== "native-unistyles" && reactBasedFrontends.includes(f));
-		const hasNative = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-		if (hasReactWeb) deps.web = {
-			dependencies: ["@tanstack/react-query"],
-			devDependencies: ["@tanstack/react-query-devtools"]
-		};
-		if (hasNative) deps.native = { dependencies: ["@tanstack/react-query"] };
-	}
-	if (frontend.includes("solid")) deps.web = {
-		dependencies: ["@tanstack/solid-query"],
-		devDependencies: ["@tanstack/solid-query-devtools", "@tanstack/solid-router-devtools"]
-	};
-	return deps;
-}
-function getConvexDependencies(frontend) {
-	const deps = {
-		web: { dependencies: ["convex"] },
-		native: { dependencies: ["convex"] }
-	};
-	if (frontend.includes("tanstack-start")) {
-		deps.web.dependencies.push("@convex-dev/react-query");
-		deps.web.dependencies.push("@tanstack/react-router-ssr-query");
-	}
-	if (frontend.includes("svelte")) deps.web.dependencies.push("convex-svelte");
-	if (frontend.includes("nuxt")) deps.web.dependencies.push("convex-nuxt", "convex-vue");
-	return deps;
-}
-async function setupApi(config) {
-	const { api, frontend, backend, projectDir } = config;
-	const isConvex = backend === "convex";
-	const webDir = path.join(projectDir, "apps/web");
-	const nativeDir = path.join(projectDir, "apps/native");
-	const serverDir = path.join(projectDir, "apps/server");
-	const webDirExists = await fs.pathExists(webDir);
-	const nativeDirExists = await fs.pathExists(nativeDir);
-	await fs.pathExists(serverDir);
-	const frontendType = getFrontendType(frontend);
-	if (!isConvex && api !== "none") {
-		const apiDeps = getApiDependencies(api, frontendType, backend);
-		const apiPackageDir = path.join(projectDir, "packages/api");
-		if (apiDeps.server) {
-			await addPackageDependency({
-				dependencies: apiDeps.server.dependencies,
-				projectDir: apiPackageDir
-			});
-			if (backend === "self" && webDirExists) await addPackageDependency({
-				dependencies: apiDeps.server.dependencies,
-				projectDir: webDir
-			});
-			if (backend === "self") {
-				const frameworkDeps = [];
-				if (frontend.includes("next")) frameworkDeps.push("next");
-				if (frameworkDeps.length > 0) await addPackageDependency({
-					dependencies: frameworkDeps,
-					projectDir: apiPackageDir
-				});
-			}
-		}
-		if (config.auth === "better-auth" && (backend === "express" || backend === "fastify")) await addPackageDependency({
-			dependencies: ["better-auth"],
-			projectDir: apiPackageDir
-		});
-		if (backend === "express") await addPackageDependency({
-			devDependencies: ["@types/express"],
-			projectDir: apiPackageDir
-		});
-		if (webDirExists && apiDeps.web) await addPackageDependency({
-			dependencies: apiDeps.web.dependencies,
-			devDependencies: apiDeps.web.devDependencies,
-			projectDir: webDir
-		});
-		if (nativeDirExists && apiDeps.native) await addPackageDependency({
-			dependencies: apiDeps.native.dependencies,
-			projectDir: nativeDir
-		});
-	}
-	if (!isConvex) {
-		const queryDeps = getQueryDependencies(frontend);
-		if (webDirExists && queryDeps.web) await addPackageDependency({
-			dependencies: queryDeps.web.dependencies,
-			devDependencies: queryDeps.web.devDependencies,
-			projectDir: webDir
-		});
-		if (nativeDirExists && queryDeps.native) await addPackageDependency({
-			dependencies: queryDeps.native.dependencies,
-			projectDir: nativeDir
-		});
+//#region src/helpers/addons/wxt-setup.ts
+const TEMPLATES = {
+	vanilla: {
+		label: "Vanilla",
+		hint: "Vanilla JavaScript template"
+	},
+	vue: {
+		label: "Vue",
+		hint: "Vue.js template"
+	},
+	react: {
+		label: "React",
+		hint: "React template"
+	},
+	solid: {
+		label: "Solid",
+		hint: "SolidJS template"
+	},
+	svelte: {
+		label: "Svelte",
+		hint: "Svelte template"
 	}
-	if (isConvex) {
-		const convexDeps = getConvexDependencies(frontend);
-		if (webDirExists) await addPackageDependency({
-			dependencies: convexDeps.web.dependencies,
-			projectDir: webDir
-		});
-		if (nativeDirExists) await addPackageDependency({
-			dependencies: convexDeps.native.dependencies,
-			projectDir: nativeDir
+};
+async function setupWxt(config) {
+	const { packageManager, projectDir } = config;
+	try {
+		log.info("Setting up WXT...");
+		const template = await select({
+			message: "Choose a template",
+			options: Object.entries(TEMPLATES).map(([key, template$1]) => ({
+				value: key,
+				label: template$1.label,
+				hint: template$1.hint
+			})),
+			initialValue: "react"
 		});
+		if (isCancel(template)) return exitCancelled("Operation cancelled");
+		const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
+		const appsDir = path.join(projectDir, "apps");
+		await fs.ensureDir(appsDir);
+		const s = spinner();
+		s.start("Running WXT init command...");
+		await $({
+			cwd: appsDir,
+			env: { CI: "true" }
+		})`${args}`;
+		const extensionDir = path.join(projectDir, "apps", "extension");
+		const packageJsonPath = path.join(extensionDir, "package.json");
+		if (await fs.pathExists(packageJsonPath)) {
+			const packageJson = await fs.readJson(packageJsonPath);
+			packageJson.name = "extension";
+			if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port 5555`;
+			await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+		}
+		s.stop("WXT setup complete!");
+	} catch (error) {
+		log.error(pc.red("Failed to set up WXT"));
+		if (error instanceof Error) console.error(pc.red(error.message));
 	}
 }
 
 //#endregion
-//#region src/helpers/core/backend-setup.ts
-async function setupBackendDependencies(config) {
-	const { backend, runtime, api, auth, projectDir } = config;
-	if (backend === "convex") {
-		await addPackageDependency({
-			dependencies: ["convex"],
-			projectDir: path.join(projectDir, "packages/backend")
-		});
-		return;
+//#region src/helpers/addons/addons-setup.ts
+async function setupAddons(config) {
+	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("tauri") && (hasReactWebFrontend || hasNuxtFrontend || hasSvelteFrontend || hasSolidFrontend || hasNextFrontend)) await setupTauri(config);
+	const hasUltracite = addons.includes("ultracite");
+	const hasBiome = addons.includes("biome");
+	const hasHusky = addons.includes("husky");
+	const hasOxlint = addons.includes("oxlint");
+	if (!hasUltracite) {
+		if (hasBiome) await setupBiome(projectDir);
+		if (hasOxlint) await setupOxlint(projectDir, config.packageManager);
+		if (hasHusky) {
+			let linter;
+			if (hasOxlint) linter = "oxlint";
+			else if (hasBiome) linter = "biome";
+			await setupHusky(projectDir, linter);
+		}
 	}
-	const framework = backend;
-	const serverDir = path.join(projectDir, "apps/server");
-	const dependencies = [];
-	const devDependencies = [];
-	if (framework === "hono") {
-		dependencies.push("hono");
-		if (runtime === "node") dependencies.push("@hono/node-server");
-	} else if (framework === "elysia") {
-		dependencies.push("elysia", "@elysiajs/cors");
-		if (runtime === "node") dependencies.push("@elysiajs/node");
-	} else if (framework === "express") {
-		dependencies.push("express", "cors");
-		devDependencies.push("@types/express", "@types/cors");
-	} else if (framework === "fastify") dependencies.push("fastify", "@fastify/cors");
-	if (api === "trpc") {
-		dependencies.push("@trpc/server");
-		if (framework === "hono") dependencies.push("@hono/trpc-server");
-		else if (framework === "elysia") dependencies.push("@elysiajs/trpc");
-	} else if (api === "orpc") dependencies.push("@orpc/server", "@orpc/openapi", "@orpc/zod");
-	if (auth === "better-auth") dependencies.push("better-auth");
-	if (runtime === "node") devDependencies.push("tsx", "@types/node");
-	else if (runtime === "bun") devDependencies.push("@types/bun");
-	if (dependencies.length > 0 || devDependencies.length > 0) await addPackageDependency({
-		dependencies,
-		devDependencies,
-		projectDir: serverDir
-	});
+	if (addons.includes("starlight")) await setupStarlight(config);
+	if (addons.includes("fumadocs")) await setupFumadocs(config);
+	if (addons.includes("opentui")) await setupTui(config);
+	if (addons.includes("wxt")) await setupWxt(config);
+	if (hasUltracite) await setupUltracite(config, hasHusky);
+	if (addons.includes("ruler")) await setupRuler(config);
 }
-
-//#endregion
-//#region src/utils/better-auth-plugin-setup.ts
-async function setupBetterAuthPlugins(projectDir, config) {
-	const authIndexPath = `${projectDir}/packages/auth/src/index.ts`;
-	const authIndexFile = tsProject.addSourceFileAtPath(authIndexPath);
-	if (!authIndexFile) return;
-	const pluginsToAdd = [];
-	const importsToAdd = [];
-	if (config.backend === "self" && config.frontend?.includes("tanstack-start")) {
-		pluginsToAdd.push("tanstackStartCookies()");
-		importsToAdd.push("import { tanstackStartCookies } from \"better-auth/tanstack-start\";");
-	}
-	if (config.backend === "self" && config.frontend?.includes("next")) {
-		pluginsToAdd.push("nextCookies()");
-		importsToAdd.push("import { nextCookies } from \"better-auth/next-js\";");
-	}
-	if (config.frontend?.includes("native-bare") || config.frontend?.includes("native-uniwind") || config.frontend?.includes("native-unistyles")) {
-		pluginsToAdd.push("expo()");
-		importsToAdd.push("import { expo } from \"@better-auth/expo\";");
-	}
-	if (pluginsToAdd.length === 0) return;
-	importsToAdd.forEach((importStatement) => {
-		if (!authIndexFile.getImportDeclaration((declaration) => declaration.getModuleSpecifierValue().includes(importStatement.split("\"")[1]))) authIndexFile.insertImportDeclaration(0, {
-			moduleSpecifier: importStatement.split("\"")[1],
-			namedImports: [importStatement.split("{")[1].split("}")[0].trim()]
-		});
+async function setupBiome(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["@biomejs/biome"],
+		projectDir
 	});
-	const betterAuthCall = authIndexFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "betterAuth");
-	if (betterAuthCall) {
-		const configObject = betterAuthCall.getArguments()[0];
-		if (configObject && configObject.getKind() === SyntaxKind.ObjectLiteralExpression) {
-			const pluginsArray = ensureArrayProperty(configObject.asKindOrThrow(SyntaxKind.ObjectLiteralExpression), "plugins");
-			pluginsToAdd.forEach((plugin) => {
-				pluginsArray.addElement(plugin);
-			});
-		}
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			check: "biome check --write ."
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 	}
-	authIndexFile.save();
 }
-
-//#endregion
-//#region src/helpers/core/auth-setup.ts
-async function setupAuth(config) {
-	const { auth, frontend, backend, projectDir } = config;
-	if (!auth || auth === "none") 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);
-	await fs.pathExists(serverDir);
-	try {
-		if (backend === "convex") {
-			if (auth === "clerk" && clientDirExists) {
-				const hasNextJs = frontend.includes("next");
-				const hasTanStackStart = frontend.includes("tanstack-start");
-				const hasViteReactOther = frontend.some((f) => ["tanstack-router", "react-router"].includes(f));
-				if (hasNextJs) await addPackageDependency({
-					dependencies: ["@clerk/nextjs"],
-					projectDir: clientDir
-				});
-				else if (hasTanStackStart) await addPackageDependency({
-					dependencies: ["@clerk/tanstack-react-start", "srvx"],
-					projectDir: clientDir
-				});
-				else if (hasViteReactOther) await addPackageDependency({
-					dependencies: ["@clerk/clerk-react"],
-					projectDir: clientDir
-				});
-			}
-			if (auth === "better-auth") {
-				const convexBackendDir = path.join(projectDir, "packages/backend");
-				const convexBackendDirExists = await fs.pathExists(convexBackendDir);
-				const hasNativeForBA = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-				if (convexBackendDirExists) {
-					await addPackageDependency({
-						dependencies: ["better-auth", "@convex-dev/better-auth"],
-						customDependencies: { "better-auth": "1.4.9" },
-						projectDir: convexBackendDir
-					});
-					if (hasNativeForBA) await addPackageDependency({
-						dependencies: ["@better-auth/expo"],
-						customDependencies: { "@better-auth/expo": "1.4.9" },
-						projectDir: convexBackendDir
-					});
-				}
-				if (clientDirExists) {
-					const hasNextJs = frontend.includes("next");
-					const hasTanStackStart = frontend.includes("tanstack-start");
-					const hasViteReactOther = frontend.some((f) => ["tanstack-router", "react-router"].includes(f));
-					if (hasNextJs) await addPackageDependency({
-						dependencies: ["better-auth", "@convex-dev/better-auth"],
-						customDependencies: { "better-auth": "1.4.9" },
-						projectDir: clientDir
-					});
-					else if (hasTanStackStart) await addPackageDependency({
-						dependencies: ["better-auth", "@convex-dev/better-auth"],
-						customDependencies: { "better-auth": "1.4.9" },
-						projectDir: clientDir
-					});
-					else if (hasViteReactOther) await addPackageDependency({
-						dependencies: ["better-auth", "@convex-dev/better-auth"],
-						customDependencies: { "better-auth": "1.4.9" },
-						projectDir: clientDir
-					});
-				}
-				const hasNativeBare$1 = frontend.includes("native-bare");
-				const hasNativeUniwind$1 = frontend.includes("native-uniwind");
-				const hasUnistyles$1 = frontend.includes("native-unistyles");
-				if (nativeDirExists && (hasNativeBare$1 || hasNativeUniwind$1 || hasUnistyles$1)) await addPackageDependency({
-					dependencies: [
-						"better-auth",
-						"@better-auth/expo",
-						"@convex-dev/better-auth"
-					],
-					customDependencies: {
-						"better-auth": "1.4.9",
-						"@better-auth/expo": "1.4.9"
-					},
-					projectDir: nativeDir
-				});
-			}
-			const hasNativeBare = frontend.includes("native-bare");
-			const hasNativeUniwind = frontend.includes("native-uniwind");
-			const hasUnistyles = frontend.includes("native-unistyles");
-			if (auth === "clerk" && nativeDirExists && (hasNativeBare || hasNativeUniwind || hasUnistyles)) await addPackageDependency({
-				dependencies: ["@clerk/clerk-expo"],
-				projectDir: nativeDir
-			});
-			return;
-		}
-		const authPackageDir = path.join(projectDir, "packages/auth");
-		const authPackageDirExists = await fs.pathExists(authPackageDir);
-		if (authPackageDirExists && auth === "better-auth") await addPackageDependency({
-			dependencies: ["better-auth"],
-			projectDir: authPackageDir
-		});
-		if (frontend.some((f) => [
-			"react-router",
-			"tanstack-router",
-			"tanstack-start",
-			"next",
-			"nuxt",
-			"svelte",
-			"solid"
-		].includes(f)) && clientDirExists) {
-			if (auth === "better-auth") await addPackageDependency({
-				dependencies: ["better-auth"],
-				projectDir: clientDir
-			});
-		}
-		if ((frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles")) && nativeDirExists) {
-			if (auth === "better-auth") {
-				await addPackageDependency({
-					dependencies: ["better-auth", "@better-auth/expo"],
-					projectDir: nativeDir
-				});
-				if (authPackageDirExists) await addPackageDependency({
-					dependencies: ["@better-auth/expo"],
-					projectDir: authPackageDir
-				});
-			}
-		}
-		if (authPackageDirExists && auth === "better-auth") await setupBetterAuthPlugins(projectDir, config);
-	} catch (error) {
-		consola.error(pc.red("Failed to configure authentication dependencies"));
-		if (error instanceof Error) consola.error(pc.red(error.message));
+async function setupHusky(projectDir, linter) {
+	await addPackageDependency({
+		devDependencies: ["husky", "lint-staged"],
+		projectDir
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			prepare: "husky"
+		};
+		if (linter === "oxlint") packageJson["lint-staged"] = { "*": ["oxlint", "oxfmt --write"] };
+		else if (linter === "biome") packageJson["lint-staged"] = { "*.{js,ts,cjs,mjs,d.cts,d.mts,jsx,tsx,json,jsonc}": ["biome check --write ."] };
+		else packageJson["lint-staged"] = { "**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx,vue,astro,svelte}": "" };
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 	}
 }
-function generateAuthSecret(length = 32) {
-	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-	let result = "";
-	const charactersLength = 62;
-	for (let i = 0; i < length; i++) result += characters.charAt(Math.floor(Math.random() * charactersLength));
-	return result;
-}
 
 //#endregion
-//#region src/helpers/core/env-setup.ts
-function getClientServerVar(frontend, backend) {
-	const hasNextJs = frontend.includes("next");
-	const hasNuxt = frontend.includes("nuxt");
-	const hasSvelte = frontend.includes("svelte");
-	const hasTanstackStart = frontend.includes("tanstack-start");
-	if (backend === "self") return {
-		key: "",
-		value: "",
-		write: false
-	};
-	let key = "VITE_SERVER_URL";
-	if (hasNextJs) key = "NEXT_PUBLIC_SERVER_URL";
-	else if (hasNuxt) key = "NUXT_PUBLIC_SERVER_URL";
-	else if (hasSvelte) key = "PUBLIC_SERVER_URL";
-	else if (hasTanstackStart) key = "VITE_SERVER_URL";
-	return {
-		key,
-		value: "http://localhost:3000",
-		write: true
-	};
-}
-function getConvexVar(frontend) {
-	const hasNextJs = frontend.includes("next");
-	const hasNuxt = frontend.includes("nuxt");
-	const hasSvelte = frontend.includes("svelte");
-	const hasTanstackStart = frontend.includes("tanstack-start");
-	if (hasNextJs) return "NEXT_PUBLIC_CONVEX_URL";
-	if (hasNuxt) return "NUXT_PUBLIC_CONVEX_URL";
-	if (hasSvelte) return "PUBLIC_CONVEX_URL";
-	if (hasTanstackStart) return "VITE_CONVEX_URL";
-	return "VITE_CONVEX_URL";
-}
-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, comment } 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 {
-			if (comment) contentToAdd += `# ${comment}\n`;
-			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];
-		if (!new RegExp(`^${key}=.*$`, "m").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, webDeploy, serverDeploy } = 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$1 = hasReactRouter || hasTanStackRouter || hasTanStackStart || hasNextJs || hasNuxt || hasSolid || hasSvelte;
-	if (hasWebFrontend$1) {
-		const clientDir = path.join(projectDir, "apps/web");
-		if (await fs.pathExists(clientDir)) {
-			const baseVar = getClientServerVar(frontend, backend);
-			const clientVars = [{
-				key: backend === "convex" ? getConvexVar(frontend) : baseVar.key,
-				value: backend === "convex" ? "https://<YOUR_CONVEX_URL>" : baseVar.value,
-				condition: backend === "convex" ? true : baseVar.write
-			}];
-			if (backend === "convex" && auth === "clerk") {
-				if (hasNextJs) clientVars.push({
-					key: "NEXT_PUBLIC_CLERK_FRONTEND_API_URL",
-					value: "",
-					condition: true
-				}, {
-					key: "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY",
-					value: "",
-					condition: true
-				}, {
-					key: "CLERK_SECRET_KEY",
-					value: "",
-					condition: true
-				});
-				else if (hasReactRouter || hasTanStackRouter || hasTanStackStart) {
-					clientVars.push({
-						key: "VITE_CLERK_PUBLISHABLE_KEY",
-						value: "",
-						condition: true
-					});
-					if (hasTanStackStart) clientVars.push({
-						key: "CLERK_SECRET_KEY",
-						value: "",
-						condition: true
-					});
-				}
-			}
-			if (backend === "convex" && auth === "better-auth") {
-				if (hasNextJs) clientVars.push({
-					key: "NEXT_PUBLIC_CONVEX_SITE_URL",
-					value: "https://<YOUR_CONVEX_URL>",
-					condition: true
-				});
-				else if (hasReactRouter || hasTanStackRouter || hasTanStackStart) clientVars.push({
-					key: "VITE_CONVEX_SITE_URL",
-					value: "https://<YOUR_CONVEX_URL>",
-					condition: true
-				});
-			}
-			await addEnvVariablesToFile(path.join(clientDir, ".env"), clientVars);
-		}
-	}
-	if (frontend.includes("native-bare") || frontend.includes("native-uniwind") || 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 === "self") serverUrl = "http://localhost:3001";
-			if (backend === "convex") {
-				envVarName = "EXPO_PUBLIC_CONVEX_URL";
-				serverUrl = "https://<YOUR_CONVEX_URL>";
-			}
-			const nativeVars = [{
-				key: envVarName,
-				value: serverUrl,
-				condition: true
-			}];
-			if (backend === "convex" && auth === "clerk") nativeVars.push({
-				key: "EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY",
-				value: "",
-				condition: true
-			});
-			if (backend === "convex" && auth === "better-auth") nativeVars.push({
-				key: "EXPO_PUBLIC_CONVEX_SITE_URL",
-				value: "https://<YOUR_CONVEX_URL>",
-				condition: true
-			});
-			await addEnvVariablesToFile(path.join(nativeDir, ".env"), nativeVars);
-		}
-	}
-	if (backend === "convex") {
-		const convexBackendDir = path.join(projectDir, "packages/backend");
-		if (await fs.pathExists(convexBackendDir)) {
-			const envLocalPath = path.join(convexBackendDir, ".env.local");
-			let commentBlocks = "";
-			if (examples?.includes("ai")) commentBlocks += `# Set Google AI API key for AI agent
-# npx convex env set GOOGLE_GENERATIVE_AI_API_KEY=your_google_api_key
-
-`;
-			if (auth === "better-auth") commentBlocks += `# Set Convex environment variables
-# npx convex env set BETTER_AUTH_SECRET=$(openssl rand -base64 32)
-${hasWebFrontend$1 ? "# npx convex env set SITE_URL http://localhost:3001\n" : ""}`;
-			if (commentBlocks) {
-				let existingContent = "";
-				if (await fs.pathExists(envLocalPath)) existingContent = await fs.readFile(envLocalPath, "utf8");
-				await fs.writeFile(envLocalPath, commentBlocks + existingContent);
-			}
-			const convexBackendVars = [];
-			if (examples?.includes("ai")) convexBackendVars.push({
-				key: "GOOGLE_GENERATIVE_AI_API_KEY",
-				value: "",
-				condition: true,
-				comment: "Google AI API key for AI agent"
-			});
-			if (auth === "better-auth") {
-				const hasNative = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-				const hasWeb = hasWebFrontend$1;
-				if (hasNative) convexBackendVars.push({
-					key: "EXPO_PUBLIC_CONVEX_SITE_URL",
-					value: "",
-					condition: true,
-					comment: "Same as CONVEX_URL but ends in .site"
-				});
-				if (hasWeb) convexBackendVars.push({
-					key: hasNextJs ? "NEXT_PUBLIC_CONVEX_SITE_URL" : "VITE_CONVEX_SITE_URL",
-					value: "",
-					condition: true,
-					comment: "Same as CONVEX_URL but ends in .site"
-				}, {
-					key: "SITE_URL",
-					value: "http://localhost:3001",
-					condition: true,
-					comment: "Web app URL for authentication"
-				});
-			}
-			if (convexBackendVars.length > 0) await addEnvVariablesToFile(envLocalPath, convexBackendVars);
-		}
-		return;
-	}
-	const serverDir = path.join(projectDir, "apps/server");
-	let corsOrigin = "http://localhost:3001";
-	if (backend === "self") corsOrigin = "http://localhost:3001";
-	else if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
-	let databaseUrl = null;
-	if (database !== "none" && dbSetup === "none") 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";
+//#region src/utils/env-utils.ts
+async function addEnvVariablesToFile(envPath, variables) {
+	let content = "";
+	if (fs.existsSync(envPath)) content = await fs.readFile(envPath, "utf-8");
+	else await fs.ensureFile(envPath);
+	const existingLines = content.split("\n");
+	const newLines = [];
+	const keysToAdd = /* @__PURE__ */ new Map();
+	for (const variable of variables) {
+		if (variable.condition === false || !variable.key) continue;
+		keysToAdd.set(variable.key, variable.value);
+	}
+	let foundKeys = /* @__PURE__ */ new Set();
+	for (const line of existingLines) {
+		const trimmedLine = line.trim();
+		let lineProcessed = false;
+		for (const [key, value] of keysToAdd) if (trimmedLine.startsWith(`${key}=`)) {
+			newLines.push(`${key}=${value}`);
+			foundKeys.add(key);
+			lineProcessed = true;
 			break;
-		case "sqlite":
-			if (config.runtime === "workers" || webDeploy === "cloudflare" || serverDeploy === "cloudflare") databaseUrl = "http://127.0.0.1:8080";
-			else {
-				const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
-				databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
-			}
-			break;
-	}
-	const serverVars = [
-		{
-			key: "BETTER_AUTH_SECRET",
-			value: generateAuthSecret(),
-			condition: !!auth
-		},
-		{
-			key: "BETTER_AUTH_URL",
-			value: backend === "self" ? "http://localhost:3001" : "http://localhost:3000",
-			condition: !!auth
-		},
-		{
-			key: "POLAR_ACCESS_TOKEN",
-			value: "",
-			condition: config.payments === "polar"
-		},
-		{
-			key: "POLAR_SUCCESS_URL",
-			value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
-			condition: config.payments === "polar"
-		},
-		{
-			key: "CORS_ORIGIN",
-			value: corsOrigin,
-			condition: true
-		},
-		{
-			key: "GOOGLE_GENERATIVE_AI_API_KEY",
-			value: "",
-			condition: examples?.includes("ai") || false
-		},
-		{
-			key: "DATABASE_URL",
-			value: databaseUrl,
-			condition: database !== "none" && dbSetup === "none"
 		}
-	];
-	if (backend === "self") {
-		const webDir = path.join(projectDir, "apps/web");
-		if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverVars);
-	} else if (await fs.pathExists(serverDir)) await addEnvVariablesToFile(path.join(serverDir, ".env"), serverVars);
-	if (webDeploy === "cloudflare" && serverDeploy === "cloudflare" || webDeploy === "cloudflare" || serverDeploy === "cloudflare") {
-		const infraDir = path.join(projectDir, "packages/infra");
-		if (await fs.pathExists(infraDir)) await addEnvVariablesToFile(path.join(infraDir, ".env"), [{
-			key: "ALCHEMY_PASSWORD",
-			value: "please-change-this",
-			condition: true
-		}]);
+		if (!lineProcessed) newLines.push(line);
 	}
+	for (const [key, value] of keysToAdd) if (!foundKeys.has(key)) newLines.push(`${key}=${value}`);
+	if (newLines.length > 0 && newLines[newLines.length - 1] === "") newLines.pop();
+	if (foundKeys.size > 0 || keysToAdd.size > foundKeys.size) await fs.writeFile(envPath, newLines.join("\n") + "\n");
 }
 
 //#endregion
@@ -6045,106 +3721,23 @@ async function setupTurso(config, cliInput) {
 
 //#endregion
 //#region src/helpers/core/db-setup.ts
+/**
+* Database setup - CLI-only operations
+* Calls external database provider CLIs (turso, neon, prisma-postgres, etc.)
+* Dependencies are handled by the generator's db-deps processor
+*/
 async function setupDatabase(config, cliInput) {
-	const { database, orm, dbSetup, backend, projectDir } = config;
+	const { database, dbSetup, backend, projectDir } = config;
 	if (backend === "convex" || database === "none") {
 		if (backend !== "convex") {
-			const serverDir = path.join(projectDir, "apps/server");
-			const serverDbDir = path.join(serverDir, "src/db");
+			const serverDbDir = path.join(projectDir, "apps/server/src/db");
 			if (await fs.pathExists(serverDbDir)) await fs.remove(serverDbDir);
 		}
 		return;
 	}
 	const dbPackageDir = path.join(projectDir, "packages/db");
-	const webDir = path.join(projectDir, "apps/web");
-	const webDirExists = await fs.pathExists(webDir);
 	if (!await fs.pathExists(dbPackageDir)) return;
 	try {
-		if (orm === "prisma") {
-			if (database === "mongodb") await addPackageDependency({
-				customDependencies: { "@prisma/client": "6.19.0" },
-				customDevDependencies: { prisma: "6.19.0" },
-				projectDir: dbPackageDir
-			});
-			else {
-				const prismaDependencies = ["@prisma/client"];
-				const prismaDevDependencies = ["prisma"];
-				if (database === "mysql" && dbSetup === "planetscale") prismaDependencies.push("@prisma/adapter-planetscale", "@planetscale/database");
-				else if (database === "mysql") prismaDependencies.push("@prisma/adapter-mariadb");
-				else if (database === "sqlite") if (dbSetup === "d1") prismaDependencies.push("@prisma/adapter-d1");
-				else prismaDependencies.push("@prisma/adapter-libsql");
-				else if (database === "postgres") if (dbSetup === "neon") {
-					prismaDependencies.push("@prisma/adapter-neon", "@neondatabase/serverless", "ws");
-					prismaDevDependencies.push("@types/ws");
-				} else if (dbSetup === "prisma-postgres") prismaDependencies.push("@prisma/adapter-pg");
-				else {
-					prismaDependencies.push("@prisma/adapter-pg");
-					prismaDependencies.push("pg");
-					prismaDevDependencies.push("@types/pg");
-				}
-				await addPackageDependency({
-					dependencies: prismaDependencies,
-					devDependencies: prismaDevDependencies,
-					projectDir: dbPackageDir
-				});
-			}
-			if (await fs.pathExists(webDir)) if (database === "mongodb") await addPackageDependency({
-				customDependencies: { "@prisma/client": "6.19.0" },
-				projectDir: webDir
-			});
-			else await addPackageDependency({
-				dependencies: ["@prisma/client"],
-				projectDir: webDir
-			});
-		} else if (orm === "drizzle") {
-			if (database === "sqlite") {
-				await addPackageDependency({
-					dependencies: [
-						"drizzle-orm",
-						"@libsql/client",
-						"libsql"
-					],
-					devDependencies: ["drizzle-kit"],
-					projectDir: dbPackageDir
-				});
-				if (webDirExists) await addPackageDependency({
-					dependencies: ["@libsql/client", "libsql"],
-					projectDir: webDir
-				});
-			} else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
-				dependencies: [
-					"drizzle-orm",
-					"@neondatabase/serverless",
-					"ws"
-				],
-				devDependencies: ["drizzle-kit", "@types/ws"],
-				projectDir: dbPackageDir
-			});
-			else if (dbSetup === "planetscale") await addPackageDependency({
-				dependencies: ["drizzle-orm", "pg"],
-				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: dbPackageDir
-			});
-			else await addPackageDependency({
-				dependencies: ["drizzle-orm", "pg"],
-				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: dbPackageDir
-			});
-			else if (database === "mysql") if (dbSetup === "planetscale") await addPackageDependency({
-				dependencies: ["drizzle-orm", "@planetscale/database"],
-				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
-			});
-			else await addPackageDependency({
-				dependencies: ["drizzle-orm", "mysql2"],
-				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
-			});
-		} else if (orm === "mongoose") await addPackageDependency({
-			dependencies: ["mongoose"],
-			devDependencies: [],
-			projectDir: dbPackageDir
-		});
 		if (dbSetup === "docker") await setupDockerCompose(config);
 		else if (database === "sqlite" && dbSetup === "turso") await setupTurso(config, cliInput);
 		else if (database === "sqlite" && dbSetup === "d1") await setupCloudflareD1(config);
@@ -6153,391 +3746,13 @@ async function setupDatabase(config, cliInput) {
 			else if (dbSetup === "neon") await setupNeonPostgres(config, cliInput);
 			else if (dbSetup === "planetscale") await setupPlanetScale(config);
 			else if (dbSetup === "supabase") await setupSupabase(config, cliInput);
-		} else if (database === "mysql") {
-			if (dbSetup === "planetscale") await setupPlanetScale(config);
-		} else if (database === "mongodb" && dbSetup === "mongodb-atlas") await setupMongoDBAtlas(config, cliInput);
+		} else if (database === "mysql" && dbSetup === "planetscale") await setupPlanetScale(config);
+		else if (database === "mongodb" && dbSetup === "mongodb-atlas") await setupMongoDBAtlas(config, cliInput);
 	} catch (error) {
 		if (error instanceof Error) consola.error(pc.red(error.message));
 	}
 }
 
-//#endregion
-//#region src/helpers/core/runtime-setup.ts
-async function setupRuntime(config) {
-	const { runtime, backend, projectDir } = config;
-	if (backend === "convex" || backend === "self" || runtime === "none") return;
-	const serverDir = path.join(projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
-	if (runtime === "bun") await setupBunRuntime(serverDir, backend);
-	else if (runtime === "node") await setupNodeRuntime(serverDir, backend);
-}
-async function setupBunRuntime(serverDir, _backend) {
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return;
-	const packageJson = await fs.readJson(packageJsonPath);
-	packageJson.scripts = {
-		...packageJson.scripts,
-		dev: "bun run --hot src/index.ts",
-		start: "bun run dist/index.js"
-	};
-	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	await addPackageDependency({
-		devDependencies: ["@types/bun"],
-		projectDir: serverDir
-	});
-}
-async function setupNodeRuntime(serverDir, backend) {
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return;
-	const packageJson = await fs.readJson(packageJsonPath);
-	packageJson.scripts = {
-		...packageJson.scripts,
-		dev: "tsx watch src/index.ts",
-		start: "node dist/index.js"
-	};
-	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	await addPackageDependency({
-		devDependencies: ["tsx", "@types/node"],
-		projectDir: serverDir
-	});
-	if (backend === "hono") await addPackageDependency({
-		dependencies: ["@hono/node-server"],
-		projectDir: serverDir
-	});
-	else if (backend === "elysia") await addPackageDependency({
-		dependencies: ["@elysiajs/node"],
-		projectDir: serverDir
-	});
-}
-
-//#endregion
-//#region src/helpers/core/create-readme.ts
-async function createReadme(projectDir, options) {
-	const readmePath = path.join(projectDir, "README.md");
-	const content = generateReadmeContent(options);
-	try {
-		await fs.writeFile(readmePath, content);
-	} catch (error) {
-		consola.error("Failed to create README.md file:", error);
-	}
-}
-function generateReadmeContent(options) {
-	const { projectName, packageManager, database, auth, addons = [], orm = "drizzle", runtime = "bun", frontend = ["tanstack-router"], backend = "hono", api = "trpc", webDeploy, serverDeploy } = options;
-	const isConvex = backend === "convex";
-	const hasReactRouter = frontend.includes("react-router");
-	const hasNative = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-	const hasSvelte = frontend.includes("svelte");
-	const packageManagerRunCmd = `${packageManager} run`;
-	let webPort = "3001";
-	if (hasReactRouter || hasSvelte) webPort = "5173";
-	const stackDescription = generateStackDescription(frontend, backend, api, isConvex);
-	return `# ${projectName}
-
-This project was created with [Better-T-Stack](https://github.com/AmanVarshney01/create-better-t-stack), a modern TypeScript stack${stackDescription ? ` that combines ${stackDescription}` : ""}.
-
-## Features
-
-${generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api)}
-
-## Getting Started
-
-First, install the dependencies:
-
-\`\`\`bash
-${packageManager} install
-\`\`\`
-${isConvex ? `
-## Convex Setup
-
-This project uses Convex as a backend. You'll need to set up Convex before running the app:
-
-\`\`\`bash
-${packageManagerRunCmd} dev:setup
-\`\`\`
-
-Follow the prompts to create a new Convex project and connect it to your application.${auth === "clerk" ? " See [Convex + Clerk guide](https://docs.convex.dev/auth/clerk) for auth setup." : ""}` : generateDatabaseSetup(database, auth, packageManagerRunCmd, orm, options.dbSetup, options.serverDeploy, options.backend)}
-
-Then, run the development server:
-
-\`\`\`bash
-${packageManagerRunCmd} dev
-\`\`\`
-
-${generateRunningInstructions(frontend, backend, webPort, hasNative, isConvex)}
-${addons.includes("pwa") && hasReactRouter ? "\n## PWA Support with React Router v7\n\nThere is a known compatibility issue between VitePWA and React Router v7.\nSee: https://github.com/vite-pwa/vite-plugin-pwa/issues/809\n" : ""}
-${generateDeploymentCommands(packageManagerRunCmd, webDeploy, serverDeploy)}
-
-## Project Structure
-
-\`\`\`
-${generateProjectStructure(projectName, frontend, backend, addons, isConvex, api, auth)}
-\`\`\`
-
-## Available Scripts
-
-${generateScriptsList(packageManagerRunCmd, database, orm, auth, hasNative, addons, backend, options.dbSetup)}
-`;
-}
-function generateStackDescription(frontend, backend, api, isConvex) {
-	const parts = [];
-	const hasTanstackRouter = frontend.includes("tanstack-router");
-	const hasReactRouter = frontend.includes("react-router");
-	const hasNext = frontend.includes("next");
-	const hasTanstackStart = frontend.includes("tanstack-start");
-	const hasSvelte = frontend.includes("svelte");
-	const hasNuxt = frontend.includes("nuxt");
-	const hasSolid = frontend.includes("solid");
-	if (!(frontend.length === 0 || frontend.includes("none"))) {
-		if (hasTanstackRouter) parts.push("React, TanStack Router");
-		else if (hasReactRouter) parts.push("React, React Router");
-		else if (hasNext) parts.push("Next.js");
-		else if (hasTanstackStart) parts.push("React, TanStack Start");
-		else if (hasSvelte) parts.push("SvelteKit");
-		else if (hasNuxt) parts.push("Nuxt");
-		else if (hasSolid) parts.push("SolidJS");
-	}
-	if (backend !== "none") parts.push(backend[0].toUpperCase() + backend.slice(1));
-	if (!isConvex && api !== "none") parts.push(api.toUpperCase());
-	return parts.length > 0 ? `${parts.join(", ")}, and more` : "";
-}
-function generateRunningInstructions(frontend, backend, webPort, hasNative, isConvex) {
-	const instructions = [];
-	const hasFrontendNone = frontend.length === 0 || frontend.includes("none");
-	const isBackendNone = backend === "none";
-	const isBackendSelf = backend === "self";
-	if (!hasFrontendNone) {
-		const hasTanstackRouter = frontend.includes("tanstack-router");
-		const hasReactRouter = frontend.includes("react-router");
-		const hasNext = frontend.includes("next");
-		const hasTanstackStart = frontend.includes("tanstack-start");
-		const hasSvelte = frontend.includes("svelte");
-		const hasNuxt = frontend.includes("nuxt");
-		const hasSolid = frontend.includes("solid");
-		if (hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid) if (isBackendSelf) instructions.push(`Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see your fullstack application.`);
-		else instructions.push(`Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see the web application.`);
-	}
-	if (hasNative) instructions.push("Use the Expo Go app to run the mobile application.");
-	if (isConvex) instructions.push("Your app will connect to the Convex cloud backend automatically.");
-	else if (!isBackendNone && !isBackendSelf) instructions.push("The API is running at [http://localhost:3000](http://localhost:3000).");
-	return instructions.join("\n");
-}
-function generateProjectStructure(projectName, frontend, backend, addons, isConvex, api, auth) {
-	const structure = [`${projectName}/`, "├── apps/"];
-	const hasFrontendNone = frontend.length === 0 || frontend.includes("none");
-	const isBackendNone = backend === "none";
-	const isBackendSelf = backend === "self";
-	if (!hasFrontendNone) {
-		const hasTanstackRouter = frontend.includes("tanstack-router");
-		const hasReactRouter = frontend.includes("react-router");
-		const hasNext = frontend.includes("next");
-		const hasTanstackStart = frontend.includes("tanstack-start");
-		const hasSvelte = frontend.includes("svelte");
-		const hasNuxt = frontend.includes("nuxt");
-		const hasSolid = frontend.includes("solid");
-		if (hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid) {
-			let frontendType = "";
-			if (hasTanstackRouter) frontendType = "React + TanStack Router";
-			else if (hasReactRouter) frontendType = "React + React Router";
-			else if (hasNext) frontendType = "Next.js";
-			else if (hasTanstackStart) frontendType = "React + TanStack Start";
-			else if (hasSvelte) frontendType = "SvelteKit";
-			else if (hasNuxt) frontendType = "Nuxt";
-			else if (hasSolid) frontendType = "SolidJS";
-			if (isBackendSelf) structure.push(`│   └── web/         # Fullstack application (${frontendType})`);
-			else structure.push(`│   ├── web/         # Frontend application (${frontendType})`);
-		}
-	}
-	if (frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles")) if (isBackendSelf) structure.push("│   ├── native/      # Mobile application (React Native, Expo)");
-	else structure.push("│   ├── native/      # Mobile application (React Native, Expo)");
-	if (addons.includes("starlight")) if (isBackendSelf) structure.push("│   ├── docs/        # Documentation site (Astro Starlight)");
-	else structure.push("│   ├── docs/        # Documentation site (Astro Starlight)");
-	if (!isBackendSelf && !isBackendNone && !isConvex) {
-		const backendName = backend[0].toUpperCase() + backend.slice(1);
-		const apiName = api !== "none" ? api.toUpperCase() : "";
-		const backendDesc = apiName ? `${backendName}, ${apiName}` : backendName;
-		structure.push(`│   └── server/      # Backend API (${backendDesc})`);
-	}
-	if (isConvex || !isBackendNone) {
-		structure.push("├── packages/");
-		if (isConvex) {
-			structure.push("│   ├── backend/     # Convex backend functions and schema");
-			if (auth === "clerk") structure.push("│   │   ├── convex/    # Convex functions and schema", "│   │   └── .env.local # Convex environment variables");
-		}
-		if (!isConvex) {
-			structure.push("│   ├── api/         # API layer / business logic");
-			if (auth !== "none") structure.push("│   ├── auth/        # Authentication configuration & logic");
-			if (api !== "none" || auth !== "none") structure.push("│   └── db/          # Database schema & queries");
-		}
-	}
-	return structure.join("\n");
-}
-function generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api) {
-	const isConvex = backend === "convex";
-	const isBackendNone = backend === "none";
-	const hasTanstackRouter = frontend.includes("tanstack-router");
-	const hasReactRouter = frontend.includes("react-router");
-	const hasNative = frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
-	const hasNext = frontend.includes("next");
-	const hasTanstackStart = frontend.includes("tanstack-start");
-	const hasSvelte = frontend.includes("svelte");
-	const hasNuxt = frontend.includes("nuxt");
-	const hasSolid = frontend.includes("solid");
-	const hasFrontendNone = frontend.length === 0 || frontend.includes("none");
-	const addonsList = ["- **TypeScript** - For type safety and improved developer experience"];
-	if (!hasFrontendNone) {
-		if (hasTanstackRouter) addonsList.push("- **TanStack Router** - File-based routing with full type safety");
-		else if (hasReactRouter) addonsList.push("- **React Router** - Declarative routing for React");
-		else if (hasNext) addonsList.push("- **Next.js** - Full-stack React framework");
-		else if (hasTanstackStart) addonsList.push("- **TanStack Start** - SSR framework with TanStack Router");
-		else if (hasSvelte) addonsList.push("- **SvelteKit** - Web framework for building Svelte apps");
-		else if (hasNuxt) addonsList.push("- **Nuxt** - The Intuitive Vue Framework");
-		else if (hasSolid) addonsList.push("- **SolidJS** - Simple and performant reactivity");
-	}
-	if (hasNative) {
-		addonsList.push("- **React Native** - Build mobile apps using React");
-		addonsList.push("- **Expo** - Tools for React Native development");
-	}
-	if (!hasFrontendNone) addonsList.push("- **TailwindCSS** - Utility-first CSS for rapid UI development", "- **shadcn/ui** - Reusable UI components");
-	if (isConvex) addonsList.push("- **Convex** - Reactive backend-as-a-service platform");
-	else if (!isBackendNone) {
-		if (backend === "hono") addonsList.push("- **Hono** - Lightweight, performant server framework");
-		else if (backend === "express") addonsList.push("- **Express** - Fast, unopinionated web framework");
-		else if (backend === "fastify") addonsList.push("- **Fastify** - Fast, low-overhead web framework");
-		else if (backend === "elysia") addonsList.push("- **Elysia** - Type-safe, high-performance framework");
-		if (api === "trpc") addonsList.push("- **tRPC** - End-to-end type-safe APIs");
-		else if (api === "orpc") addonsList.push("- **oRPC** - End-to-end type-safe APIs with OpenAPI integration");
-		if (runtime !== "none") addonsList.push(`- **${runtime === "bun" ? "Bun" : runtime === "node" ? "Node.js" : runtime}** - Runtime environment`);
-	}
-	if (database !== "none" && !isConvex) {
-		const ormName = orm === "drizzle" ? "Drizzle" : orm === "prisma" ? "Prisma" : orm === "mongoose" ? "Mongoose" : "ORM";
-		const dbName = database === "sqlite" ? "SQLite/Turso" : database === "postgres" ? "PostgreSQL" : database === "mysql" ? "MySQL" : database === "mongodb" ? "MongoDB" : "Database";
-		addonsList.push(`- **${ormName}** - TypeScript-first ORM`, `- **${dbName}** - Database engine`);
-	}
-	if (auth !== "none") {
-		const authLabel = auth === "clerk" ? "Clerk" : "Better-Auth";
-		addonsList.push(`- **Authentication** - ${authLabel}`);
-	}
-	for (const addon of addons) if (addon === "pwa") addonsList.push("- **PWA** - Progressive Web App support");
-	else if (addon === "tauri") addonsList.push("- **Tauri** - Build native desktop applications");
-	else if (addon === "biome") addonsList.push("- **Biome** - Linting and formatting");
-	else if (addon === "oxlint") addonsList.push("- **Oxlint** - Oxlint + Oxfmt (linting & formatting)");
-	else if (addon === "husky") addonsList.push("- **Husky** - Git hooks for code quality");
-	else if (addon === "starlight") addonsList.push("- **Starlight** - Documentation site with Astro");
-	else if (addon === "turborepo") addonsList.push("- **Turborepo** - Optimized monorepo build system");
-	return addonsList.join("\n");
-}
-function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSetup, _serverDeploy, backend) {
-	if (database === "none") return "";
-	const isBackendSelf = backend === "self";
-	const envPath = isBackendSelf ? "apps/web/.env" : "apps/server/.env";
-	let setup = "## Database Setup\n\n";
-	if (database === "sqlite") setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
-
- 1. Start the local SQLite database (optional):
-${dbSetup === "d1" ? "D1 local development and migrations are handled automatically by Alchemy during dev and deploy." : `\`\`\`bash
-${packageManagerRunCmd} db:local
-\`\`\``}
-
-2. Update your \`.env\` file in the \`${isBackendSelf ? "apps/web" : "apps/server"}\` directory with the appropriate connection details if needed.
-`;
-	else if (database === "postgres") setup += `This project uses PostgreSQL${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
-
-1. Make sure you have a PostgreSQL database set up.
-2. Update your \`${envPath}\` file with your PostgreSQL connection details.
-`;
-	else if (database === "mysql") setup += `This project uses MySQL${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
-
-1. Make sure you have a MySQL database set up.
-2. Update your \`${envPath}\` file with your MySQL connection details.
-`;
-	else if (database === "mongodb") setup += `This project uses MongoDB ${orm === "mongoose" ? "with Mongoose" : orm === "prisma" ? "with Prisma ORM" : `with ${orm}`}.
-
-1. Make sure you have MongoDB set up.
-2. Update your \`${envPath}\` file with your MongoDB connection URI.
-`;
-	setup += `
-3. ${orm === "prisma" ? `Generate the Prisma client and push the schema:
-\`\`\`bash
-${packageManagerRunCmd} db:push
-\`\`\`` : orm === "drizzle" ? `Apply the schema to your database:
-\`\`\`bash
-${packageManagerRunCmd} db:push
-\`\`\`` : `Apply the schema to your database:
-\`\`\`bash
-${packageManagerRunCmd} db:push
-\`\`\``}
-`;
-	return setup;
-}
-function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNative, addons, backend, dbSetup) {
-	const isConvex = backend === "convex";
-	const isBackendNone = backend === "none";
-	const isBackendSelf = backend === "self";
-	let scripts = `- \`${packageManagerRunCmd} dev\`: Start all applications in development mode
-- \`${packageManagerRunCmd} build\`: Build all applications`;
-	if (!isBackendSelf) scripts += `
-- \`${packageManagerRunCmd} dev:web\`: Start only the web application`;
-	if (isConvex) scripts += `
-- \`${packageManagerRunCmd} dev:setup\`: Setup and configure your Convex project`;
-	else if (!isBackendNone && !isBackendSelf) scripts += `
-- \`${packageManagerRunCmd} dev:server\`: Start only the server`;
-	scripts += `
-- \`${packageManagerRunCmd} check-types\`: Check TypeScript types across all apps`;
-	if (hasNative) scripts += `
-- \`${packageManagerRunCmd} dev:native\`: Start the React Native/Expo development server`;
-	if (database !== "none" && !isConvex) {
-		scripts += `
-- \`${packageManagerRunCmd} db:push\`: Push schema changes to database
-- \`${packageManagerRunCmd} db:studio\`: Open database studio UI`;
-		if (database === "sqlite" && dbSetup !== "d1") scripts += `
-- \`${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
-	}
-	if (addons.includes("biome")) scripts += `
-- \`${packageManagerRunCmd} check\`: Run Biome formatting and linting`;
-	if (addons.includes("oxlint")) scripts += `
-- \`${packageManagerRunCmd} check\`: Run Oxlint and Oxfmt`;
-	if (addons.includes("pwa")) scripts += `
-- \`cd apps/web && ${packageManagerRunCmd} generate-pwa-assets\`: Generate PWA assets`;
-	if (addons.includes("tauri")) scripts += `
-- \`cd apps/web && ${packageManagerRunCmd} desktop:dev\`: Start Tauri desktop app in development
-- \`cd apps/web && ${packageManagerRunCmd} desktop:build\`: Build Tauri desktop app`;
-	if (addons.includes("starlight")) scripts += `
-- \`cd apps/docs && ${packageManagerRunCmd} dev\`: Start documentation site
-- \`cd apps/docs && ${packageManagerRunCmd} build\`: Build documentation site`;
-	return scripts;
-}
-function generateDeploymentCommands(packageManagerRunCmd, webDeploy, serverDeploy) {
-	const lines = [];
-	if (webDeploy === "cloudflare" || serverDeploy === "cloudflare") {
-		lines.push("## Deployment (Cloudflare via Alchemy)");
-		if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") lines.push(`- Web dev: cd apps/web && ${packageManagerRunCmd} dev`, `- Web deploy: cd apps/web && ${packageManagerRunCmd} deploy`, `- Web destroy: cd apps/web && ${packageManagerRunCmd} destroy`);
-		if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`, `- Server destroy: cd apps/server && ${packageManagerRunCmd} destroy`);
-		if (webDeploy === "cloudflare" && serverDeploy === "cloudflare") lines.push(`- Dev: ${packageManagerRunCmd} dev`, `- Deploy: ${packageManagerRunCmd} deploy`, `- Destroy: ${packageManagerRunCmd} destroy`);
-		lines.push("", "For more details, see the guide on [Deploying to Cloudflare with Alchemy](https://www.better-t-stack.dev/docs/guides/cloudflare-alchemy).");
-	}
-	return lines.length ? `${lines.join("\n")}\n` : "";
-}
-
-//#endregion
-//#region src/helpers/core/env-package-setup.ts
-async function setupEnvPackageDependencies(projectDir, options) {
-	const envDir = path.join(projectDir, "packages/env");
-	if (!await fs.pathExists(envDir)) return;
-	await addPackageDependency({
-		dependencies: getT3EnvDeps(options),
-		projectDir: envDir
-	});
-}
-function getT3EnvDeps(options) {
-	const deps = ["zod"];
-	const { frontend, backend, runtime } = options;
-	if (frontend.includes("next")) deps.push("@t3-oss/env-nextjs");
-	else if (frontend.includes("nuxt")) deps.push("@t3-oss/env-nuxt");
-	else deps.push("@t3-oss/env-core");
-	if (backend !== "convex" && backend !== "none" && runtime !== "workers" && !deps.includes("@t3-oss/env-core")) deps.push("@t3-oss/env-core");
-	return deps;
-}
-
 //#endregion
 //#region src/helpers/core/git.ts
 async function initializeGit(projectDir, useGit) {
@@ -6561,44 +3776,19 @@ async function initializeGit(projectDir, useGit) {
 }
 
 //#endregion
-//#region src/helpers/core/infra-package-setup.ts
-async function setupInfraPackageDependencies(projectDir, _options) {
-	const infraDir = path.join(projectDir, "packages/infra");
-	if (!await fs.pathExists(infraDir)) return;
-	await addPackageDependency({
-		devDependencies: ["alchemy"],
-		projectDir: infraDir
-	});
-}
-
-//#endregion
-//#region src/helpers/core/payments-setup.ts
-async function setupPayments(config) {
-	const { payments, projectDir, frontend } = config;
-	if (!payments || payments === "none") return;
-	const clientDir = path.join(projectDir, "apps/web");
-	const authDir = path.join(projectDir, "packages/auth");
-	const clientDirExists = await fs.pathExists(clientDir);
-	const authDirExists = await fs.pathExists(authDir);
-	if (payments === "polar") {
-		if (authDirExists) await addPackageDependency({
-			dependencies: ["@polar-sh/better-auth", "@polar-sh/sdk"],
-			projectDir: authDir
-		});
-		if (clientDirExists) {
-			if (frontend.some((f) => [
-				"react-router",
-				"tanstack-router",
-				"tanstack-start",
-				"next",
-				"nuxt",
-				"svelte",
-				"solid"
-			].includes(f))) await addPackageDependency({
-				dependencies: ["@polar-sh/better-auth"],
-				projectDir: clientDir
-			});
-		}
+//#region src/helpers/core/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}`));
 	}
 }
 
@@ -6817,375 +4007,24 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend)
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
-//#endregion
-//#region src/helpers/core/workspace-setup.ts
-async function setupWorkspaceDependencies(projectDir, options) {
-	const { projectName, packageManager, runtime, backend } = options;
-	const workspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
-	const packages = await detectPackages(projectDir);
-	const configDep = packages.config.exists ? { [`@${projectName}/config`]: workspaceVersion } : {};
-	const envDep = packages.env.exists ? { [`@${projectName}/env`]: workspaceVersion } : {};
-	const ctx = {
-		projectName,
-		workspaceVersion,
-		options,
-		commonDeps: ["dotenv", "zod"],
-		commonDevDeps: ["typescript"],
-		configDep,
-		envDep
-	};
-	await Promise.all([
-		setupEnvPackage(packages.env, packages.infra, ctx),
-		setupInfraPackage(packages.infra, ctx),
-		setupDbPackage(packages.db, ctx),
-		setupAuthPackage(packages.auth, packages.db, ctx),
-		setupApiPackage(packages.api, packages.auth, packages.db, ctx),
-		setupBackendPackage(packages.backend, ctx),
-		setupServerPackage(packages.server, packages.api, packages.auth, packages.db, ctx),
-		setupWebPackage(packages.web, packages.api, packages.auth, packages.backend, ctx),
-		setupNativePackage(packages.native, packages.api, packages.backend, ctx)
-	]);
-	const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: [...ctx.commonDevDeps, ...runtimeDevDeps],
-		customDependencies: envDep,
-		customDevDependencies: configDep,
-		projectDir
-	});
-}
-async function detectPackages(projectDir) {
-	const entries = await Promise.all(Object.entries({
-		config: "packages/config",
-		env: "packages/env",
-		infra: "packages/infra",
-		db: "packages/db",
-		auth: "packages/auth",
-		api: "packages/api",
-		backend: "packages/backend",
-		server: "apps/server",
-		web: "apps/web",
-		native: "apps/native"
-	}).map(async ([name, relativePath]) => {
-		const dir = path.join(projectDir, relativePath);
-		return [name, {
-			dir,
-			exists: await fs.pathExists(dir)
-		}];
-	}));
-	return Object.fromEntries(entries);
-}
-async function setupEnvPackage(pkg, infraPkg, ctx) {
-	if (!pkg.exists) return;
-	const runtimeDevDeps = getRuntimeDevDeps(ctx.options.runtime, ctx.options.backend);
-	const customDevDeps = { ...ctx.configDep };
-	if ((ctx.options.serverDeploy === "cloudflare" || ctx.options.webDeploy === "cloudflare") && infraPkg.exists) customDevDeps[`@${ctx.projectName}/infra`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: [...ctx.commonDevDeps, ...runtimeDevDeps],
-		customDevDependencies: customDevDeps,
-		projectDir: pkg.dir
-	});
-}
-async function setupInfraPackage(pkg, ctx) {
-	if (!pkg.exists) return;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupDbPackage(pkg, ctx) {
-	if (!pkg.exists) return;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDependencies: ctx.envDep,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupAuthPackage(pkg, dbPkg, ctx) {
-	if (!pkg.exists) return;
-	const deps = { ...ctx.envDep };
-	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDependencies: deps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupApiPackage(pkg, authPkg, dbPkg, ctx) {
-	if (!pkg.exists) return;
-	const deps = { ...ctx.envDep };
-	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
-	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDependencies: deps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupBackendPackage(pkg, ctx) {
-	if (!pkg.exists) return;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupServerPackage(pkg, apiPkg, authPkg, dbPkg, ctx) {
-	if (!pkg.exists) return;
-	const deps = { ...ctx.envDep };
-	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
-	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
-	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: [...ctx.commonDevDeps, "tsdown"],
-		customDependencies: deps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupWebPackage(pkg, apiPkg, authPkg, backendPkg, ctx) {
-	if (!pkg.exists) return;
-	const deps = { ...ctx.envDep };
-	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
-	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
-	if (ctx.options.backend === "convex" && backendPkg.exists) deps[`@${ctx.projectName}/backend`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDependencies: deps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-async function setupNativePackage(pkg, apiPkg, backendPkg, ctx) {
-	if (!pkg.exists) return;
-	const deps = { ...ctx.envDep };
-	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
-	if (ctx.options.backend === "convex" && backendPkg.exists) deps[`@${ctx.projectName}/backend`] = ctx.workspaceVersion;
-	await addPackageDependency({
-		dependencies: ctx.commonDeps,
-		devDependencies: ctx.commonDevDeps,
-		customDependencies: deps,
-		customDevDependencies: ctx.configDep,
-		projectDir: pkg.dir
-	});
-}
-function getRuntimeDevDeps(runtime, backend) {
-	if (runtime === "none" && backend === "self") return ["@types/node"];
-	if (runtime === "node" || runtime === "workers") return ["@types/node"];
-	if (runtime === "bun") return ["@types/bun"];
-	return [];
-}
-
-//#endregion
-//#region src/helpers/core/project-config.ts
-async function updatePackageConfigurations(projectDir, options) {
-	await updateRootPackageJson(projectDir, options);
-	if (options.backend === "convex") await updateConvexPackageJson(projectDir, options);
-	else if (options.backend !== "none") {
-		await updateDbPackageJson(projectDir, options);
-		await updateAuthPackageJson(projectDir, options);
-		await updateApiPackageJson(projectDir, options);
-		if (options.backend !== "self") await updateServerPackageJson(projectDir, options);
-	}
-	await setupWorkspaceDependencies(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;
-	packageJson.scripts = packageJson.scripts || {};
-	packageJson.workspaces = packageJson.workspaces || [];
-	const scripts = packageJson.scripts;
-	const workspaces = packageJson.workspaces;
-	const { projectName, packageManager, backend, database, orm, dbSetup, serverDeploy, addons } = options;
-	const backendPackageName = backend === "convex" ? `@${projectName}/backend` : "server";
-	const dbPackageName = `@${projectName}/db`;
-	const hasTurborepo = addons.includes("turborepo");
-	const needsDbScripts = backend !== "convex" && database !== "none" && orm !== "none" && orm !== "mongoose";
-	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "cloudflare";
-	const pmConfig = getPackageManagerConfig(packageManager, hasTurborepo);
-	scripts.dev = pmConfig.dev;
-	scripts.build = pmConfig.build;
-	scripts["check-types"] = pmConfig.checkTypes;
-	scripts["dev:native"] = pmConfig.filter("native", "dev");
-	scripts["dev:web"] = pmConfig.filter("web", "dev");
-	if (backend !== "self" && backend !== "none") scripts["dev:server"] = pmConfig.filter(backendPackageName, "dev");
-	if (backend === "convex") scripts["dev:setup"] = pmConfig.filter(backendPackageName, "dev:setup");
-	if (needsDbScripts) {
-		scripts["db:push"] = pmConfig.filter(dbPackageName, "db:push");
-		if (!isD1Alchemy) scripts["db:studio"] = pmConfig.filter(dbPackageName, "db:studio");
-		if (orm === "prisma") {
-			scripts["db:generate"] = pmConfig.filter(dbPackageName, "db:generate");
-			scripts["db:migrate"] = pmConfig.filter(dbPackageName, "db:migrate");
-		} else if (orm === "drizzle") {
-			scripts["db:generate"] = pmConfig.filter(dbPackageName, "db:generate");
-			if (!isD1Alchemy) scripts["db:migrate"] = pmConfig.filter(dbPackageName, "db:migrate");
-		}
-	}
-	if (database === "sqlite" && dbSetup !== "d1") scripts["db:local"] = pmConfig.filter(dbPackageName, "db:local");
-	if (dbSetup === "docker") {
-		scripts["db:start"] = pmConfig.filter(dbPackageName, "db:start");
-		scripts["db:watch"] = pmConfig.filter(dbPackageName, "db:watch");
-		scripts["db:stop"] = pmConfig.filter(dbPackageName, "db:stop");
-		scripts["db:down"] = pmConfig.filter(dbPackageName, "db:down");
-	}
-	try {
-		const { stdout } = await $`${packageManager} -v`;
-		packageJson.packageManager = `${packageManager}@${stdout.trim()}`;
-	} catch {
-		log.warn(`Could not determine ${packageManager} version.`);
-	}
-	if (backend === "convex") {
-		if (!workspaces.includes("packages/*")) workspaces.push("packages/*");
-		if ((options.frontend.length > 0 || addons.includes("starlight")) && !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 });
-}
-function getPackageManagerConfig(packageManager, hasTurborepo) {
-	if (hasTurborepo) return {
-		dev: "turbo dev",
-		build: "turbo build",
-		checkTypes: "turbo check-types",
-		filter: (workspace, script) => `turbo -F ${workspace} ${script}`
-	};
-	switch (packageManager) {
-		case "pnpm": return {
-			dev: "pnpm -r dev",
-			build: "pnpm -r build",
-			checkTypes: "pnpm -r check-types",
-			filter: (workspace, script) => `pnpm --filter ${workspace} ${script}`
-		};
-		case "npm": return {
-			dev: "npm run dev --workspaces",
-			build: "npm run build --workspaces",
-			checkTypes: "npm run check-types --workspaces",
-			filter: (workspace, script) => `npm run ${script} --workspace ${workspace}`
-		};
-		case "bun": return {
-			dev: "bun run --filter '*' dev",
-			build: "bun run --filter '*' build",
-			checkTypes: "bun run --filter '*' check-types",
-			filter: (workspace, script) => `bun run --filter ${workspace} ${script}`
-		};
-	}
-}
-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);
-	serverPackageJson.scripts = serverPackageJson.scripts || {};
-	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
-}
-async function updateDbPackageJson(projectDir, options) {
-	const dbPackageJsonPath = path.join(projectDir, "packages/db/package.json");
-	if (!await fs.pathExists(dbPackageJsonPath)) return;
-	const dbPackageJson = await fs.readJson(dbPackageJsonPath);
-	dbPackageJson.name = `@${options.projectName}/db`;
-	dbPackageJson.scripts = dbPackageJson.scripts || {};
-	const scripts = dbPackageJson.scripts;
-	const { database, orm, dbSetup, serverDeploy } = options;
-	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "cloudflare";
-	if (database !== "none") {
-		if (database === "sqlite" && dbSetup !== "d1") scripts["db:local"] = "turso dev --db-file local.db";
-		if (orm === "prisma") {
-			scripts["db:push"] = "prisma db push";
-			scripts["db:generate"] = "prisma generate";
-			scripts["db:migrate"] = "prisma migrate dev";
-			if (!isD1Alchemy) scripts["db:studio"] = "prisma studio";
-		} else if (orm === "drizzle") {
-			scripts["db:push"] = "drizzle-kit push";
-			scripts["db:generate"] = "drizzle-kit generate";
-			if (!isD1Alchemy) {
-				scripts["db:studio"] = "drizzle-kit studio";
-				scripts["db:migrate"] = "drizzle-kit migrate";
-			}
-		}
-	}
-	if (dbSetup === "docker") {
-		scripts["db:start"] = "docker compose up -d";
-		scripts["db:watch"] = "docker compose up";
-		scripts["db:stop"] = "docker compose stop";
-		scripts["db:down"] = "docker compose down";
-	}
-	await fs.writeJson(dbPackageJsonPath, dbPackageJson, { spaces: 2 });
-}
-async function updateAuthPackageJson(projectDir, options) {
-	const authPackageJsonPath = path.join(projectDir, "packages/auth/package.json");
-	if (!await fs.pathExists(authPackageJsonPath)) return;
-	const authPackageJson = await fs.readJson(authPackageJsonPath);
-	authPackageJson.name = `@${options.projectName}/auth`;
-	await fs.writeJson(authPackageJsonPath, authPackageJson, { spaces: 2 });
-}
-async function updateApiPackageJson(projectDir, options) {
-	const apiPackageJsonPath = path.join(projectDir, "packages/api/package.json");
-	if (!await fs.pathExists(apiPackageJsonPath)) return;
-	const apiPackageJson = await fs.readJson(apiPackageJsonPath);
-	apiPackageJson.name = `@${options.projectName}/api`;
-	await fs.writeJson(apiPackageJsonPath, apiPackageJson, { 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`;
-	convexPackageJson.scripts = convexPackageJson.scripts || {};
-	await fs.writeJson(convexPackageJsonPath, convexPackageJson, { spaces: 2 });
-}
-
 //#endregion
 //#region src/helpers/core/create-project.ts
 async function createProject(options, cliInput = {}) {
 	const projectDir = options.projectDir;
 	const isConvex = options.backend === "convex";
-	const isSelfBackend = options.backend === "self";
-	const needsServerSetup = !isConvex && !isSelfBackend;
 	try {
 		await fs.ensureDir(projectDir);
-		await copyBaseTemplate(projectDir, options);
-		await setupFrontendTemplates(projectDir, options);
-		await setupBackendFramework(projectDir, options);
-		if (needsServerSetup || isSelfBackend && options.dbSetup === "docker") await setupDockerComposeTemplates(projectDir, options);
-		await setupAuthTemplate(projectDir, options);
-		if (options.payments && options.payments !== "none") await setupPaymentsTemplate(projectDir, options);
-		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);
-		await setupAddonsTemplate(projectDir, options);
-		await setupDeploymentTemplates(projectDir, options);
-		await setupEnvPackageDependencies(projectDir, options);
-		if (options.serverDeploy === "cloudflare" || options.webDeploy === "cloudflare") await setupInfraPackageDependencies(projectDir, options);
-		await setupApi(options);
-		if (isConvex || needsServerSetup) await setupBackendDependencies(options);
-		if (!isConvex) {
-			if (needsServerSetup) await setupRuntime(options);
-			await setupDatabase(options, cliInput);
-		}
-		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamples(options);
+		const result = await generateVirtualProject({
+			config: options,
+			templates: EMBEDDED_TEMPLATES
+		});
+		if (!result.success || !result.tree) throw new Error(result.error || "Failed to generate project templates");
+		await writeTreeToFilesystem(result.tree, projectDir);
+		await setPackageManagerVersion(projectDir, options.packageManager);
+		if (!isConvex && options.database !== "none") await setupDatabase(options, cliInput);
 		if (options.addons.length > 0 && options.addons[0] !== "none") await setupAddons(options);
-		if (options.auth && options.auth !== "none") await setupAuth(options);
-		if (options.payments && options.payments !== "none") await setupPayments(options);
-		await handleExtras(projectDir, options);
-		await setupEnvironmentVariables(options);
-		await updatePackageConfigurations(projectDir, options);
-		await setupWebDeploy(options);
-		await setupServerDeploy(options);
-		await setupCatalogs(projectDir, options);
-		await createReadme(projectDir, options);
 		await writeBtsConfig(options);
+		await formatProject(projectDir);
 		if (!isSilent()) log.success("Project template successfully scaffolded!");
 		if (options.install) await installDependencies({
 			projectDir,
@@ -7207,6 +4046,21 @@ async function createProject(options, cliInput = {}) {
 		}
 	}
 }
+async function setPackageManagerVersion(projectDir, packageManager) {
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(pkgJsonPath)) return;
+	try {
+		const { stdout } = await $`${packageManager} -v`;
+		const version = stdout.trim();
+		const pkgJson = await fs.readJson(pkgJsonPath);
+		pkgJson.packageManager = `${packageManager}@${version}`;
+		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	} catch {
+		const pkgJson = await fs.readJson(pkgJsonPath);
+		delete pkgJson.packageManager;
+		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	}
+}
 
 //#endregion
 //#region src/helpers/core/command-handlers.ts
@@ -7412,68 +4266,6 @@ async function handleDirectoryConflictProgrammatically(currentPathInput, strateg
 		default: throw new Error(`Unknown directory conflict strategy: ${strategy}`);
 	}
 }
-async function addAddonsHandler(input) {
-	try {
-		const projectDir = input.projectDir || process.cwd();
-		const detectedConfig = await detectProjectConfig(projectDir);
-		if (!detectedConfig) exitWithError("Could not detect project configuration. Please ensure this is a valid Better-T-Stack project.");
-		if (!input.addons || input.addons.length === 0) {
-			const addonsPrompt = await getAddonsToAdd(detectedConfig.frontend || [], detectedConfig.addons || [], detectedConfig.auth);
-			if (addonsPrompt.length > 0) input.addons = addonsPrompt;
-		}
-		if (!input.webDeploy) {
-			const deploymentPrompt = await getDeploymentToAdd(detectedConfig.frontend || [], detectedConfig.webDeploy);
-			if (deploymentPrompt !== "none") input.webDeploy = deploymentPrompt;
-		}
-		if (!input.serverDeploy) {
-			const serverDeploymentPrompt = await getServerDeploymentToAdd(detectedConfig.runtime, detectedConfig.serverDeploy, detectedConfig.backend);
-			if (serverDeploymentPrompt !== "none") input.serverDeploy = serverDeploymentPrompt;
-		}
-		const packageManager = input.packageManager || detectedConfig.packageManager || "npm";
-		let somethingAdded = false;
-		if (input.addons && input.addons.length > 0) {
-			await addAddonsToProject({
-				...input,
-				install: false,
-				suppressInstallMessage: true,
-				addons: input.addons
-			});
-			somethingAdded = true;
-		}
-		if (input.webDeploy && input.webDeploy !== "none") {
-			await addDeploymentToProject({
-				...input,
-				install: false,
-				suppressInstallMessage: true,
-				webDeploy: input.webDeploy
-			});
-			somethingAdded = true;
-		}
-		if (input.serverDeploy && input.serverDeploy !== "none") {
-			await addDeploymentToProject({
-				...input,
-				install: false,
-				suppressInstallMessage: true,
-				serverDeploy: input.serverDeploy
-			});
-			somethingAdded = true;
-		}
-		if (!somethingAdded) {
-			outro(pc.yellow("No addons or deployment configurations to add."));
-			return;
-		}
-		if (input.install) await installDependencies({
-			projectDir,
-			packageManager
-		});
-		else log.info(`Run ${pc.bold(`${packageManager} install`)} to install dependencies`);
-		outro("Add command completed successfully!");
-	} catch (error) {
-		if (error instanceof UserCancelledError) return;
-		if (error instanceof CLIError) throw error;
-		handleError(error, "Failed to add addons or deployment");
-	}
-}
 
 //#endregion
 //#region src/utils/open-url.ts
@@ -7571,17 +4363,6 @@ const router = os.router({
 		});
 		if (options.verbose) return result;
 	}),
-	add: os.meta({ description: "Add addons or deployment configurations to an existing Better-T-Stack project" }).input(z.tuple([z.object({
-		addons: z.array(types_exports.AddonsSchema).optional().default([]),
-		webDeploy: types_exports.WebDeploySchema.optional(),
-		serverDeploy: types_exports.ServerDeploySchema.optional(),
-		projectDir: z.string().optional(),
-		install: z.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
-		packageManager: types_exports.PackageManagerSchema.optional()
-	})])).handler(async ({ input }) => {
-		const [options] = input;
-		await addAddonsHandler(options);
-	}),
 	sponsors: os.meta({ description: "Show Better-T-Stack sponsors" }).handler(async () => {
 		try {
 			renderTitle();
@@ -7672,6 +4453,69 @@ async function docs() {
 async function builder() {
 	return caller.builder();
 }
+/**
+* Programmatic API to generate a project in-memory (virtual filesystem).
+* Returns a VirtualFileTree without writing to disk.
+* Useful for web previews and testing.
+*
+* @example
+* ```typescript
+* import { createVirtual, EMBEDDED_TEMPLATES } from "create-better-t-stack";
+*
+* const result = await createVirtual({
+*   frontend: ["tanstack-router"],
+*   backend: "hono",
+*   runtime: "bun",
+*   database: "sqlite",
+*   orm: "drizzle",
+* });
+*
+* if (result.success) {
+*   console.log(`Generated ${result.tree.fileCount} files`);
+* }
+* ```
+*/
+async function createVirtual(options) {
+	try {
+		const result = await generateVirtualProject({
+			config: {
+				projectName: options.projectName || "my-project",
+				projectDir: "/virtual",
+				relativePath: "./virtual",
+				database: options.database || "none",
+				orm: options.orm || "none",
+				backend: options.backend || "hono",
+				runtime: options.runtime || "bun",
+				frontend: options.frontend || ["tanstack-router"],
+				addons: options.addons || [],
+				examples: options.examples || [],
+				auth: options.auth || "none",
+				payments: options.payments || "none",
+				git: options.git ?? false,
+				packageManager: options.packageManager || "bun",
+				install: false,
+				dbSetup: options.dbSetup || "none",
+				api: options.api || "trpc",
+				webDeploy: options.webDeploy || "none",
+				serverDeploy: options.serverDeploy || "none"
+			},
+			templates: EMBEDDED_TEMPLATES
+		});
+		if (result.success && result.tree) return {
+			success: true,
+			tree: result.tree
+		};
+		return {
+			success: false,
+			error: result.error || "Unknown error"
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
 
 //#endregion
-export { router as a, docs as i, create as n, sponsors as o, createBtsCli as r, builder as t };
+export { create as a, docs as c, sponsors as d, builder as i, generateVirtualProject$1 as l, TEMPLATE_COUNT as n, createBtsCli as o, VirtualFileSystem as r, createVirtual as s, EMBEDDED_TEMPLATES$1 as t, router as u };