create-better-t-stack 2.33.9 → 2.34.1

package/dist/{src-BSUXyw1T.js → src-CqC0HMY7.js}

@@ -10,9 +10,10 @@ import { fileURLToPath } from "node:url";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
-import { globby } from "globby";
+import { glob } from "tinyglobby";
 import handlebars from "handlebars";
 import { IndentationText, Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
+import { Biome } from "@biomejs/js-api/nodejs";
 import os from "node:os";
 
 //#region src/utils/get-package-manager.ts
@@ -28,9 +29,8 @@ const getUserPkgManager = () => {
 const __filename = fileURLToPath(import.meta.url);
 const distPath = path.dirname(__filename);
 const PKG_ROOT = path.join(distPath, "../");
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG_BASE = {
 	projectName: "my-better-t-app",
-	projectDir: path.resolve(process.cwd(), "my-better-t-app"),
 	relativePath: "my-better-t-app",
 	frontend: ["tanstack-router"],
 	database: "sqlite",
@@ -39,14 +39,25 @@ const DEFAULT_CONFIG = {
 	addons: ["turborepo"],
 	examples: [],
 	git: true,
-	packageManager: getUserPkgManager(),
 	install: true,
 	dbSetup: "none",
 	backend: "hono",
 	runtime: "bun",
 	api: "trpc",
-	webDeploy: "none"
+	webDeploy: "none",
+	serverDeploy: "none"
 };
+function getDefaultConfig() {
+	return {
+		...DEFAULT_CONFIG_BASE,
+		projectDir: path.resolve(process.cwd(), DEFAULT_CONFIG_BASE.projectName),
+		packageManager: getUserPkgManager(),
+		frontend: [...DEFAULT_CONFIG_BASE.frontend],
+		addons: [...DEFAULT_CONFIG_BASE.addons],
+		examples: [...DEFAULT_CONFIG_BASE.examples]
+	};
+}
+const DEFAULT_CONFIG = getDefaultConfig();
 const dependencyVersionMap = {
 	"better-auth": "^1.3.4",
 	"@better-auth/expo": "^1.3.4",
@@ -103,18 +114,24 @@ const dependencyVersionMap = {
 	"convex-svelte": "^0.0.11",
 	"convex-nuxt": "0.1.5",
 	"convex-vue": "^0.1.5",
-	"@tanstack/svelte-query": "^5.74.4",
+	"@tanstack/svelte-query": "^5.85.3",
+	"@tanstack/svelte-query-devtools": "^5.85.3",
 	"@tanstack/vue-query-devtools": "^5.83.0",
 	"@tanstack/vue-query": "^5.83.0",
 	"@tanstack/react-query-devtools": "^5.80.5",
 	"@tanstack/react-query": "^5.80.5",
 	"@tanstack/solid-query": "^5.75.0",
 	"@tanstack/solid-query-devtools": "^5.75.0",
+	"@tanstack/solid-router-devtools": "^1.131.25",
 	wrangler: "^4.23.0",
 	"@cloudflare/vite-plugin": "^1.9.0",
 	"@opennextjs/cloudflare": "^1.3.0",
 	"nitro-cloudflare-dev": "^0.2.2",
-	"@sveltejs/adapter-cloudflare": "^7.0.4"
+	"@sveltejs/adapter-cloudflare": "^7.2.1",
+	"@cloudflare/workers-types": "^4.20250813.0",
+	alchemy: "^0.62.1",
+	nitropack: "^2.12.4",
+	dotenv: "^17.2.1"
 };
 const ADDON_COMPATIBILITY = {
 	pwa: [
@@ -128,7 +145,8 @@ const ADDON_COMPATIBILITY = {
 		"react-router",
 		"nuxt",
 		"svelte",
-		"solid"
+		"solid",
+		"next"
 	],
 	biome: [],
 	husky: [],
@@ -233,7 +251,16 @@ const ProjectNameSchema = z.string().min(1, "Project name cannot be empty").max(
 	];
 	return !invalidChars.some((char) => name.includes(char));
 }, "Project name contains invalid characters").refine((name) => name.toLowerCase() !== "node_modules", "Project name is reserved").describe("Project name or path");
-const WebDeploySchema = z.enum(["workers", "none"]).describe("Web deployment");
+const WebDeploySchema = z.enum([
+	"wrangler",
+	"alchemy",
+	"none"
+]).describe("Web deployment");
+const ServerDeploySchema = z.enum([
+	"wrangler",
+	"alchemy",
+	"none"
+]).describe("Server deployment");
 const DirectoryConflictSchema = z.enum([
 	"merge",
 	"overwrite",
@@ -544,6 +571,34 @@ function isExampleAIAllowed(backend, frontends = []) {
 function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
 	if (webDeploy && webDeploy !== "none" && !hasWebFrontendFlag) exitWithError("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
 }
+function validateServerDeployRequiresBackend(serverDeploy, backend) {
+	if (serverDeploy && serverDeploy !== "none" && (!backend || backend === "none")) exitWithError("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
+}
+function validateAddonsAgainstFrontends(addons = [], frontends = []) {
+	for (const addon of addons) {
+		if (addon === "none") continue;
+		const { isCompatible, reason } = validateAddonCompatibility(addon, frontends);
+		if (!isCompatible) exitWithError(`Incompatible addon/frontend combination: ${reason}`);
+	}
+}
+function validateExamplesCompatibility(examples, backend, database, frontend) {
+	const examplesArr = examples ?? [];
+	if (examplesArr.length === 0 || examplesArr.includes("none")) return;
+	if (examplesArr.includes("todo") && backend !== "convex" && backend !== "none" && database === "none") exitWithError("The 'todo' example requires a database if a backend (other than Convex) is present. Cannot use --examples todo when database is 'none' and a backend is selected.");
+	if (examplesArr.includes("ai") && backend === "elysia") exitWithError("The 'ai' example is not compatible with the Elysia backend.");
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
+}
+function validateAlchemyCompatibility(webDeploy, serverDeploy, frontends = []) {
+	const isAlchemyWebDeploy = webDeploy === "alchemy";
+	const isAlchemyServerDeploy = serverDeploy === "alchemy";
+	if (isAlchemyWebDeploy || isAlchemyServerDeploy) {
+		const incompatibleFrontends = frontends.filter((f) => f === "next" || f === "react-router");
+		if (incompatibleFrontends.length > 0) {
+			const deployType = isAlchemyWebDeploy && isAlchemyServerDeploy ? "web and server deployment" : isAlchemyWebDeploy ? "web deployment" : "server deployment";
+			exitWithError(`Alchemy ${deployType} is temporarily not compatible with ${incompatibleFrontends.join(" and ")} frontend(s). Please choose a different frontend or deployment option.`);
+		}
+	}
+}
 
 //#endregion
 //#region src/prompts/api.ts
@@ -1004,16 +1059,97 @@ async function getRuntimeChoice(runtime, backend) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/server-deploy.ts
+function getDeploymentDisplay$1(deployment) {
+	if (deployment === "wrangler") return {
+		label: "Wrangler",
+		hint: "Deploy to Cloudflare Workers using Wrangler"
+	};
+	if (deployment === "alchemy") return {
+		label: "Alchemy",
+		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";
+	const options = [];
+	if (runtime === "workers") ["alchemy", "wrangler"].forEach((deploy) => {
+		const { label, hint } = getDeploymentDisplay$1(deploy);
+		options.unshift({
+			value: deploy,
+			label,
+			hint
+		});
+	});
+	else options.push({
+		value: "none",
+		label: "None",
+		hint: "Manual setup"
+	});
+	const response = await select({
+		message: "Select server deployment",
+		options,
+		initialValue: webDeploy === "alchemy" ? "alchemy" : runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
+	});
+	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getServerDeploymentToAdd(runtime, existingDeployment) {
+	const options = [];
+	if (runtime === "workers") {
+		if (existingDeployment !== "wrangler") {
+			const { label, hint } = getDeploymentDisplay$1("wrangler");
+			options.push({
+				value: "wrangler",
+				label,
+				hint
+			});
+		}
+		if (existingDeployment !== "alchemy") {
+			const { label, hint } = getDeploymentDisplay$1("alchemy");
+			options.push({
+				value: "alchemy",
+				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 select({
+		message: "Select server deployment",
+		options,
+		initialValue: runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
+	});
+	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
 //#endregion
 //#region src/prompts/web-deploy.ts
 function hasWebFrontend(frontends) {
 	return frontends.some((f) => WEB_FRAMEWORKS.includes(f));
 }
 function getDeploymentDisplay(deployment) {
-	if (deployment === "workers") return {
-		label: "Cloudflare Workers",
+	if (deployment === "wrangler") return {
+		label: "Wrangler",
 		hint: "Deploy to Cloudflare Workers using Wrangler"
 	};
+	if (deployment === "alchemy") return {
+		label: "Alchemy",
+		hint: "Deploy to Cloudflare Workers using Alchemy"
+	};
 	return {
 		label: deployment,
 		hint: `Add ${deployment} deployment`
@@ -1022,15 +1158,18 @@ function getDeploymentDisplay(deployment) {
 async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []) {
 	if (deployment !== void 0) return deployment;
 	if (!hasWebFrontend(frontend)) return "none";
-	const options = [{
-		value: "workers",
-		label: "Cloudflare Workers",
-		hint: "Deploy to Cloudflare Workers using Wrangler"
-	}, {
-		value: "none",
-		label: "None",
-		hint: "Manual setup"
-	}];
+	const options = [
+		"wrangler",
+		"alchemy",
+		"none"
+	].map((deploy) => {
+		const { label, hint } = getDeploymentDisplay(deploy);
+		return {
+			value: deploy,
+			label,
+			hint
+		};
+	});
 	const response = await select({
 		message: "Select web deployment",
 		options,
@@ -1042,10 +1181,18 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 async function getDeploymentToAdd(frontend, existingDeployment) {
 	if (!hasWebFrontend(frontend)) return "none";
 	const options = [];
-	if (existingDeployment !== "workers") {
-		const { label, hint } = getDeploymentDisplay("workers");
+	if (existingDeployment !== "wrangler") {
+		const { label, hint } = getDeploymentDisplay("wrangler");
+		options.push({
+			value: "wrangler",
+			label,
+			hint
+		});
+	}
+	if (existingDeployment !== "alchemy") {
+		const { label, hint } = getDeploymentDisplay("alchemy");
 		options.push({
-			value: "workers",
+			value: "alchemy",
 			label,
 			hint
 		});
@@ -1081,6 +1228,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		examples: ({ results }) => getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api),
 		dbSetup: ({ results }) => getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime),
 		webDeploy: ({ results }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend),
+		serverDeploy: ({ results }) => getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy),
 		git: () => getGitChoice(flags.git),
 		packageManager: () => getPackageManagerChoice(flags.packageManager),
 		install: () => getinstallChoice(flags.install)
@@ -1120,7 +1268,8 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		install: result.install,
 		dbSetup: result.dbSetup,
 		api: result.api,
-		webDeploy: result.webDeploy
+		webDeploy: result.webDeploy,
+		serverDeploy: result.serverDeploy
 	};
 }
 
@@ -1152,7 +1301,7 @@ async function getProjectName(initialName) {
 	let projectPath = "";
 	let defaultName = DEFAULT_CONFIG.projectName;
 	let counter = 1;
-	while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
+	while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
 		defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
 		counter++;
 	}
@@ -1199,7 +1348,7 @@ const getLatestCLIVersion = () => {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
+	const BTS_TELEMETRY = "0";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -1207,11 +1356,16 @@ function isTelemetryEnabled() {
 
 //#endregion
 //#region src/utils/analytics.ts
-const POSTHOG_API_KEY = "phc_8ZUxEwwfKMajJLvxz1daGd931dYbQrwKNficBmsdIrs";
-const POSTHOG_HOST = "https://us.i.posthog.com";
+const POSTHOG_API_KEY = "random";
+const POSTHOG_HOST = "random";
+function generateSessionId() {
+	const rand = Math.random().toString(36).slice(2);
+	const now = Date.now().toString(36);
+	return `cli_${now}${rand}`;
+}
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
-	const sessionId = `cli_${crypto.randomUUID().replace(/-/g, "")}`;
+	const sessionId = generateSessionId();
 	const { projectName, projectDir, relativePath,...safeConfig } = config;
 	const payload = {
 		api_key: POSTHOG_API_KEY,
@@ -1219,8 +1373,8 @@ async function trackProjectCreation(config, disableAnalytics = false) {
 		properties: {
 			...safeConfig,
 			cli_version: getLatestCLIVersion(),
-			node_version: process.version,
-			platform: process.platform,
+			node_version: typeof process !== "undefined" ? process.version : "",
+			platform: typeof process !== "undefined" ? process.platform : "",
 			$ip: null
 		},
 		distinct_id: sessionId
@@ -1274,6 +1428,7 @@ function displayConfig(config) {
 	}
 	if (config.dbSetup !== void 0) configDisplay.push(`${pc.blue("Database Setup:")} ${String(config.dbSetup)}`);
 	if (config.webDeploy !== void 0) configDisplay.push(`${pc.blue("Web Deployment:")} ${String(config.webDeploy)}`);
+	if (config.serverDeploy !== void 0) configDisplay.push(`${pc.blue("Server Deployment:")} ${String(config.serverDeploy)}`);
 	if (configDisplay.length === 0) return pc.yellow("No configuration selected.");
 	return configDisplay.join("\n");
 }
@@ -1296,6 +1451,7 @@ function generateReproducibleCommand(config) {
 	else flags.push("--examples none");
 	flags.push(`--db-setup ${config.dbSetup}`);
 	flags.push(`--web-deploy ${config.webDeploy}`);
+	flags.push(`--server-deploy ${config.serverDeploy}`);
 	flags.push(config.git ? "--git" : "--no-git");
 	flags.push(`--package-manager ${config.packageManager}`);
 	flags.push(config.install ? "--install" : "--no-install");
@@ -1313,8 +1469,8 @@ function generateReproducibleCommand(config) {
 async function handleDirectoryConflict(currentPathInput, silent = false) {
 	while (true) {
 		const resolvedPath = path.resolve(process.cwd(), currentPathInput);
-		const dirExists = fs.pathExistsSync(resolvedPath);
-		const dirIsNotEmpty = dirExists && fs.readdirSync(resolvedPath).length > 0;
+		const dirExists = await fs.pathExists(resolvedPath);
+		const dirIsNotEmpty = dirExists && (await fs.readdir(resolvedPath)).length > 0;
 		if (!dirIsNotEmpty) return {
 			finalPathInput: currentPathInput,
 			shouldClearDirectory: false
@@ -1440,7 +1596,7 @@ const renderTitle = () => {
 };
 
 //#endregion
-//#region src/validation.ts
+//#region src/utils/config-processing.ts
 function processArrayOption(options) {
 	if (!options || options.length === 0) return [];
 	if (options.includes("none")) return [];
@@ -1451,22 +1607,10 @@ function deriveProjectName(projectName, projectDirectory) {
 	if (projectDirectory) return path.basename(path.resolve(process.cwd(), projectDirectory));
 	return "";
 }
-function validateProjectName(name) {
-	const result = ProjectNameSchema.safeParse(name);
-	if (!result.success) exitWithError(`Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`);
-}
-function processAndValidateFlags(options, providedFlags, projectName) {
+function processFlags(options, projectName) {
 	const config = {};
-	if (options.api) {
-		config.api = options.api;
-		if (options.api === "none") {
-			if (options.examples && !(options.examples.length === 1 && options.examples[0] === "none") && options.backend !== "convex") exitWithError("Cannot use '--examples' when '--api' is set to 'none'. Please remove the --examples flag or choose an API type.");
-		}
-	}
+	if (options.api) config.api = options.api;
 	if (options.backend) config.backend = options.backend;
-	if (providedFlags.has("backend") && config.backend && config.backend !== "convex" && config.backend !== "none") {
-		if (providedFlags.has("runtime") && options.runtime === "none") exitWithError(`'--runtime none' is only supported with '--backend convex' or '--backend none'. Please choose 'bun', 'node', or remove the --runtime flag.`);
-	}
 	if (options.database) config.database = options.database;
 	if (options.orm) config.orm = options.orm;
 	if (options.auth !== void 0) config.auth = options.auth;
@@ -1476,70 +1620,190 @@ function processAndValidateFlags(options, providedFlags, projectName) {
 	if (options.dbSetup) config.dbSetup = options.dbSetup;
 	if (options.packageManager) config.packageManager = options.packageManager;
 	if (options.webDeploy) config.webDeploy = options.webDeploy;
+	if (options.serverDeploy) config.serverDeploy = options.serverDeploy;
 	const derivedName = deriveProjectName(projectName, options.projectDirectory);
-	if (derivedName) {
-		const nameToValidate = projectName ? path.basename(projectName) : derivedName;
-		validateProjectName(nameToValidate);
-		config.projectName = projectName || derivedName;
-	}
-	if (options.frontend && options.frontend.length > 0) if (options.frontend.includes("none")) {
-		if (options.frontend.length > 1) exitWithError(`Cannot combine 'none' with other frontend options.`);
-		config.frontend = [];
-	} else {
-		const validOptions = processArrayOption(options.frontend);
-		ensureSingleWebAndNative(validOptions);
-		config.frontend = validOptions;
-	}
-	if (providedFlags.has("api") && providedFlags.has("frontend") && config.api && config.frontend && config.frontend.length > 0) validateApiFrontendCompatibility(config.api, config.frontend);
-	if (options.addons && options.addons.length > 0) if (options.addons.includes("none")) {
-		if (options.addons.length > 1) exitWithError(`Cannot combine 'none' with other addons.`);
-		config.addons = [];
-	} else config.addons = processArrayOption(options.addons);
-	if (options.examples && options.examples.length > 0) if (options.examples.includes("none")) {
-		if (options.examples.length > 1) exitWithError("Cannot combine 'none' with other examples.");
-		config.examples = [];
-	} else {
-		config.examples = processArrayOption(options.examples);
-		if (options.examples.includes("none") && config.backend !== "convex") config.examples = [];
+	if (derivedName) config.projectName = projectName || derivedName;
+	if (options.frontend && options.frontend.length > 0) config.frontend = processArrayOption(options.frontend);
+	if (options.addons && options.addons.length > 0) config.addons = processArrayOption(options.addons);
+	if (options.examples && options.examples.length > 0) config.examples = processArrayOption(options.examples);
+	return config;
+}
+function getProvidedFlags(options) {
+	return new Set(Object.keys(options).filter((key) => options[key] !== void 0));
+}
+function validateNoneExclusivity(options, optionName) {
+	if (!options || options.length === 0) return;
+	if (options.includes("none") && options.length > 1) throw new Error(`Cannot combine 'none' with other ${optionName}.`);
+}
+function validateArrayOptions(options) {
+	validateNoneExclusivity(options.frontend, "frontend options");
+	validateNoneExclusivity(options.addons, "addons");
+	validateNoneExclusivity(options.examples, "examples");
+}
+
+//#endregion
+//#region src/utils/config-validation.ts
+function validateDatabaseOrmAuth(cfg, flags) {
+	const db = cfg.database;
+	const orm = cfg.orm;
+	const has = (k) => flags ? flags.has(k) : true;
+	if (has("orm") && has("database") && orm === "mongoose" && db !== "mongodb") exitWithError("Mongoose ORM requires MongoDB database. Please use '--database mongodb' or choose a different ORM.");
+	if (has("orm") && has("database") && orm === "drizzle" && db === "mongodb") exitWithError("Drizzle ORM does not support MongoDB. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
+	if (has("database") && has("orm") && db === "mongodb" && orm && orm !== "mongoose" && orm !== "prisma" && orm !== "none") exitWithError("MongoDB database requires Mongoose or Prisma ORM. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
+	if (has("database") && has("orm") && db && db !== "none" && orm === "none") exitWithError("Database selection requires an ORM. Please choose '--orm drizzle', '--orm prisma', or '--orm mongoose'.");
+	if (has("orm") && has("database") && orm && orm !== "none" && db === "none") exitWithError("ORM selection requires a database. Please choose a database or set '--orm none'.");
+	if (has("auth") && has("database") && cfg.auth && db === "none") exitWithError("Authentication requires a database. Please choose a database or set '--no-auth'.");
+	if (cfg.auth && db === "none") exitWithError("Authentication requires a database. Please choose a database or set '--no-auth'.");
+	if (orm && orm !== "none" && db === "none") exitWithError("ORM selection requires a database. Please choose a database or set '--orm none'.");
+}
+function validateDatabaseSetup(config, providedFlags) {
+	const { dbSetup, database, runtime } = config;
+	if (providedFlags.has("dbSetup") && providedFlags.has("database") && dbSetup && dbSetup !== "none" && database === "none") exitWithError("Database setup requires a database. Please choose a database or set '--db-setup none'.");
+	const setupValidations = {
+		turso: {
+			database: "sqlite",
+			errorMessage: "Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup."
+		},
+		neon: {
+			database: "postgres",
+			errorMessage: "Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		"prisma-postgres": {
+			database: "postgres",
+			errorMessage: "Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		"mongodb-atlas": {
+			database: "mongodb",
+			errorMessage: "MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup."
+		},
+		supabase: {
+			database: "postgres",
+			errorMessage: "Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
+		},
+		d1: {
+			database: "sqlite",
+			runtime: "workers",
+			errorMessage: "Cloudflare D1 setup requires SQLite database and Cloudflare Workers runtime."
+		},
+		docker: { errorMessage: "Docker setup is not compatible with SQLite database or Cloudflare Workers runtime." },
+		none: { errorMessage: "" }
+	};
+	if (dbSetup && dbSetup !== "none") {
+		const validation = setupValidations[dbSetup];
+		if (validation.database && database !== validation.database) exitWithError(validation.errorMessage);
+		if (validation.runtime && runtime !== validation.runtime) exitWithError(validation.errorMessage);
+		if (dbSetup === "docker") {
+			if (database === "sqlite") exitWithError("Docker setup is not compatible with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
+			if (runtime === "workers") exitWithError("Docker setup is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+		}
+	}
+}
+function validateBackendConstraints(config, providedFlags, options) {
+	const { backend } = config;
+	if (providedFlags.has("backend") && backend && backend !== "convex" && backend !== "none") {
+		if (providedFlags.has("runtime") && options.runtime === "none") exitWithError("'--runtime none' is only supported with '--backend convex' or '--backend none'. Please choose 'bun', 'node', or remove the --runtime flag.");
 	}
-	if (config.backend === "convex" || config.backend === "none") {
-		const incompatibleFlags = incompatibleFlagsForBackend(config.backend, providedFlags, options);
-		if (incompatibleFlags.length > 0) exitWithError(`The following flags are incompatible with '--backend ${config.backend}': ${incompatibleFlags.join(", ")}. Please remove them.`);
-		if (config.backend === "convex" && providedFlags.has("frontend") && options.frontend) {
+	if (backend === "convex" || backend === "none") {
+		const incompatibleFlags = incompatibleFlagsForBackend(backend, providedFlags, options);
+		if (incompatibleFlags.length > 0) exitWithError(`The following flags are incompatible with '--backend ${backend}': ${incompatibleFlags.join(", ")}. Please remove them.`);
+		if (backend === "convex" && providedFlags.has("frontend") && options.frontend) {
 			const incompatibleFrontends = options.frontend.filter((f) => f === "solid");
 			if (incompatibleFrontends.length > 0) exitWithError(`The following frontends are not compatible with '--backend convex': ${incompatibleFrontends.join(", ")}. Please choose a different frontend or backend.`);
 		}
 		coerceBackendPresets(config);
 	}
-	if (providedFlags.has("orm") && providedFlags.has("database") && config.orm === "mongoose" && config.database !== "mongodb") exitWithError("Mongoose ORM requires MongoDB database. Please use '--database mongodb' or choose a different ORM.");
-	if (providedFlags.has("database") && providedFlags.has("orm") && config.database === "mongodb" && config.orm && config.orm !== "mongoose" && config.orm !== "prisma") exitWithError("MongoDB database requires Mongoose or Prisma ORM. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
-	if (providedFlags.has("orm") && providedFlags.has("database") && config.orm === "drizzle" && config.database === "mongodb") exitWithError("Drizzle ORM does not support MongoDB. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
-	if (providedFlags.has("database") && providedFlags.has("orm") && config.database && config.database !== "none" && config.orm === "none") exitWithError("Database selection requires an ORM. Please choose '--orm drizzle', '--orm prisma', or '--orm mongoose'.");
-	if (providedFlags.has("orm") && providedFlags.has("database") && config.orm && config.orm !== "none" && config.database === "none") exitWithError("ORM selection requires a database. Please choose a database or set '--orm none'.");
-	if (providedFlags.has("auth") && providedFlags.has("database") && config.auth && config.database === "none") exitWithError("Authentication requires a database. Please choose a database or set '--no-auth'.");
-	if (providedFlags.has("dbSetup") && providedFlags.has("database") && config.dbSetup && config.dbSetup !== "none" && config.database === "none") exitWithError("Database setup requires a database. Please choose a database or set '--db-setup none'.");
-	if (providedFlags.has("dbSetup") && (config.database ? providedFlags.has("database") : true) && config.dbSetup === "turso" && config.database !== "sqlite") exitWithError("Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup.");
-	if (providedFlags.has("dbSetup") && (config.database ? providedFlags.has("database") : true) && config.dbSetup === "neon" && config.database !== "postgres") exitWithError("Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
-	if (providedFlags.has("dbSetup") && (config.database ? providedFlags.has("database") : true) && config.dbSetup === "prisma-postgres" && config.database !== "postgres") exitWithError("Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
-	if (providedFlags.has("dbSetup") && (config.database ? providedFlags.has("database") : true) && config.dbSetup === "mongodb-atlas" && config.database !== "mongodb") exitWithError("MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup.");
-	if (providedFlags.has("dbSetup") && (config.database ? providedFlags.has("database") : true) && config.dbSetup === "supabase" && config.database !== "postgres") exitWithError("Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup.");
-	if (config.dbSetup === "d1") {
-		if (providedFlags.has("dbSetup") && providedFlags.has("database") || providedFlags.has("dbSetup") && !config.database) {
-			if (config.database !== "sqlite") exitWithError("Cloudflare D1 setup requires SQLite database. Please use '--database sqlite' or choose a different setup.");
-		}
-		if (providedFlags.has("dbSetup") && providedFlags.has("runtime") || providedFlags.has("dbSetup") && !config.runtime) {
-			if (config.runtime !== "workers") exitWithError("Cloudflare D1 setup requires the Cloudflare Workers runtime. Please use '--runtime workers' or choose a different setup.");
-		}
+}
+function validateFrontendConstraints(config, providedFlags) {
+	const { frontend } = config;
+	if (frontend && frontend.length > 0) {
+		ensureSingleWebAndNative(frontend);
+		if (providedFlags.has("api") && providedFlags.has("frontend") && config.api) validateApiFrontendCompatibility(config.api, frontend);
 	}
-	if (providedFlags.has("dbSetup") && providedFlags.has("database") && config.dbSetup === "docker" && config.database === "sqlite") exitWithError("Docker setup is not compatible with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
-	if (providedFlags.has("dbSetup") && providedFlags.has("runtime") && config.dbSetup === "docker" && config.runtime === "workers") exitWithError("Docker setup is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
-	validateWorkersCompatibility(providedFlags, options, config);
-	const hasWebFrontendFlag = (config.frontend ?? []).some((f) => isWebFrontend(f));
+	const hasWebFrontendFlag = (frontend ?? []).some((f) => isWebFrontend(f));
 	validateWebDeployRequiresWebFrontend(config.webDeploy, hasWebFrontendFlag);
+}
+function validateApiConstraints(config, options) {
+	if (config.api === "none") {
+		if (options.examples && !(options.examples.length === 1 && options.examples[0] === "none") && options.backend !== "convex") exitWithError("Cannot use '--examples' when '--api' is set to 'none'. Please remove the --examples flag or choose an API type.");
+	}
+}
+function validateFullConfig(config, providedFlags, options) {
+	validateDatabaseOrmAuth(config, providedFlags);
+	validateDatabaseSetup(config, providedFlags);
+	validateBackendConstraints(config, providedFlags, options);
+	validateFrontendConstraints(config, providedFlags);
+	validateApiConstraints(config, options);
+	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
+	validateWorkersCompatibility(providedFlags, options, config);
+	if (config.addons && config.addons.length > 0) {
+		validateAddonsAgainstFrontends(config.addons, config.frontend);
+		config.addons = [...new Set(config.addons)];
+	}
+	validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? []);
+	validateAlchemyCompatibility(config.webDeploy, config.serverDeploy, config.frontend ?? []);
+}
+function validateConfigForProgrammaticUse(config) {
+	try {
+		validateDatabaseOrmAuth(config);
+		if (config.frontend && config.frontend.length > 0) ensureSingleWebAndNative(config.frontend);
+		validateApiFrontendCompatibility(config.api, config.frontend);
+		if (config.addons && config.addons.length > 0) validateAddonsAgainstFrontends(config.addons, config.frontend);
+		validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? []);
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(String(error));
+	}
+}
+
+//#endregion
+//#region src/utils/project-name-validation.ts
+function validateProjectName(name) {
+	const result = ProjectNameSchema.safeParse(name);
+	if (!result.success) exitWithError(`Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`);
+}
+function validateProjectNameThrow(name) {
+	const result = ProjectNameSchema.safeParse(name);
+	if (!result.success) throw new Error(`Invalid project name: ${result.error.issues[0]?.message}`);
+}
+function extractAndValidateProjectName(projectName, projectDirectory, throwOnError = false) {
+	const derivedName = projectName || (projectDirectory ? path.basename(path.resolve(process.cwd(), projectDirectory)) : "");
+	if (!derivedName) return "";
+	const nameToValidate = projectName ? path.basename(projectName) : derivedName;
+	if (throwOnError) validateProjectNameThrow(nameToValidate);
+	else validateProjectName(nameToValidate);
+	return projectName || derivedName;
+}
+
+//#endregion
+//#region src/validation.ts
+function processAndValidateFlags(options, providedFlags, projectName) {
+	if (options.yolo) {
+		const cfg = processFlags(options, projectName);
+		const validatedProjectName$1 = extractAndValidateProjectName(projectName, options.projectDirectory, true);
+		if (validatedProjectName$1) cfg.projectName = validatedProjectName$1;
+		return cfg;
+	}
+	try {
+		validateArrayOptions(options);
+	} catch (error) {
+		exitWithError(error instanceof Error ? error.message : String(error));
+	}
+	const config = processFlags(options, projectName);
+	const validatedProjectName = extractAndValidateProjectName(projectName, options.projectDirectory, false);
+	if (validatedProjectName) config.projectName = validatedProjectName;
+	validateFullConfig(config, providedFlags, options);
 	return config;
 }
-function getProvidedFlags(options) {
-	return new Set(Object.keys(options).filter((key) => options[key] !== void 0));
+function processProvidedFlagsWithoutValidation(options, projectName) {
+	const config = processFlags(options, projectName);
+	const validatedProjectName = extractAndValidateProjectName(projectName, options.projectDirectory, true);
+	if (validatedProjectName) config.projectName = validatedProjectName;
+	return config;
+}
+function validateConfigCompatibility(config, providedFlags, options) {
+	if (options?.yolo) return;
+	if (options && providedFlags) validateFullConfig(config, providedFlags, options);
+	else validateConfigForProgrammaticUse(config);
 }
 
 //#endregion
@@ -1560,7 +1824,8 @@ async function writeBtsConfig(projectConfig) {
 		packageManager: projectConfig.packageManager,
 		dbSetup: projectConfig.dbSetup,
 		api: projectConfig.api,
-		webDeploy: projectConfig.webDeploy
+		webDeploy: projectConfig.webDeploy,
+		serverDeploy: projectConfig.serverDeploy
 	};
 	const baseContent = {
 		$schema: "https://r2.better-t-stack.dev/schema.json",
@@ -1577,7 +1842,8 @@ async function writeBtsConfig(projectConfig) {
 		packageManager: btsConfig.packageManager,
 		dbSetup: btsConfig.dbSetup,
 		api: btsConfig.api,
-		webDeploy: btsConfig.webDeploy
+		webDeploy: btsConfig.webDeploy,
+		serverDeploy: btsConfig.serverDeploy
 	};
 	let configContent = JSON.stringify(baseContent);
 	const formatResult = JSONC.format(configContent, void 0, {
@@ -1670,7 +1936,7 @@ function getPackageExecutionCommand(packageManager, commandWithArgs) {
 }
 
 //#endregion
-//#region src/helpers/setup/fumadocs-setup.ts
+//#region src/helpers/addons/fumadocs-setup.ts
 const TEMPLATES = {
 	"next-mdx": {
 		label: "Next.js: Fumadocs MDX",
@@ -1757,9 +2023,9 @@ handlebars.registerHelper("or", (a, b) => a || b);
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
 //#endregion
-//#region src/helpers/project-generation/template-manager.ts
+//#region src/helpers/core/template-manager.ts
 async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
-	const sourceFiles = await globby(sourcePattern, {
+	const sourceFiles = await glob(sourcePattern, {
 		cwd: baseSourceDir,
 		dot: true,
 		onlyFiles: true,
@@ -2073,10 +2339,6 @@ async function handleExtras(projectDir, context) {
 		const npmrcTemplateSrc = path.join(extrasDir, "_npmrc.hbs");
 		if (await fs.pathExists(npmrcTemplateSrc)) await processAndCopyFiles("_npmrc.hbs", extrasDir, projectDir, context);
 	}
-	if (context.runtime === "workers") {
-		const runtimeWorkersDir = path.join(PKG_ROOT, "templates/runtime/workers");
-		if (await fs.pathExists(runtimeWorkersDir)) await processAndCopyFiles("**/*", runtimeWorkersDir, projectDir, context, false);
-	}
 }
 async function setupDockerComposeTemplates(projectDir, context) {
 	if (context.dbSetup !== "docker" || context.database === "none") return;
@@ -2085,29 +2347,62 @@ async function setupDockerComposeTemplates(projectDir, context) {
 	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, serverAppDir, context);
 }
 async function setupDeploymentTemplates(projectDir, context) {
-	if (context.webDeploy === "none") return;
-	if (context.webDeploy === "workers") {
+	if (context.webDeploy === "alchemy" || context.serverDeploy === "alchemy") if (context.webDeploy === "alchemy" && context.serverDeploy === "alchemy") {
+		const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
+		if (await fs.pathExists(alchemyTemplateSrc)) {
+			await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, projectDir, context);
+			const serverAppDir = path.join(projectDir, "apps/server");
+			if (await fs.pathExists(serverAppDir)) {
+				await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+				await processAndCopyFiles("wrangler.jsonc.hbs", alchemyTemplateSrc, serverAppDir, context);
+			}
+		}
+	} else {
+		if (context.webDeploy === "alchemy") {
+			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
+			const webAppDir = path.join(projectDir, "apps/web");
+			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(webAppDir)) await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, webAppDir, context);
+		}
+		if (context.serverDeploy === "alchemy") {
+			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
+			const serverAppDir = path.join(projectDir, "apps/server");
+			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
+				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+				await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+				await processAndCopyFiles("wrangler.jsonc.hbs", alchemyTemplateSrc, serverAppDir, context);
+			}
+		}
+	}
+	if (context.webDeploy !== "none" && context.webDeploy !== "alchemy") {
 		const webAppDir = path.join(projectDir, "apps/web");
-		if (!await fs.pathExists(webAppDir)) return;
-		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/web/${templateMap[f]}`);
-			if (await fs.pathExists(deployTemplateSrc)) await processAndCopyFiles("**/*", deployTemplateSrc, webAppDir, context);
+		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 !== "alchemy") {
+		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/setup/ruler-setup.ts
+//#region src/helpers/addons/ruler-setup.ts
 async function setupVibeRules(config) {
 	const { packageManager, projectDir } = config;
 	try {
@@ -2189,7 +2484,7 @@ async function addRulerScriptToPackageJson(projectDir, packageManager) {
 }
 
 //#endregion
-//#region src/helpers/setup/starlight-setup.ts
+//#region src/helpers/addons/starlight-setup.ts
 async function setupStarlight(config) {
 	const { packageManager, projectDir } = config;
 	const s = spinner();
@@ -2221,7 +2516,7 @@ async function setupStarlight(config) {
 }
 
 //#endregion
-//#region src/helpers/setup/tauri-setup.ts
+//#region src/helpers/addons/tauri-setup.ts
 async function setupTauri(config) {
 	const { packageManager, frontend, projectDir } = config;
 	const s = spinner();
@@ -2258,8 +2553,8 @@ async function setupTauri(config) {
 			`--window-title=${path.basename(projectDir)}`,
 			`--frontend-dist=${frontendDist}`,
 			`--dev-url=${devUrl}`,
-			`--before-dev-command=\"${packageManager} run dev\"`,
-			`--before-build-command=\"${packageManager} run build\"`
+			`--before-dev-command="${packageManager} run dev"`,
+			`--before-build-command="${packageManager} run build"`
 		];
 		const tauriArgsString = tauriArgs.join(" ");
 		const commandWithArgs = `@tauri-apps/cli@latest ${tauriArgsString}`;
@@ -2277,7 +2572,7 @@ async function setupTauri(config) {
 }
 
 //#endregion
-//#region src/helpers/setup/ultracite-setup.ts
+//#region src/helpers/addons/ultracite-setup.ts
 const EDITORS = {
 	vscode: {
 		label: "VSCode / Cursor / Windsurf",
@@ -2384,7 +2679,7 @@ function ensureArrayProperty(obj, name) {
 }
 
 //#endregion
-//#region src/helpers/setup/vite-pwa-setup.ts
+//#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");
@@ -2418,7 +2713,7 @@ async function addPwaToViteConfig(viteConfigPath, projectName) {
 }
 
 //#endregion
-//#region src/helpers/setup/addons-setup.ts
+//#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");
@@ -2552,7 +2847,7 @@ async function setupOxlint(projectDir, packageManager) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/detect-project-config.ts
+//#region src/helpers/core/detect-project-config.ts
 async function detectProjectConfig(projectDir) {
 	try {
 		const btsConfig = await readBtsConfig(projectDir);
@@ -2570,7 +2865,8 @@ async function detectProjectConfig(projectDir) {
 			packageManager: btsConfig.packageManager,
 			dbSetup: btsConfig.dbSetup,
 			api: btsConfig.api,
-			webDeploy: btsConfig.webDeploy
+			webDeploy: btsConfig.webDeploy,
+			serverDeploy: btsConfig.serverDeploy
 		};
 		return null;
 	} catch (_error) {
@@ -2586,7 +2882,7 @@ async function isBetterTStackProject(projectDir) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/install-dependencies.ts
+//#region src/helpers/core/install-dependencies.ts
 async function installDependencies({ projectDir, packageManager }) {
 	const s = spinner();
 	try {
@@ -2603,7 +2899,7 @@ async function installDependencies({ projectDir, packageManager }) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/add-addons.ts
+//#region src/helpers/core/add-addons.ts
 async function addAddonsToProject(input) {
 	try {
 		const projectDir = input.projectDir || process.cwd();
@@ -2628,7 +2924,8 @@ async function addAddonsToProject(input) {
 			install: input.install || false,
 			dbSetup: detectedConfig.dbSetup || "none",
 			api: detectedConfig.api || "none",
-			webDeploy: detectedConfig.webDeploy || "none"
+			webDeploy: detectedConfig.webDeploy || "none",
+			serverDeploy: detectedConfig.serverDeploy || "none"
 		};
 		for (const addon of input.addons) {
 			const { isCompatible, reason } = validateAddonCompatibility(addon, config.frontend);
@@ -2651,12 +2948,92 @@ async function addAddonsToProject(input) {
 }
 
 //#endregion
-//#region src/helpers/setup/workers-nuxt-setup.ts
-async function setupNuxtWorkersDeploy(projectDir, packageManager) {
+//#region src/helpers/deployment/server-deploy-setup.ts
+async function setupServerDeploy(config) {
+	const { serverDeploy, webDeploy, projectDir } = config;
+	const { packageManager } = config;
+	if (serverDeploy === "none") return;
+	if (serverDeploy === "alchemy" && webDeploy === "alchemy") return;
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	if (serverDeploy === "wrangler") {
+		await setupWorkersServerDeploy(serverDir, packageManager);
+		await generateCloudflareWorkerTypes({
+			serverDir,
+			packageManager
+		});
+	} else if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, packageManager);
+}
+async function setupWorkersServerDeploy(serverDir, _packageManager) {
+	const packageJsonPath = path.join(serverDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	packageJson.scripts = {
+		...packageJson.scripts,
+		dev: "wrangler dev --port=3000",
+		start: "wrangler dev",
+		deploy: "wrangler deploy",
+		build: "wrangler deploy --dry-run",
+		"cf-typegen": "wrangler types --env-interface CloudflareBindings"
+	};
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	await addPackageDependency({
+		devDependencies: [
+			"wrangler",
+			"@types/node",
+			"@cloudflare/workers-types"
+		],
+		projectDir: serverDir
+	});
+}
+async function generateCloudflareWorkerTypes({ serverDir, packageManager }) {
+	if (!await fs.pathExists(serverDir)) return;
+	const s = spinner();
+	try {
+		s.start("Generating Cloudflare Workers types...");
+		const runCmd = packageManager === "npm" ? "npm" : packageManager;
+		await execa(runCmd, ["run", "cf-typegen"], { cwd: serverDir });
+		s.stop("Cloudflare Workers types generated successfully!");
+	} catch {
+		s.stop(pc.yellow("Failed to generate Cloudflare Workers types"));
+		const managerCmd = `${packageManager} run`;
+		log.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
+	}
+}
+async function setupAlchemyServerDeploy(serverDir, _packageManager) {
+	if (!await fs.pathExists(serverDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"wrangler",
+			"@types/node",
+			"@cloudflare/workers-types",
+			"dotenv"
+		],
+		projectDir: serverDir
+	});
+	const packageJsonPath = path.join(serverDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		packageJson.scripts = {
+			...packageJson.scripts,
+			dev: "wrangler dev --port=3000",
+			build: "wrangler deploy --dry-run",
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-next-setup.ts
+async function setupNextAlchemyDeploy(projectDir, _packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["nitro-cloudflare-dev", "wrangler"],
+		devDependencies: ["alchemy", "dotenv"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -2664,43 +3041,518 @@ async function setupNuxtWorkersDeploy(projectDir, packageManager) {
 		const pkg = await fs.readJson(pkgPath);
 		pkg.scripts = {
 			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types"
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-nuxt-setup.ts
+async function setupNuxtAlchemyDeploy(projectDir, _packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"nitro-cloudflare-dev",
+			"dotenv"
+		],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
 		};
 		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
 	}
 	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
 	if (!await fs.pathExists(nuxtConfigPath)) return;
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(nuxtConfigPath);
-	if (!sourceFile) return;
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineNuxtConfig";
-	});
-	if (!defineCall) return;
-	const configObj = defineCall.getArguments()[0];
-	if (!configObj) return;
-	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-	const compatProp = configObj.getProperty("compatibilityDate");
-	if (compatProp && compatProp.getKind() === SyntaxKind.PropertyAssignment) compatProp.setInitializer(`'${today}'`);
-	else configObj.addPropertyAssignment({
-		name: "compatibilityDate",
-		initializer: `'${today}'`
-	});
-	const nitroInitializer = `{
+	try {
+		const project = new Project({ manipulationSettings: {
+			indentationText: IndentationText.TwoSpaces,
+			quoteKind: QuoteKind.Double
+		} });
+		project.addSourceFileAtPath(nuxtConfigPath);
+		const sourceFile = project.getSourceFileOrThrow(nuxtConfigPath);
+		const exportAssignment = sourceFile.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 nitroProp = configObj.getProperty("nitro");
-	if (nitroProp && nitroProp.getKind() === SyntaxKind.PropertyAssignment) nitroProp.setInitializer(nitroInitializer);
-	else configObj.addPropertyAssignment({
-		name: "nitro",
-		initializer: nitroInitializer
-	});
-	const modulesProp = configObj.getProperty("modules");
+  }`
+			});
+			const modulesProperty = configObject.getProperty("modules");
+			if (modulesProperty && Node.isPropertyAssignment(modulesProperty)) {
+				const initializer = modulesProperty.getInitializer();
+				if (Node.isArrayLiteralExpression(initializer)) {
+					const hasModule = initializer.getElements().some((el) => el.getText() === "\"nitro-cloudflare-dev\"" || el.getText() === "'nitro-cloudflare-dev'");
+					if (!hasModule) 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) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"@cloudflare/vite-plugin",
+			"dotenv"
+		],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	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/react-router");
+		if (!alchemyImport) sourceFile.addImportDeclaration({
+			moduleSpecifier: "alchemy/cloudflare/react-router",
+			defaultImport: "alchemy"
+		});
+		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)) {
+					const hasCloudflarePlugin = initializer.getElements().some((el) => el.getText().includes("cloudflare("));
+					if (!hasCloudflarePlugin) initializer.addElement("alchemy()");
+				}
+			} else if (!pluginsProperty) configObject.addPropertyAssignment({
+				name: "plugins",
+				initializer: "[alchemy()]"
+			});
+		}
+		await project.save();
+	} catch (error) {
+		console.warn("Failed to update vite.config.ts:", error);
+	}
+	const reactRouterConfigPath = path.join(webAppDir, "react-router.config.ts");
+	if (await fs.pathExists(reactRouterConfigPath)) try {
+		const project = new Project({ manipulationSettings: {
+			indentationText: IndentationText.TwoSpaces,
+			quoteKind: QuoteKind.Double
+		} });
+		project.addSourceFileAtPath(reactRouterConfigPath);
+		const sourceFile = project.getSourceFileOrThrow(reactRouterConfigPath);
+		const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
+		if (!exportAssignment) return;
+		const configExpression = exportAssignment.getExpression();
+		let configObject;
+		if (Node.isObjectLiteralExpression(configExpression)) configObject = configExpression;
+		else if (Node.isSatisfiesExpression(configExpression)) {
+			const expression = configExpression.getExpression();
+			if (Node.isObjectLiteralExpression(expression)) configObject = expression;
+		}
+		if (!configObject || !Node.isObjectLiteralExpression(configObject)) return;
+		const futureProperty = configObject.getProperty("future");
+		if (!futureProperty) configObject.addPropertyAssignment({
+			name: "future",
+			initializer: `{
+    unstable_viteEnvironmentApi: true,
+  }`
+		});
+		else if (Node.isPropertyAssignment(futureProperty)) {
+			const futureInitializer = futureProperty.getInitializer();
+			if (Node.isObjectLiteralExpression(futureInitializer)) {
+				const viteEnvApiProp = futureInitializer.getProperty("unstable_viteEnvironmentApi");
+				if (!viteEnvApiProp) futureInitializer.addPropertyAssignment({
+					name: "unstable_viteEnvironmentApi",
+					initializer: "true"
+				});
+				else if (Node.isPropertyAssignment(viteEnvApiProp)) {
+					const value = viteEnvApiProp.getInitializer()?.getText();
+					if (value === "false") viteEnvApiProp.setInitializer("true");
+				}
+			}
+		}
+		await project.save();
+	} catch (error) {
+		console.warn("Failed to update react-router.config.ts:", error);
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-solid-setup.ts
+async function setupSolidAlchemyDeploy(projectDir, _packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: ["alchemy", "dotenv"],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-svelte-setup.ts
+async function setupSvelteAlchemyDeploy(projectDir, _packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"@sveltejs/adapter-cloudflare",
+			"dotenv"
+		],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	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 importDeclarations = sourceFile.getImportDeclarations();
+		const adapterImport = importDeclarations.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) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: ["alchemy", "dotenv"],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-tanstack-start-setup.ts
+async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"nitropack",
+			"dotenv"
+		],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	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)) {
+			if (!configObject.getProperty("build")) configObject.addPropertyAssignment({
+				name: "build",
+				initializer: `{
+    target: "esnext",
+    rollupOptions: {
+      external: ["node:async_hooks", "cloudflare:workers"],
+    },
+  }`
+			});
+			const pluginsProperty = configObject.getProperty("plugins");
+			if (pluginsProperty && Node.isPropertyAssignment(pluginsProperty)) {
+				const initializer = pluginsProperty.getInitializer();
+				if (Node.isArrayLiteralExpression(initializer)) {
+					const hasShim = initializer.getElements().some((el) => el.getText().includes("alchemy"));
+					if (!hasShim) initializer.addElement("alchemy()");
+					const tanstackElements = initializer.getElements().filter((el) => el.getText().includes("tanstackStart"));
+					tanstackElements.forEach((element) => {
+						if (Node.isCallExpression(element)) {
+							const args = element.getArguments();
+							if (args.length === 0) element.addArgument(`{
+      target: "cloudflare-module",
+      customViteReactPlugin: true,
+    }`);
+							else if (args.length === 1 && Node.isObjectLiteralExpression(args[0])) {
+								const configObj = args[0];
+								if (!configObj.getProperty("target")) configObj.addPropertyAssignment({
+									name: "target",
+									initializer: "\"cloudflare-module\""
+								});
+								if (!configObj.getProperty("customViteReactPlugin")) configObj.addPropertyAssignment({
+									name: "customViteReactPlugin",
+									initializer: "true"
+								});
+							}
+						}
+					});
+				}
+			} else configObject.addPropertyAssignment({
+				name: "plugins",
+				initializer: "[alchemy()]"
+			});
+		}
+		await project.save();
+	} catch (error) {
+		console.warn("Failed to update vite.config.ts:", error);
+	}
+	const nitroConfigPath = path.join(webAppDir, "nitro.config.ts");
+	const nitroConfigContent = `import { defineNitroConfig } from "nitropack/config";
+
+export default defineNitroConfig({
+    preset: "cloudflare-module",
+    cloudflare: {
+        nodeCompat: true,
+    },
+});
+`;
+	await fs.writeFile(nitroConfigPath, nitroConfigContent, "utf-8");
+}
+
+//#endregion
+//#region src/helpers/deployment/alchemy/alchemy-combined-setup.ts
+async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
+	await addPackageDependency({
+		devDependencies: ["alchemy", "dotenv"],
+		projectDir
+	});
+	const rootPkgPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(rootPkgPath)) {
+		const pkg = await fs.readJson(rootPkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
+		};
+		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
+	}
+	const serverDir = path.join(projectDir, "apps/server");
+	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, packageManager);
+	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);
+	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);
+}
+
+//#endregion
+//#region src/helpers/deployment/workers/workers-next-setup.ts
+async function setupNextWorkersDeploy(projectDir, _packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		dependencies: ["@opennextjs/cloudflare"],
+		devDependencies: ["wrangler"],
+		projectDir: webAppDir
+	});
+	const packageJsonPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const pkg = await fs.readJson(packageJsonPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
+			deploy: "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
+			upload: "opennextjs-cloudflare build && opennextjs-cloudflare upload",
+			"cf-typegen": "wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts"
+		};
+		await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/workers/workers-nuxt-setup.ts
+async function setupNuxtWorkersDeploy(projectDir, packageManager) {
+	const webAppDir = path.join(projectDir, "apps/web");
+	if (!await fs.pathExists(webAppDir)) return;
+	await addPackageDependency({
+		devDependencies: ["nitro-cloudflare-dev", "wrangler"],
+		projectDir: webAppDir
+	});
+	const pkgPath = path.join(webAppDir, "package.json");
+	if (await fs.pathExists(pkgPath)) {
+		const pkg = await fs.readJson(pkgPath);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: `${packageManager} run build && wrangler deploy`,
+			"cf-typegen": "wrangler types"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
+	if (!await fs.pathExists(nuxtConfigPath)) return;
+	const sourceFile = tsProject.addSourceFileAtPathIfExists(nuxtConfigPath);
+	if (!sourceFile) return;
+	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
+		const expression = expr.getExpression();
+		return Node.isIdentifier(expression) && expression.getText() === "defineNuxtConfig";
+	});
+	if (!defineCall) return;
+	const configObj = defineCall.getArguments()[0];
+	if (!configObj) return;
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const compatProp = configObj.getProperty("compatibilityDate");
+	if (compatProp && compatProp.getKind() === SyntaxKind.PropertyAssignment) compatProp.setInitializer(`'${today}'`);
+	else configObj.addPropertyAssignment({
+		name: "compatibilityDate",
+		initializer: `'${today}'`
+	});
+	const nitroInitializer = `{
+    preset: "cloudflare_module",
+    cloudflare: {
+      deployConfig: true,
+      nodeCompat: true
+    }
+  }`;
+	const nitroProp = configObj.getProperty("nitro");
+	if (nitroProp && nitroProp.getKind() === SyntaxKind.PropertyAssignment) nitroProp.setInitializer(nitroInitializer);
+	else configObj.addPropertyAssignment({
+		name: "nitro",
+		initializer: nitroInitializer
+	});
+	const modulesProp = configObj.getProperty("modules");
 	if (modulesProp && modulesProp.getKind() === SyntaxKind.PropertyAssignment) {
 		const arrayExpr = modulesProp.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
 		if (arrayExpr) {
@@ -2715,7 +3567,7 @@ async function setupNuxtWorkersDeploy(projectDir, packageManager) {
 }
 
 //#endregion
-//#region src/helpers/setup/workers-svelte-setup.ts
+//#region src/helpers/deployment/workers/workers-svelte-setup.ts
 async function setupSvelteWorkersDeploy(projectDir, packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
@@ -2752,7 +3604,7 @@ async function setupSvelteWorkersDeploy(projectDir, packageManager) {
 }
 
 //#endregion
-//#region src/helpers/setup/workers-tanstack-start-setup.ts
+//#region src/helpers/deployment/workers/workers-tanstack-start-setup.ts
 async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
@@ -2790,7 +3642,7 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 }
 
 //#endregion
-//#region src/helpers/setup/workers-vite-setup.ts
+//#region src/helpers/deployment/workers/workers-vite-setup.ts
 async function setupWorkersVitePlugin(projectDir) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
@@ -2821,12 +3673,16 @@ async function setupWorkersVitePlugin(projectDir) {
 }
 
 //#endregion
-//#region src/helpers/setup/web-deploy-setup.ts
+//#region src/helpers/deployment/web-deploy-setup.ts
 async function setupWebDeploy(config) {
-	const { webDeploy, frontend, projectDir } = config;
+	const { webDeploy, serverDeploy, frontend, projectDir } = config;
 	const { packageManager } = config;
 	if (webDeploy === "none") return;
-	if (webDeploy !== "workers") return;
+	if (webDeploy !== "wrangler" && webDeploy !== "alchemy") return;
+	if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
+		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
+		return;
+	}
 	const isNext = frontend.includes("next");
 	const isNuxt = frontend.includes("nuxt");
 	const isSvelte = frontend.includes("svelte");
@@ -2834,11 +3690,21 @@ async function setupWebDeploy(config) {
 	const isTanstackStart = frontend.includes("tanstack-start");
 	const isReactRouter = frontend.includes("react-router");
 	const isSolid = frontend.includes("solid");
-	if (isNext) await setupNextWorkersDeploy(projectDir, packageManager);
-	else if (isNuxt) await setupNuxtWorkersDeploy(projectDir, packageManager);
-	else if (isSvelte) await setupSvelteWorkersDeploy(projectDir, packageManager);
-	else if (isTanstackStart) await setupTanstackStartWorkersDeploy(projectDir, packageManager);
-	else if (isTanstackRouter || isReactRouter || isSolid) await setupWorkersWebDeploy(projectDir, packageManager);
+	if (webDeploy === "wrangler") {
+		if (isNext) await setupNextWorkersDeploy(projectDir, packageManager);
+		else if (isNuxt) await setupNuxtWorkersDeploy(projectDir, packageManager);
+		else if (isSvelte) await setupSvelteWorkersDeploy(projectDir, packageManager);
+		else if (isTanstackStart) await setupTanstackStartWorkersDeploy(projectDir, packageManager);
+		else if (isTanstackRouter || isReactRouter || isSolid) await setupWorkersWebDeploy(projectDir, packageManager);
+	} else if (webDeploy === "alchemy") {
+		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);
+	}
 }
 async function setupWorkersWebDeploy(projectDir, pkgManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
@@ -2855,30 +3721,9 @@ async function setupWorkersWebDeploy(projectDir, pkgManager) {
 	}
 	await setupWorkersVitePlugin(projectDir);
 }
-async function setupNextWorkersDeploy(projectDir, _packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		dependencies: ["@opennextjs/cloudflare"],
-		devDependencies: ["wrangler"],
-		projectDir: webAppDir
-	});
-	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const pkg = await fs.readJson(packageJsonPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
-			deploy: "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
-			upload: "opennextjs-cloudflare build && opennextjs-cloudflare upload",
-			"cf-typegen": "wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts"
-		};
-		await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
-	}
-}
 
 //#endregion
-//#region src/helpers/project-generation/add-deployment.ts
+//#region src/helpers/core/add-deployment.ts
 async function addDeploymentToProject(input) {
 	try {
 		const projectDir = input.projectDir || process.cwd();
@@ -2886,7 +3731,8 @@ async function addDeploymentToProject(input) {
 		if (!isBetterTStack) exitWithError("This doesn't appear to be a Better-T Stack project. Please run this command from the root of a Better-T Stack project.");
 		const detectedConfig = await detectProjectConfig(projectDir);
 		if (!detectedConfig) exitWithError("Could not detect the project configuration. Please ensure this is a valid Better-T Stack project.");
-		if (detectedConfig.webDeploy === input.webDeploy) exitWithError(`${input.webDeploy} deployment is already configured for this 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,
@@ -2903,224 +3749,79 @@ async function addDeploymentToProject(input) {
 			packageManager: input.packageManager || detectedConfig.packageManager || "npm",
 			install: input.install || false,
 			dbSetup: detectedConfig.dbSetup || "none",
-			api: detectedConfig.api || "none",
-			webDeploy: input.webDeploy
-		};
-		log.info(pc.green(`Adding ${input.webDeploy} deployment to ${config.frontend.join("/")}`));
-		await setupDeploymentTemplates(projectDir, config);
-		await setupWebDeploy(config);
-		await updateBtsConfig(projectDir, { webDeploy: input.webDeploy });
-		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) {
-		const message = error instanceof Error ? error.message : String(error);
-		exitWithError(`Error adding deployment: ${message}`);
-	}
-}
-
-//#endregion
-//#region src/helpers/setup/api-setup.ts
-async function setupApi(config) {
-	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
-	const isConvex = backend === "convex";
-	const webDir = path.join(projectDir, "apps/web");
-	const nativeDir = path.join(projectDir, "apps/native");
-	const webDirExists = await fs.pathExists(webDir);
-	const nativeDirExists = await fs.pathExists(nativeDir);
-	const hasReactWeb = frontend.some((f) => [
-		"tanstack-router",
-		"react-router",
-		"tanstack-start",
-		"next"
-	].includes(f));
-	const hasNuxtWeb = frontend.includes("nuxt");
-	const hasSvelteWeb = frontend.includes("svelte");
-	const hasSolidWeb = frontend.includes("solid");
-	if (!isConvex && api !== "none") {
-		const serverDir = path.join(projectDir, "apps/server");
-		const serverDirExists = await fs.pathExists(serverDir);
-		if (serverDirExists) {
-			if (api === "orpc") await addPackageDependency({
-				dependencies: ["@orpc/server", "@orpc/client"],
-				projectDir: serverDir
-			});
-			else if (api === "trpc") {
-				await addPackageDependency({
-					dependencies: ["@trpc/server", "@trpc/client"],
-					projectDir: serverDir
-				});
-				if (config.backend === "hono") await addPackageDependency({
-					dependencies: ["@hono/trpc-server"],
-					projectDir: serverDir
-				});
-				else if (config.backend === "elysia") await addPackageDependency({
-					dependencies: ["@elysiajs/trpc"],
-					projectDir: serverDir
-				});
-			}
-		}
-		if (webDirExists) {
-			if (hasReactWeb) {
-				if (api === "orpc") await addPackageDependency({
-					dependencies: ["@orpc/tanstack-query", "@orpc/client"],
-					projectDir: webDir
-				});
-				else if (api === "trpc") await addPackageDependency({
-					dependencies: [
-						"@trpc/tanstack-react-query",
-						"@trpc/client",
-						"@trpc/server"
-					],
-					projectDir: webDir
-				});
-			} else if (hasNuxtWeb) {
-				if (api === "orpc") await addPackageDependency({
-					dependencies: [
-						"@tanstack/vue-query",
-						"@tanstack/vue-query-devtools",
-						"@orpc/tanstack-query",
-						"@orpc/client"
-					],
-					projectDir: webDir
-				});
-			} else if (hasSvelteWeb) {
-				if (api === "orpc") await addPackageDependency({
-					dependencies: [
-						"@orpc/tanstack-query",
-						"@orpc/client",
-						"@tanstack/svelte-query"
-					],
-					projectDir: webDir
-				});
-			} else if (hasSolidWeb) {
-				if (api === "orpc") await addPackageDependency({
-					dependencies: [
-						"@orpc/tanstack-query",
-						"@orpc/client",
-						"@tanstack/solid-query"
-					],
-					projectDir: webDir
-				});
-			}
-		}
-		if (nativeDirExists) {
-			if (api === "trpc") await addPackageDependency({
-				dependencies: [
-					"@trpc/tanstack-react-query",
-					"@trpc/client",
-					"@trpc/server"
-				],
-				projectDir: nativeDir
-			});
-			else if (api === "orpc") await addPackageDependency({
-				dependencies: ["@orpc/tanstack-query", "@orpc/client"],
-				projectDir: nativeDir
-			});
-		}
-	}
-	const reactBasedFrontends = [
-		"react-router",
-		"tanstack-router",
-		"tanstack-start",
-		"next",
-		"native-nativewind",
-		"native-unistyles"
-	];
-	const needsSolidQuery = frontend.includes("solid");
-	const needsReactQuery = frontend.some((f) => reactBasedFrontends.includes(f));
-	if (needsReactQuery && !isConvex) {
-		const reactQueryDeps = ["@tanstack/react-query"];
-		const reactQueryDevDeps = ["@tanstack/react-query-devtools"];
-		const hasReactWeb$1 = frontend.some((f) => f !== "native-nativewind" && f !== "native-unistyles" && reactBasedFrontends.includes(f));
-		const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
-		if (hasReactWeb$1 && webDirExists) {
-			const webPkgJsonPath = path.join(webDir, "package.json");
-			if (await fs.pathExists(webPkgJsonPath)) try {
-				await addPackageDependency({
-					dependencies: reactQueryDeps,
-					devDependencies: reactQueryDevDeps,
-					projectDir: webDir
-				});
-			} catch (_error) {}
-		}
-		if (hasNative && nativeDirExists) {
-			const nativePkgJsonPath = path.join(nativeDir, "package.json");
-			if (await fs.pathExists(nativePkgJsonPath)) try {
-				await addPackageDependency({
-					dependencies: reactQueryDeps,
-					projectDir: nativeDir
-				});
-			} catch (_error) {}
-		}
-	}
-	if (needsSolidQuery && !isConvex) {
-		const solidQueryDeps = ["@tanstack/solid-query"];
-		const solidQueryDevDeps = ["@tanstack/solid-query-devtools"];
-		if (webDirExists) {
-			const webPkgJsonPath = path.join(webDir, "package.json");
-			if (await fs.pathExists(webPkgJsonPath)) try {
-				await addPackageDependency({
-					dependencies: solidQueryDeps,
-					devDependencies: solidQueryDevDeps,
-					projectDir: webDir
-				});
-			} catch (_error) {}
-		}
-	}
-	if (isConvex) {
-		if (webDirExists) {
-			const webPkgJsonPath = path.join(webDir, "package.json");
-			if (await fs.pathExists(webPkgJsonPath)) try {
-				const webDepsToAdd = ["convex"];
-				if (frontend.includes("tanstack-start")) webDepsToAdd.push("@convex-dev/react-query");
-				if (hasSvelteWeb) webDepsToAdd.push("convex-svelte");
-				if (hasNuxtWeb) {
-					webDepsToAdd.push("convex-nuxt");
-					webDepsToAdd.push("convex-vue");
-				}
-				await addPackageDependency({
-					dependencies: webDepsToAdd,
-					projectDir: webDir
-				});
-			} catch (_error) {}
-		}
-		if (nativeDirExists) {
-			const nativePkgJsonPath = path.join(nativeDir, "package.json");
-			if (await fs.pathExists(nativePkgJsonPath)) try {
-				await addPackageDependency({
-					dependencies: ["convex"],
-					projectDir: nativeDir
-				});
-			} catch (_error) {}
-		}
-		const backendPackageName = `@${projectName}/backend`;
-		const backendWorkspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
-		const addWorkspaceDepManually = async (pkgJsonPath, depName, depVersion) => {
-			try {
-				const pkgJson = await fs.readJson(pkgJsonPath);
-				if (!pkgJson.dependencies) pkgJson.dependencies = {};
-				if (pkgJson.dependencies[depName] !== depVersion) {
-					pkgJson.dependencies[depName] = depVersion;
-					await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
-				}
-			} catch (_error) {}
+			api: detectedConfig.api || "none",
+			webDeploy: input.webDeploy || detectedConfig.webDeploy || "none",
+			serverDeploy: input.serverDeploy || detectedConfig.serverDeploy || "none"
 		};
-		if (webDirExists) {
-			const webPkgJsonPath = path.join(webDir, "package.json");
-			if (await fs.pathExists(webPkgJsonPath)) await addWorkspaceDepManually(webPkgJsonPath, backendPackageName, backendWorkspaceVersion);
-		}
-		if (nativeDirExists) {
-			const nativePkgJsonPath = path.join(nativeDir, "package.json");
-			if (await fs.pathExists(nativePkgJsonPath)) await addWorkspaceDepManually(nativePkgJsonPath, backendPackageName, backendWorkspaceVersion);
-		}
+		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) {
+		const message = error instanceof Error ? error.message : String(error);
+		exitWithError(`Error adding deployment: ${message}`);
 	}
 }
 
 //#endregion
-//#region src/helpers/setup/auth-setup.ts
+//#region src/utils/format-with-biome.ts
+async function formatProjectWithBiome(projectDir) {
+	const biome = new Biome();
+	const { projectKey } = biome.openProject(projectDir);
+	biome.applyConfiguration(projectKey, {
+		formatter: {
+			enabled: true,
+			indentStyle: "tab"
+		},
+		javascript: { formatter: { quoteStyle: "double" } }
+	});
+	const files = await glob("**/*", {
+		cwd: projectDir,
+		dot: true,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const filePath of files) try {
+		const ext = path.extname(filePath).toLowerCase();
+		const supported = new Set([
+			".ts",
+			".tsx",
+			".js",
+			".jsx",
+			".cjs",
+			".mjs",
+			".cts",
+			".mts",
+			".json",
+			".jsonc",
+			".md",
+			".mdx",
+			".css",
+			".scss",
+			".html"
+		]);
+		if (!supported.has(ext)) continue;
+		const original = await fs.readFile(filePath, "utf8");
+		const result = biome.formatContent(projectKey, original, { filePath });
+		const content = result?.content;
+		if (typeof content !== "string") continue;
+		if (content.length === 0 && original.length > 0) continue;
+		if (content !== original) await fs.writeFile(filePath, content);
+	} catch {}
+}
+
+//#endregion
+//#region src/helpers/addons/auth-setup.ts
 async function setupAuth(config) {
 	const { auth, frontend, backend, projectDir } = config;
 	if (backend === "convex" || !auth) return;
@@ -3172,7 +3873,217 @@ function generateAuthSecret(length = 32) {
 }
 
 //#endregion
-//#region src/helpers/setup/backend-setup.ts
+//#region src/helpers/addons/examples-setup.ts
+async function setupExamples(config) {
+	const { examples, frontend, backend, projectDir } = config;
+	if (backend === "convex" || !examples || examples.length === 0 || examples[0] === "none") return;
+	if (examples.includes("ai")) {
+		const webClientDir = path.join(projectDir, "apps/web");
+		const nativeClientDir = path.join(projectDir, "apps/native");
+		const serverDir = path.join(projectDir, "apps/server");
+		const webClientDirExists = await fs.pathExists(webClientDir);
+		const nativeClientDirExists = await fs.pathExists(nativeClientDir);
+		const serverDirExists = await fs.pathExists(serverDir);
+		const hasNuxt = frontend.includes("nuxt");
+		const hasSvelte = frontend.includes("svelte");
+		const hasReactWeb = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next") || frontend.includes("tanstack-start");
+		const hasReactNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+		if (webClientDirExists) {
+			const dependencies = ["ai"];
+			if (hasNuxt) dependencies.push("@ai-sdk/vue");
+			else if (hasSvelte) dependencies.push("@ai-sdk/svelte");
+			else if (hasReactWeb) dependencies.push("@ai-sdk/react");
+			await addPackageDependency({
+				dependencies,
+				projectDir: webClientDir
+			});
+		}
+		if (nativeClientDirExists && hasReactNative) await addPackageDependency({
+			dependencies: ["ai", "@ai-sdk/react"],
+			projectDir: nativeClientDir
+		});
+		if (serverDirExists && backend !== "none") await addPackageDependency({
+			dependencies: ["ai", "@ai-sdk/google"],
+			projectDir: serverDir
+		});
+	}
+}
+
+//#endregion
+//#region src/helpers/core/api-setup.ts
+async function addBackendWorkspaceDependency(projectDir, backendPackageName, workspaceVersion) {
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	try {
+		const pkgJson = await fs.readJson(pkgJsonPath);
+		if (!pkgJson.dependencies) pkgJson.dependencies = {};
+		pkgJson.dependencies[backendPackageName] = workspaceVersion;
+		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	} catch (_error) {}
+}
+function getFrontendType(frontend) {
+	const reactBasedFrontends = [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next"
+	];
+	const nativeFrontends = ["native-nativewind", "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) {
+	const deps = {};
+	if (api === "orpc") deps.server = { dependencies: ["@orpc/server", "@orpc/client"] };
+	else if (api === "trpc") deps.server = { dependencies: ["@trpc/server", "@trpc/client"] };
+	if (frontendType.hasReactWeb) {
+		if (api === "orpc") deps.web = { dependencies: ["@orpc/tanstack-query", "@orpc/client"] };
+		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"
+		],
+		devDependencies: ["@tanstack/vue-query-devtools"]
+	};
+	else if (frontendType.hasSvelteWeb && api === "orpc") deps.web = {
+		dependencies: [
+			"@orpc/tanstack-query",
+			"@orpc/client",
+			"@tanstack/svelte-query"
+		],
+		devDependencies: ["@tanstack/svelte-query-devtools"]
+	};
+	else if (frontendType.hasSolidWeb && api === "orpc") deps.web = {
+		dependencies: [
+			"@orpc/tanstack-query",
+			"@orpc/client",
+			"@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-nativewind",
+		"native-unistyles"
+	];
+	const deps = {};
+	const needsReactQuery = frontend.some((f) => reactBasedFrontends.includes(f));
+	if (needsReactQuery) {
+		const hasReactWeb = frontend.some((f) => f !== "native-nativewind" && f !== "native-unistyles" && reactBasedFrontends.includes(f));
+		const hasNative = frontend.includes("native-nativewind") || 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");
+	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, projectName, frontend, backend, packageManager, projectDir } = config;
+	const isConvex = backend === "convex";
+	const webDir = path.join(projectDir, "apps/web");
+	const nativeDir = path.join(projectDir, "apps/native");
+	const serverDir = path.join(projectDir, "apps/server");
+	const webDirExists = await fs.pathExists(webDir);
+	const nativeDirExists = await fs.pathExists(nativeDir);
+	const serverDirExists = await fs.pathExists(serverDir);
+	const frontendType = getFrontendType(frontend);
+	if (!isConvex && api !== "none") {
+		const apiDeps = getApiDependencies(api, frontendType);
+		if (serverDirExists && apiDeps.server) {
+			await addPackageDependency({
+				dependencies: apiDeps.server.dependencies,
+				projectDir: serverDir
+			});
+			if (api === "trpc") {
+				if (backend === "hono") await addPackageDependency({
+					dependencies: ["@hono/trpc-server"],
+					projectDir: serverDir
+				});
+				else if (backend === "elysia") await addPackageDependency({
+					dependencies: ["@elysiajs/trpc"],
+					projectDir: serverDir
+				});
+			}
+		}
+		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
+		});
+	}
+	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
+		});
+		const backendPackageName = `@${projectName}/backend`;
+		const backendWorkspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
+		if (webDirExists) await addBackendWorkspaceDependency(webDir, backendPackageName, backendWorkspaceVersion);
+		if (nativeDirExists) await addBackendWorkspaceDependency(nativeDir, backendPackageName, backendWorkspaceVersion);
+	}
+}
+
+//#endregion
+//#region src/helpers/core/backend-setup.ts
 async function setupBackendDependencies(config) {
 	const { backend, runtime, api, projectDir } = config;
 	if (backend === "convex") return;
@@ -3211,7 +4122,7 @@ async function setupBackendDependencies(config) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/env-setup.ts
+//#region src/helpers/core/env-setup.ts
 async function addEnvVariablesToFile(filePath, variables) {
 	await fs.ensureDir(path.dirname(filePath));
 	let envContent = "";
@@ -3259,7 +4170,7 @@ async function addEnvVariablesToFile(filePath, variables) {
 	if (exampleModified || !await fs.pathExists(exampleFilePath)) await fs.writeFile(exampleFilePath, exampleEnvContent.trimEnd());
 }
 async function setupEnvironmentVariables(config) {
-	const { backend, frontend, database, auth, examples, dbSetup, projectDir } = config;
+	const { 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");
@@ -3359,39 +4270,69 @@ async function setupEnvironmentVariables(config) {
 		}
 	];
 	await addEnvVariablesToFile(envPath, serverVars);
-	if (config.runtime === "workers") {
-		const devVarsPath = path.join(serverDir, ".dev.vars");
-		try {
-			await fs.copy(envPath, devVarsPath);
-		} catch (_err) {}
+	const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
+	const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
+	if (isUnifiedAlchemy) {
+		const rootEnvPath = path.join(projectDir, ".env");
+		const rootAlchemyVars = [{
+			key: "ALCHEMY_PASSWORD",
+			value: "please-change-this",
+			condition: true
+		}];
+		await addEnvVariablesToFile(rootEnvPath, rootAlchemyVars);
+	} else if (isIndividualAlchemy) {
+		if (webDeploy === "alchemy") {
+			const webDir = path.join(projectDir, "apps/web");
+			if (await fs.pathExists(webDir)) {
+				const webAlchemyVars = [{
+					key: "ALCHEMY_PASSWORD",
+					value: "please-change-this",
+					condition: true
+				}];
+				await addEnvVariablesToFile(path.join(webDir, ".env"), webAlchemyVars);
+			}
+		}
+		if (serverDeploy === "alchemy") {
+			const serverDir$1 = path.join(projectDir, "apps/server");
+			if (await fs.pathExists(serverDir$1)) {
+				const serverAlchemyVars = [{
+					key: "ALCHEMY_PASSWORD",
+					value: "please-change-this",
+					condition: true
+				}];
+				await addEnvVariablesToFile(path.join(serverDir$1, ".env"), serverAlchemyVars);
+			}
+		}
 	}
 }
 
 //#endregion
 //#region src/helpers/database-providers/d1-setup.ts
 async function setupCloudflareD1(config) {
-	const { projectDir } = config;
-	const envPath = path.join(projectDir, "apps/server", ".env");
-	const variables = [
-		{
-			key: "CLOUDFLARE_ACCOUNT_ID",
-			value: "",
-			condition: true
-		},
-		{
-			key: "CLOUDFLARE_DATABASE_ID",
-			value: "",
-			condition: true
-		},
-		{
-			key: "CLOUDFLARE_D1_TOKEN",
-			value: "",
-			condition: true
-		}
-	];
-	try {
-		await addEnvVariablesToFile(envPath, variables);
-	} catch (_err) {}
+	const { projectDir, serverDeploy } = config;
+	if (serverDeploy === "wrangler") {
+		const envPath = path.join(projectDir, "apps/server", ".env");
+		const variables = [
+			{
+				key: "CLOUDFLARE_ACCOUNT_ID",
+				value: "",
+				condition: true
+			},
+			{
+				key: "CLOUDFLARE_DATABASE_ID",
+				value: "",
+				condition: true
+			},
+			{
+				key: "CLOUDFLARE_D1_TOKEN",
+				value: "",
+				condition: true
+			}
+		];
+		try {
+			await addEnvVariablesToFile(envPath, variables);
+		} catch (_err) {}
+	}
 }
 
 //#endregion
@@ -3839,8 +4780,10 @@ async function setupPrismaPostgres(config) {
 		else prismaConfig = await initPrismaDatabase(serverDir, packageManager);
 		if (prismaConfig) {
 			await writeEnvFile$1(projectDir, prismaConfig);
-			await addDotenvImportToPrismaConfig(projectDir);
-			if (orm === "prisma") await addPrismaAccelerateExtension(serverDir);
+			if (orm === "prisma") {
+				await addDotenvImportToPrismaConfig(projectDir);
+				await addPrismaAccelerateExtension(serverDir);
+			}
 			log.success(pc.green("Prisma Postgres database configured successfully!"));
 		} else {
 			await writeEnvFile$1(projectDir);
@@ -4185,7 +5128,7 @@ async function setupTurso(config) {
 }
 
 //#endregion
-//#region src/helpers/setup/db-setup.ts
+//#region src/helpers/core/db-setup.ts
 async function setupDatabase(config) {
 	const { database, orm, dbSetup, backend, projectDir } = config;
 	if (backend === "convex" || database === "none") {
@@ -4250,44 +5193,7 @@ async function setupDatabase(config) {
 }
 
 //#endregion
-//#region src/helpers/setup/examples-setup.ts
-async function setupExamples(config) {
-	const { examples, frontend, backend, projectDir } = config;
-	if (backend === "convex" || !examples || examples.length === 0 || examples[0] === "none") return;
-	if (examples.includes("ai")) {
-		const webClientDir = path.join(projectDir, "apps/web");
-		const nativeClientDir = path.join(projectDir, "apps/native");
-		const serverDir = path.join(projectDir, "apps/server");
-		const webClientDirExists = await fs.pathExists(webClientDir);
-		const nativeClientDirExists = await fs.pathExists(nativeClientDir);
-		const serverDirExists = await fs.pathExists(serverDir);
-		const hasNuxt = frontend.includes("nuxt");
-		const hasSvelte = frontend.includes("svelte");
-		const hasReactWeb = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next") || frontend.includes("tanstack-start");
-		const hasReactNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
-		if (webClientDirExists) {
-			const dependencies = ["ai"];
-			if (hasNuxt) dependencies.push("@ai-sdk/vue");
-			else if (hasSvelte) dependencies.push("@ai-sdk/svelte");
-			else if (hasReactWeb) dependencies.push("@ai-sdk/react");
-			await addPackageDependency({
-				dependencies,
-				projectDir: webClientDir
-			});
-		}
-		if (nativeClientDirExists && hasReactNative) await addPackageDependency({
-			dependencies: ["ai", "@ai-sdk/react"],
-			projectDir: nativeClientDir
-		});
-		if (serverDirExists && backend !== "none") await addPackageDependency({
-			dependencies: ["ai", "@ai-sdk/google"],
-			projectDir: serverDir
-		});
-	}
-}
-
-//#endregion
-//#region src/helpers/setup/runtime-setup.ts
+//#region src/helpers/core/runtime-setup.ts
 async function setupRuntime(config) {
 	const { runtime, backend, projectDir } = config;
 	if (backend === "convex" || backend === "next" || runtime === "none") return;
@@ -4295,23 +5201,6 @@ async function setupRuntime(config) {
 	if (!await fs.pathExists(serverDir)) return;
 	if (runtime === "bun") await setupBunRuntime(serverDir, backend);
 	else if (runtime === "node") await setupNodeRuntime(serverDir, backend);
-	else if (runtime === "workers") await setupWorkersRuntime(serverDir);
-}
-async function generateCloudflareWorkerTypes(config) {
-	if (config.runtime !== "workers") return;
-	const serverDir = path.join(config.projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
-	const s = spinner();
-	try {
-		s.start("Generating Cloudflare Workers types...");
-		const runCmd = config.packageManager === "npm" ? "npm" : config.packageManager;
-		await execa(runCmd, ["run", "cf-typegen"], { cwd: serverDir });
-		s.stop("Cloudflare Workers types generated successfully!");
-	} catch {
-		s.stop(pc.yellow("Failed to generate Cloudflare Workers types"));
-		const managerCmd = config.packageManager === "npm" ? "npm run" : `${config.packageManager} run`;
-		console.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
-	}
 }
 async function setupBunRuntime(serverDir, _backend) {
 	const packageJsonPath = path.join(serverDir, "package.json");
@@ -4351,27 +5240,20 @@ async function setupNodeRuntime(serverDir, backend) {
 		projectDir: serverDir
 	});
 }
-async function setupWorkersRuntime(serverDir) {
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return;
-	const packageJson = await fs.readJson(packageJsonPath);
-	packageJson.scripts = {
-		...packageJson.scripts,
-		dev: "wrangler dev --port=3000",
-		start: "wrangler dev",
-		deploy: "wrangler deploy",
-		build: "wrangler deploy --dry-run",
-		"cf-typegen": "wrangler types --env-interface CloudflareBindings"
-	};
-	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	await addPackageDependency({
-		devDependencies: ["wrangler", "@types/node"],
-		projectDir: serverDir
+
+//#endregion
+//#region src/helpers/core/convex-codegen.ts
+async function runConvexCodegen(projectDir, packageManager) {
+	const backendDir = path.join(projectDir, "packages/backend");
+	const cmd = getPackageExecutionCommand(packageManager, "convex codegen");
+	await execa(cmd, {
+		cwd: backendDir,
+		shell: true
 	});
 }
 
 //#endregion
-//#region src/helpers/project-generation/create-readme.ts
+//#region src/helpers/core/create-readme.ts
 async function createReadme(projectDir, options) {
 	const readmePath = path.join(projectDir, "README.md");
 	const content = generateReadmeContent(options);
@@ -4648,7 +5530,7 @@ function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNati
 }
 
 //#endregion
-//#region src/helpers/project-generation/git.ts
+//#region src/helpers/core/git.ts
 async function initializeGit(projectDir, useGit) {
 	if (!useGit) return;
 	const gitVersionResult = await $({
@@ -4724,20 +5606,21 @@ async function getDockerStatus(database) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/post-installation.ts
+//#region src/helpers/core/post-installation.ts
 async function displayPostInstallInstructions(config) {
-	const { database, relativePath, packageManager, depsInstalled, orm, addons, runtime, frontend, backend, dbSetup, webDeploy } = config;
+	const { database, relativePath, packageManager, depsInstalled, orm, addons, runtime, frontend, backend, dbSetup, webDeploy, serverDeploy } = config;
 	const isConvex = backend === "convex";
 	const runCmd = packageManager === "npm" ? "npm run" : packageManager;
 	const cdCmd = `cd ${relativePath}`;
 	const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
-	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) : "";
+	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy) : "";
 	const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
 	const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
 	const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
 	const pwaInstructions = addons?.includes("pwa") && frontend?.includes("react-router") ? getPwaInstructions() : "";
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
-	const workersDeployInstructions = webDeploy === "workers" ? getWorkersDeployInstructions(runCmd) : "";
+	const wranglerDeployInstructions = getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy);
+	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy);
 	const hasWeb = frontend?.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -4766,8 +5649,8 @@ async function displayPostInstallInstructions(config) {
 		if (runtime === "workers") {
 			if (dbSetup === "d1") output += `${pc.yellow("IMPORTANT:")} Complete D1 database setup first\n   (see Database commands below)\n`;
 			output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
-			output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} run cf-typegen\n\n`;
-		} else output += "\n";
+			if (serverDeploy === "wrangler") output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} cf-typegen\n`;
+		}
 	}
 	output += `${pc.bold("Your project will be available at:")}\n`;
 	if (hasWeb) output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
@@ -4780,7 +5663,8 @@ async function displayPostInstallInstructions(config) {
 	if (tauriInstructions) output += `\n${tauriInstructions.trim()}\n`;
 	if (lintingInstructions) output += `\n${lintingInstructions.trim()}\n`;
 	if (pwaInstructions) output += `\n${pwaInstructions.trim()}\n`;
-	if (workersDeployInstructions) output += `\n${workersDeployInstructions.trim()}\n`;
+	if (wranglerDeployInstructions) output += `\n${wranglerDeployInstructions.trim()}\n`;
+	if (alchemyDeployInstructions) output += `\n${alchemyDeployInstructions.trim()}\n`;
 	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
 	if (noOrmWarning) output += `\n${noOrmWarning.trim()}\n`;
 	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
@@ -4801,7 +5685,7 @@ function getNativeInstructions(isConvex) {
 function getLintingInstructions(runCmd) {
 	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
 }
-async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup) {
+async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup, serverDeploy) {
 	const instructions = [];
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
@@ -4810,7 +5694,7 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 			instructions.push("");
 		}
 	}
-	if (runtime === "workers" && dbSetup === "d1") {
+	if (serverDeploy === "wrangler" && dbSetup === "d1") {
 		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
 		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
 		instructions.push(`${pc.cyan("2.")} Create D1 database: ${pc.white(`${packageManager} wrangler d1 create your-database-name`)}`);
@@ -4818,8 +5702,8 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 		instructions.push(`${pc.cyan("4.")} Generate migrations: ${pc.white(`cd apps/server && ${packageManager} db:generate`)}`);
 		instructions.push(`${pc.cyan("5.")} Apply migrations locally: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME --local`)}`);
 		instructions.push(`${pc.cyan("6.")} Apply migrations to production: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME`)}`);
-		instructions.push("");
 	}
+	if (dbSetup === "d1" && serverDeploy === "alchemy") {}
 	if (orm === "prisma") {
 		if (dbSetup === "turso") instructions.push(`${pc.yellow("NOTE:")} Turso support with Prisma is in Early Access and requires\n   additional setup. Learn more at:\n   https://www.prisma.io/docs/orm/overview/databases/turso`);
 		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
@@ -4828,7 +5712,7 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 	} else if (orm === "drizzle") {
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
-		instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+		if (dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
 		instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 		if (database === "sqlite" && dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Start local DB (if needed): ${`cd apps/server && ${runCmd} db:local`}`);
 	} else if (orm === "mongoose") {
@@ -4851,12 +5735,22 @@ function getNoOrmWarning() {
 function getBunWebNativeWarning() {
 	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo.\n   Use 'pnpm' if problems arise.`;
 }
-function getWorkersDeployInstructions(runCmd) {
-	return `\n${pc.bold("Deploy frontend to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} run deploy`}`;
+function getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy) {
+	const instructions = [];
+	if (webDeploy === "wrangler") instructions.push(`${pc.bold("Deploy web to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} run deploy`}`);
+	if (serverDeploy === "wrangler") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} run deploy`}`);
+	return instructions.length ? `\n${instructions.join("\n")}` : "";
+}
+function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy) {
+	const instructions = [];
+	if (webDeploy === "alchemy" && serverDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy web to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}`);
+	else if (serverDeploy === "alchemy" && webDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy server to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}`);
+	else if (webDeploy === "alchemy" && serverDeploy === "alchemy") instructions.push(`${pc.bold("Deploy to Alchemy:")}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}`);
+	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
 //#endregion
-//#region src/helpers/project-generation/project-config.ts
+//#region src/helpers/core/project-config.ts
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
 	if (options.backend !== "convex") await updateServerPackageJson(projectDir, options);
@@ -5037,7 +5931,7 @@ async function updateConvexPackageJson(projectDir, options) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/create-project.ts
+//#region src/helpers/core/create-project.ts
 async function createProject(options) {
 	const projectDir = options.projectDir;
 	const isConvex = options.backend === "convex";
@@ -5065,18 +5959,18 @@ async function createProject(options) {
 		if (!isConvex && options.auth) await setupAuth(options);
 		await handleExtras(projectDir, options);
 		await setupWebDeploy(options);
+		await setupServerDeploy(options);
 		await setupEnvironmentVariables(options);
 		await updatePackageConfigurations(projectDir, options);
 		await createReadme(projectDir, options);
 		await writeBtsConfig(options);
+		await formatProjectWithBiome(projectDir);
+		if (isConvex) await runConvexCodegen(projectDir, options.packageManager);
 		log.success("Project template successfully scaffolded!");
-		if (options.install) {
-			await installDependencies({
-				projectDir,
-				packageManager: options.packageManager
-			});
-			await generateCloudflareWorkerTypes(options);
-		}
+		if (options.install) await installDependencies({
+			projectDir,
+			packageManager: options.packageManager
+		});
 		await initializeGit(projectDir, options.git);
 		await displayPostInstallInstructions({
 			...options,
@@ -5095,7 +5989,7 @@ async function createProject(options) {
 }
 
 //#endregion
-//#region src/helpers/project-generation/command-handlers.ts
+//#region src/helpers/core/command-handlers.ts
 async function createProjectHandler(input) {
 	const startTime = Date.now();
 	const timeScaffolded = (/* @__PURE__ */ new Date()).toISOString();
@@ -5105,10 +5999,11 @@ async function createProjectHandler(input) {
 	let currentPathInput;
 	if (input.yes && input.projectName) currentPathInput = input.projectName;
 	else if (input.yes) {
-		let defaultName = DEFAULT_CONFIG.relativePath;
+		const defaultConfig = getDefaultConfig();
+		let defaultName = defaultConfig.relativePath;
 		let counter = 1;
-		while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
-			defaultName = `${DEFAULT_CONFIG.projectName}-${counter}`;
+		while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
+			defaultName = `${defaultConfig.projectName}-${counter}`;
 			counter++;
 		}
 		currentPathInput = defaultName;
@@ -5146,7 +6041,8 @@ async function createProjectHandler(input) {
 				install: false,
 				dbSetup: "none",
 				api: "none",
-				webDeploy: "none"
+				webDeploy: "none",
+				serverDeploy: "none"
 			},
 			reproducibleCommand: "",
 			timeScaffolded,
@@ -5162,28 +6058,33 @@ async function createProjectHandler(input) {
 		projectDirectory: input.projectName
 	};
 	const providedFlags = getProvidedFlags(cliInput);
-	const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
-	const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
-	if (!input.yes && Object.keys(otherFlags).length > 0) {
-		log.info(pc.yellow("Using these pre-selected options:"));
-		log.message(displayConfig(otherFlags));
-		log.message("");
-	}
 	let config;
 	if (input.yes) {
+		const flagConfig = processProvidedFlagsWithoutValidation(cliInput, finalBaseName);
 		config = {
-			...DEFAULT_CONFIG,
+			...getDefaultConfig(),
 			...flagConfig,
 			projectName: finalBaseName,
 			projectDir: finalResolvedPath,
 			relativePath: finalPathInput
 		};
+		coerceBackendPresets(config);
+		validateConfigCompatibility(config, providedFlags, cliInput);
 		if (config.backend === "convex") log.info("Due to '--backend convex' flag, the following options have been automatically set: auth=false, database=none, orm=none, api=none, runtime=none, dbSetup=none, examples=todo");
 		else if (config.backend === "none") log.info("Due to '--backend none', the following options have been automatically set: --auth=false, --database=none, --orm=none, --api=none, --runtime=none, --db-setup=none, --examples=none");
 		log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
 		log.message(displayConfig(config));
 		log.message("");
-	} else config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+	} else {
+		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+		const { projectName: _projectNameFromFlags,...otherFlags } = flagConfig;
+		if (Object.keys(otherFlags).length > 0) {
+			log.info(pc.yellow("Using these pre-selected options:"));
+			log.message(displayConfig(otherFlags));
+			log.message("");
+		}
+		config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+	}
 	await createProject(config);
 	const reproducibleCommand = generateReproducibleCommand(config);
 	log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
@@ -5203,11 +6104,11 @@ async function createProjectHandler(input) {
 }
 async function handleDirectoryConflictProgrammatically(currentPathInput, strategy) {
 	const currentPath = path.resolve(process.cwd(), currentPathInput);
-	if (!fs.pathExistsSync(currentPath)) return {
+	if (!await fs.pathExists(currentPath)) return {
 		finalPathInput: currentPathInput,
 		shouldClearDirectory: false
 	};
-	const dirContents = fs.readdirSync(currentPath);
+	const dirContents = await fs.readdir(currentPath);
 	const isNotEmpty = dirContents.length > 0;
 	if (!isNotEmpty) return {
 		finalPathInput: currentPathInput,
@@ -5226,7 +6127,7 @@ async function handleDirectoryConflictProgrammatically(currentPathInput, strateg
 			let counter = 1;
 			const baseName = currentPathInput;
 			let finalPathInput = `${baseName}-${counter}`;
-			while (fs.pathExistsSync(path.resolve(process.cwd(), finalPathInput)) && fs.readdirSync(path.resolve(process.cwd(), finalPathInput)).length > 0) {
+			while (await fs.pathExists(path.resolve(process.cwd(), finalPathInput)) && (await fs.readdir(path.resolve(process.cwd(), finalPathInput))).length > 0) {
 				counter++;
 				finalPathInput = `${baseName}-${counter}`;
 			}
@@ -5252,6 +6153,10 @@ async function addAddonsHandler(input) {
 			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);
+			if (serverDeploymentPrompt !== "none") input.serverDeploy = serverDeploymentPrompt;
+		}
 		const packageManager = input.packageManager || detectedConfig.packageManager || "npm";
 		let somethingAdded = false;
 		if (input.addons && input.addons.length > 0) {
@@ -5272,6 +6177,15 @@ async function addAddonsHandler(input) {
 			});
 			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;
@@ -5375,6 +6289,7 @@ const router = t.router({
 		runtime: RuntimeSchema.optional(),
 		api: APISchema.optional(),
 		webDeploy: WebDeploySchema.optional(),
+		serverDeploy: ServerDeploySchema.optional(),
 		directoryConflict: DirectoryConflictSchema.optional(),
 		renderTitle: z.boolean().optional(),
 		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics")
@@ -5390,6 +6305,7 @@ const router = t.router({
 	add: t.procedure.meta({ description: "Add addons or deployment configurations to an existing Better-T Stack project" }).input(z.tuple([z.object({
 		addons: z.array(AddonsSchema).optional().default([]),
 		webDeploy: WebDeploySchema.optional(),
+		serverDeploy: ServerDeploySchema.optional(),
 		projectDir: z.string().optional(),
 		install: z.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
 		packageManager: PackageManagerSchema.optional()