create-better-t-stack 2.33.8 → 2.33.9-canary.7db03e6d

package/dist/{src-jDxvJPRx.js → src-CEmXO3U_.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
@@ -45,7 +46,8 @@ const DEFAULT_CONFIG = {
 	backend: "hono",
 	runtime: "bun",
 	api: "trpc",
-	webDeploy: "none"
+	webDeploy: "none",
+	serverDeploy: "none"
 };
 const dependencyVersionMap = {
 	"better-auth": "^1.3.4",
@@ -103,18 +105,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 +136,8 @@ const ADDON_COMPATIBILITY = {
 		"react-router",
 		"nuxt",
 		"svelte",
-		"solid"
+		"solid",
+		"next"
 	],
 	biome: [],
 	husky: [],
@@ -233,7 +242,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 +562,23 @@ 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.");
+}
 
 //#endregion
 //#region src/prompts/api.ts
@@ -1004,16 +1039,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 +1138,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 +1161,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 +1208,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 +1248,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 +1281,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 +1328,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 +1336,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 +1353,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 +1408,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 +1431,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 +1449,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
@@ -1476,6 +1612,7 @@ 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;
@@ -1536,6 +1673,44 @@ function processAndValidateFlags(options, providedFlags, projectName) {
 	validateWorkersCompatibility(providedFlags, options, config);
 	const hasWebFrontendFlag = (config.frontend ?? []).some((f) => isWebFrontend(f));
 	validateWebDeployRequiresWebFrontend(config.webDeploy, hasWebFrontendFlag);
+	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
+	return config;
+}
+function validateConfigCompatibility(config) {
+	const effectiveDatabase = config.database;
+	const effectiveBackend = config.backend;
+	const effectiveFrontend = config.frontend;
+	const effectiveApi = config.api;
+	validateApiFrontendCompatibility(effectiveApi, effectiveFrontend);
+	if (config.addons && config.addons.length > 0) {
+		validateAddonsAgainstFrontends(config.addons, effectiveFrontend);
+		config.addons = [...new Set(config.addons)];
+	}
+	validateExamplesCompatibility(config.examples ?? [], effectiveBackend, effectiveDatabase, effectiveFrontend ?? []);
+}
+function processProvidedFlagsWithoutValidation(options, projectName) {
+	const config = {};
+	if (options.api) config.api = options.api;
+	if (options.backend) config.backend = options.backend;
+	if (options.database) config.database = options.database;
+	if (options.orm) config.orm = options.orm;
+	if (options.auth !== void 0) config.auth = options.auth;
+	if (options.git !== void 0) config.git = options.git;
+	if (options.install !== void 0) config.install = options.install;
+	if (options.runtime) config.runtime = options.runtime;
+	if (options.dbSetup) config.dbSetup = options.dbSetup;
+	if (options.packageManager) config.packageManager = options.packageManager;
+	if (options.webDeploy) config.webDeploy = options.webDeploy;
+	const derivedName = deriveProjectName(projectName, options.projectDirectory);
+	if (derivedName) {
+		const nameToValidate = projectName ? path.basename(projectName) : derivedName;
+		const result = ProjectNameSchema.safeParse(nameToValidate);
+		if (!result.success) throw new Error(`Invalid project name: ${result.error.issues[0]?.message}`);
+		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) {
@@ -1560,7 +1735,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 +1753,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 +1847,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 +1934,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 +2250,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 +2258,58 @@ 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);
+		}
+	} 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);
+			}
+		}
+	}
+	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 +2391,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 +2423,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 +2460,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 +2479,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",
@@ -2346,7 +2548,7 @@ async function setupUltracite(config, hasHusky) {
 		];
 		if (editors.length > 0) ultraciteArgs.push("--editors", ...editors);
 		if (rules.length > 0) ultraciteArgs.push("--rules", ...rules);
-		if (hasHusky) ultraciteArgs.push("--features", "husky", "lint-staged");
+		if (hasHusky) ultraciteArgs.push("--integrations", "husky", "lint-staged");
 		const ultraciteArgsString = ultraciteArgs.join(" ");
 		const commandWithArgs = `ultracite@latest ${ultraciteArgsString} --skip-install`;
 		const ultraciteInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
@@ -2384,7 +2586,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 +2620,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 +2754,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 +2772,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 +2789,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 +2806,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 +2831,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 +2855,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,63 +2948,93 @@ 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");
-	if (modulesProp && modulesProp.getKind() === SyntaxKind.PropertyAssignment) {
-		const arrayExpr = modulesProp.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
-		if (arrayExpr) {
-			const alreadyHas = arrayExpr.getElements().some((el) => el.getText().replace(/['"`]/g, "") === "nitro-cloudflare-dev");
-			if (!alreadyHas) arrayExpr.addElement("'nitro-cloudflare-dev'");
+  }`
+			});
+			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\"]"
+			});
 		}
-	} else configObj.addPropertyAssignment({
-		name: "modules",
-		initializer: "['nitro-cloudflare-dev']"
-	});
-	await tsProject.save();
+		await project.save();
+	} catch (error) {
+		console.warn("Failed to update nuxt.config.ts:", error);
+	}
 }
 
 //#endregion
-//#region src/helpers/setup/workers-svelte-setup.ts
-async function setupSvelteWorkersDeploy(projectDir, packageManager) {
+//#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: ["@sveltejs/adapter-cloudflare", "wrangler"],
+		devDependencies: [
+			"alchemy",
+			"@cloudflare/vite-plugin",
+			"dotenv"
+		],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -2728,36 +3042,100 @@ async function setupSvelteWorkersDeploy(projectDir, packageManager) {
 		const pkg = await fs.readJson(pkgPath);
 		pkg.scripts = {
 			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types ./src/worker-configuration.d.ts"
+			deploy: "alchemy deploy",
+			destroy: "alchemy destroy",
+			"alchemy:dev": "alchemy dev"
 		};
 		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
 	}
-	const possibleConfigFiles = [path.join(webAppDir, "svelte.config.js"), path.join(webAppDir, "svelte.config.ts")];
-	const existingConfigPath = (await Promise.all(possibleConfigFiles.map(async (p) => await fs.pathExists(p) ? p : ""))).find((p) => p);
-	if (existingConfigPath) {
-		const sourceFile = tsProject.addSourceFileAtPathIfExists(existingConfigPath);
-		if (!sourceFile) return;
-		const adapterImport = sourceFile.getImportDeclarations().find((imp) => ["@sveltejs/adapter-auto", "@sveltejs/adapter-node"].includes(imp.getModuleSpecifierValue()));
-		if (adapterImport) adapterImport.setModuleSpecifier("@sveltejs/adapter-cloudflare");
-		else {
-			const alreadyHasCloudflare = sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@sveltejs/adapter-cloudflare");
-			if (!alreadyHasCloudflare) sourceFile.insertImportDeclaration(0, {
-				defaultImport: "adapter",
-				moduleSpecifier: "@sveltejs/adapter-cloudflare"
+	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 tsProject.save();
+		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/setup/workers-tanstack-start-setup.ts
-async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
+//#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: ["wrangler"],
+		devDependencies: ["alchemy", "dotenv"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -2765,13 +3143,394 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 		const pkg = await fs.readJson(pkgPath);
 		pkg.scripts = {
 			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types --env-interface Env"
+			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)) return;
+}
+
+//#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) {
+			const alreadyHas = arrayExpr.getElements().some((el) => el.getText().replace(/['"`]/g, "") === "nitro-cloudflare-dev");
+			if (!alreadyHas) arrayExpr.addElement("'nitro-cloudflare-dev'");
+		}
+	} else configObj.addPropertyAssignment({
+		name: "modules",
+		initializer: "['nitro-cloudflare-dev']"
+	});
+	await tsProject.save();
+}
+
+//#endregion
+//#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;
+	await addPackageDependency({
+		devDependencies: ["@sveltejs/adapter-cloudflare", "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 ./src/worker-configuration.d.ts"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	const possibleConfigFiles = [path.join(webAppDir, "svelte.config.js"), path.join(webAppDir, "svelte.config.ts")];
+	const existingConfigPath = (await Promise.all(possibleConfigFiles.map(async (p) => await fs.pathExists(p) ? p : ""))).find((p) => p);
+	if (existingConfigPath) {
+		const sourceFile = tsProject.addSourceFileAtPathIfExists(existingConfigPath);
+		if (!sourceFile) return;
+		const adapterImport = sourceFile.getImportDeclarations().find((imp) => ["@sveltejs/adapter-auto", "@sveltejs/adapter-node"].includes(imp.getModuleSpecifierValue()));
+		if (adapterImport) adapterImport.setModuleSpecifier("@sveltejs/adapter-cloudflare");
+		else {
+			const alreadyHasCloudflare = sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@sveltejs/adapter-cloudflare");
+			if (!alreadyHasCloudflare) sourceFile.insertImportDeclaration(0, {
+				defaultImport: "adapter",
+				moduleSpecifier: "@sveltejs/adapter-cloudflare"
+			});
+		}
+		await tsProject.save();
+	}
+}
+
+//#endregion
+//#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;
+	await addPackageDependency({
+		devDependencies: ["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 --env-interface Env"
+		};
+		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+	}
+	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
+	if (!await fs.pathExists(viteConfigPath)) return;
 	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
 	if (!sourceFile) return;
 	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
@@ -2790,7 +3549,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 +3580,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 +3597,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 +3628,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 +3638,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,
@@ -2901,226 +3654,81 @@ async function addDeploymentToProject(input) {
 			auth: detectedConfig.auth || false,
 			git: false,
 			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) {}
+			install: input.install || false,
+			dbSetup: detectedConfig.dbSetup || "none",
+			api: detectedConfig.api || "none",
+			webDeploy: input.webDeploy || detectedConfig.webDeploy || "none",
+			serverDeploy: input.serverDeploy || detectedConfig.serverDeploy || "none"
 		};
-		if (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 +3780,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 +4029,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 +4077,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 +4177,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
@@ -4185,7 +5033,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 +5098,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 +5106,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 +5145,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 +5435,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 +5511,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,7 +5554,7 @@ 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`;
+			if (serverDeploy === "wrangler") output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} cf-typegen\n\n`;
 		} else output += "\n";
 	}
 	output += `${pc.bold("Your project will be available at:")}\n`;
@@ -4780,7 +5568,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 +5590,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 +5599,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`)}`);
@@ -4820,6 +5609,10 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup)
 		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") {
+		instructions.push(`${pc.cyan("•")} Generate migrations: ${pc.white(`${runCmd} db:generate`)}`);
+		instructions.push("");
+	}
 	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.`);
@@ -4851,12 +5644,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 +5840,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";
@@ -5069,14 +5872,13 @@ async function createProject(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 +5897,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();
@@ -5107,7 +5909,7 @@ async function createProjectHandler(input) {
 	else if (input.yes) {
 		let defaultName = DEFAULT_CONFIG.relativePath;
 		let counter = 1;
-		while (fs.pathExistsSync(path.resolve(process.cwd(), defaultName)) && fs.readdirSync(path.resolve(process.cwd(), defaultName)).length > 0) {
+		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++;
 		}
@@ -5146,7 +5948,8 @@ async function createProjectHandler(input) {
 				install: false,
 				dbSetup: "none",
 				api: "none",
-				webDeploy: "none"
+				webDeploy: "none",
+				serverDeploy: "none"
 			},
 			reproducibleCommand: "",
 			timeScaffolded,
@@ -5162,15 +5965,9 @@ 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,
 			...flagConfig,
@@ -5178,12 +5975,22 @@ async function createProjectHandler(input) {
 			projectDir: finalResolvedPath,
 			relativePath: finalPathInput
 		};
+		validateConfigCompatibility(config);
 		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 +6010,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 +6033,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 +6059,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 +6083,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 +6195,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 +6211,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()