create-better-t-stack 2.50.0 → 2.50.1-canary.7ebd503f

package/dist/{src-BFx0Xu3C.js → src-DG05Vcnx.js}

@@ -15,6 +15,7 @@ import { IndentationText, Node, Project, QuoteKind, SyntaxKind } from "ts-morph"
 import { glob } from "tinyglobby";
 import handlebars from "handlebars";
 import { Biome } from "@biomejs/js-api/nodejs";
+import yaml from "yaml";
 import os$1 from "node:os";
 
 //#region src/utils/get-package-manager.ts
@@ -70,7 +71,7 @@ const dependencyVersionMap = {
 	"drizzle-orm": "^0.44.2",
 	"drizzle-kit": "^0.31.2",
 	"@planetscale/database": "^1.19.0",
-	"@libsql/client": "^0.15.9",
+	"@libsql/client": "^0.14.0",
 	"@neondatabase/serverless": "^1.0.1",
 	pg: "^8.14.1",
 	"@types/pg": "^8.11.11",
@@ -123,6 +124,7 @@ const dependencyVersionMap = {
 	"@trpc/tanstack-react-query": "^11.5.0",
 	"@trpc/server": "^11.5.0",
 	"@trpc/client": "^11.5.0",
+	next: "15.5.4",
 	convex: "^1.27.0",
 	"@convex-dev/react-query": "^0.0.0-alpha.8",
 	"convex-svelte": "^0.0.11",
@@ -146,7 +148,9 @@ const dependencyVersionMap = {
 	"@cloudflare/workers-types": "^4.20250822.0",
 	alchemy: "^0.70.0",
 	nitropack: "^2.12.4",
-	dotenv: "^17.2.1",
+	dotenv: "^17.2.2",
+	tsdown: "^0.15.5",
+	zod: "^4.1.11",
 	"@polar-sh/better-auth": "^1.1.3",
 	"@polar-sh/sdk": "^0.34.16"
 };
@@ -195,9 +199,9 @@ const BackendSchema = z.enum([
 	"hono",
 	"express",
 	"fastify",
-	"next",
 	"elysia",
 	"convex",
+	"self",
 	"none"
 ]).describe("Backend framework");
 const RuntimeSchema = z.enum([
@@ -343,6 +347,22 @@ function ensureSingleWebAndNative(frontends) {
 	if (web.length > 1) exitWithError("Cannot select multiple web frameworks. Choose only one of: tanstack-router, tanstack-start, react-router, next, nuxt, svelte, solid");
 	if (native.length > 1) exitWithError("Cannot select multiple native frameworks. Choose only one of: native-nativewind, native-unistyles");
 }
+const FULLSTACK_FRONTENDS$1 = [
+	"next",
+	"nuxt",
+	"svelte",
+	"tanstack-start"
+];
+function validateSelfBackendCompatibility(providedFlags, options, config) {
+	const backend = config.backend || options.backend;
+	const frontends = config.frontend || options.frontend || [];
+	if (backend === "self") {
+		if (!frontends.some((f) => FULLSTACK_FRONTENDS$1.includes(f))) exitWithError("Backend 'self' (fullstack) requires a fullstack-capable frontend. Please use --frontend with one of: next, nuxt, svelte, tanstack-start");
+		if (frontends.length > 1) exitWithError("Backend 'self' (fullstack) can only be used with a single frontend framework.");
+	}
+	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS$1.includes(f));
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") exitWithError("Backend 'self' (fullstack) is only compatible with fullstack-capable frontends: next, nuxt, svelte, tanstack-start. Please choose a different backend or use a fullstack frontend.");
+}
 function validateWorkersCompatibility(providedFlags, options, config) {
 	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && config.backend !== "hono") exitWithError(`Cloudflare Workers runtime (--runtime workers) is only supported with Hono backend (--backend hono). Current backend: ${config.backend}. Please use '--backend hono' or choose a different runtime.`);
 	if (providedFlags.has("backend") && config.backend && config.backend !== "hono" && config.runtime === "workers") exitWithError(`Backend '${config.backend}' is not compatible with Cloudflare Workers runtime. Cloudflare Workers runtime is only supported with Hono backend. Please use '--backend hono' or choose a different runtime.`);
@@ -664,36 +684,39 @@ async function getAuthChoice(auth, hasDatabase, backend, frontend) {
 
 //#endregion
 //#region src/prompts/backend.ts
+const FULLSTACK_FRONTENDS = [
+	"next",
+	"nuxt",
+	"svelte",
+	"tanstack-start"
+];
 async function getBackendFrameworkChoice(backendFramework, frontends) {
 	if (backendFramework !== void 0) return backendFramework;
 	const hasIncompatibleFrontend = frontends?.some((f) => f === "solid");
-	const backendOptions = [
-		{
-			value: "hono",
-			label: "Hono",
-			hint: "Lightweight, ultrafast web framework"
-		},
-		{
-			value: "next",
-			label: "Next.js",
-			hint: "separate api routes only backend"
-		},
-		{
-			value: "express",
-			label: "Express",
-			hint: "Fast, unopinionated, minimalist web framework for Node.js"
-		},
-		{
-			value: "fastify",
-			label: "Fastify",
-			hint: "Fast, low-overhead web framework for Node.js"
-		},
-		{
-			value: "elysia",
-			label: "Elysia",
-			hint: "Ergonomic web framework for building backend servers"
-		}
-	];
+	const hasFullstackFrontend = frontends?.some((f) => FULLSTACK_FRONTENDS.includes(f));
+	const backendOptions = [];
+	if (hasFullstackFrontend) backendOptions.push({
+		value: "self",
+		label: "Self (Fullstack)",
+		hint: "Use frontend's built-in api routes"
+	});
+	backendOptions.push({
+		value: "hono",
+		label: "Hono",
+		hint: "Lightweight, ultrafast web framework"
+	}, {
+		value: "express",
+		label: "Express",
+		hint: "Fast, unopinionated, minimalist web framework for Node.js"
+	}, {
+		value: "fastify",
+		label: "Fastify",
+		hint: "Fast, low-overhead web framework for Node.js"
+	}, {
+		value: "elysia",
+		label: "Elysia",
+		hint: "Ergonomic web framework for building backend servers"
+	});
 	if (!hasIncompatibleFrontend) backendOptions.push({
 		value: "convex",
 		label: "Convex",
@@ -707,7 +730,7 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 	const response = await select({
 		message: "Select backend",
 		options: backendOptions,
-		initialValue: DEFAULT_CONFIG.backend
+		initialValue: hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend
 	});
 	if (isCancel(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1086,9 +1109,8 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 //#endregion
 //#region src/prompts/runtime.ts
 async function getRuntimeChoice(runtime, backend) {
-	if (backend === "convex" || backend === "none") return "none";
+	if (backend === "convex" || backend === "none" || backend === "self") return "none";
 	if (runtime !== void 0) return runtime;
-	if (backend === "next") return "node";
 	const runtimeOptions = [{
 		value: "bun",
 		label: "Bun",
@@ -1375,7 +1397,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;
@@ -1383,8 +1405,8 @@ 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);
 	return `cli_${Date.now().toString(36)}${rand}`;
@@ -1765,8 +1787,8 @@ function validateBackendConstraints(config, providedFlags, options) {
 		].includes(f));
 		if (incompatibleFrontends.length > 0) exitWithError(`Clerk authentication is not compatible with the following frontends: ${incompatibleFrontends.join(", ")}. Please choose a different frontend or auth provider.`);
 	}
-	if (providedFlags.has("backend") && backend && backend !== "convex" && backend !== "none") {
-		if (providedFlags.has("runtime") && options.runtime === "none") exitWithError("'--runtime none' is only supported with '--backend convex' or '--backend none'. Please choose 'bun', 'node', or remove the --runtime flag.");
+	if (providedFlags.has("backend") && backend && backend !== "convex" && backend !== "none" && backend !== "self") {
+		if (providedFlags.has("runtime") && options.runtime === "none") exitWithError("'--runtime none' is only supported with '--backend convex', '--backend none', or '--backend self'. Please choose 'bun', 'node', or remove the --runtime flag.");
 	}
 	if (backend === "convex" && providedFlags.has("frontend") && options.frontend) {
 		const incompatibleFrontends = options.frontend.filter((f) => f === "solid");
@@ -1796,6 +1818,7 @@ function validateFullConfig(config, providedFlags, options) {
 	validateFrontendConstraints(config, providedFlags);
 	validateApiConstraints(config, options);
 	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
+	validateSelfBackendCompatibility(providedFlags, options, config);
 	validateWorkersCompatibility(providedFlags, options, config);
 	if (config.runtime === "workers" && config.serverDeploy === "none") exitWithError("Cloudflare Workers runtime requires a server deployment. Please choose 'wrangler' or 'alchemy' for --server-deploy.");
 	if (config.addons && config.addons.length > 0) {
@@ -1849,6 +1872,7 @@ const CORE_STACK_FLAGS = new Set([
 	"examples",
 	"auth",
 	"dbSetup",
+	"payments",
 	"api",
 	"webDeploy",
 	"serverDeploy"
@@ -1992,15 +2016,17 @@ const addPackageDependency = async (opts) => {
 	if (!pkgJson.dependencies) pkgJson.dependencies = {};
 	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
 	for (const pkgName of dependencies) {
-		const version = customDependencies[pkgName] || dependencyVersionMap[pkgName];
+		const version = dependencyVersionMap[pkgName];
 		if (version) pkgJson.dependencies[pkgName] = version;
 		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
 	}
 	for (const pkgName of devDependencies) {
-		const version = customDevDependencies[pkgName] || dependencyVersionMap[pkgName];
+		const version = dependencyVersionMap[pkgName];
 		if (version) pkgJson.devDependencies[pkgName] = version;
 		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
 	}
+	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
+	for (const [pkgName, version] of Object.entries(customDevDependencies)) pkgJson.devDependencies[pkgName] = version;
 	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 };
 
@@ -2062,11 +2088,14 @@ async function setupFumadocs(config) {
 		if (isCancel(template)) return exitCancelled("Operation cancelled");
 		const commandWithArgs = `create-fumadocs-app@latest fumadocs --template ${TEMPLATES[template].value} --src --no-install --pm ${packageManager} --no-eslint --no-git`;
 		const fumadocsInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+		const s = spinner();
+		s.start("Setting up Fumadocs...");
 		await execa(fumadocsInitCommand, {
 			cwd: path.join(projectDir, "apps"),
 			env: { CI: "true" },
 			shell: true
 		});
+		s.stop("Fumadocs setup complete!");
 		const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
 		const packageJsonPath = path.join(fumadocsDir, "package.json");
 		if (await fs.pathExists(packageJsonPath)) {
@@ -2307,11 +2336,14 @@ async function setupUltracite(config, hasHusky) {
 		if (hasHusky) ultraciteArgs.push("--integrations", "husky", "lint-staged");
 		const commandWithArgs = `ultracite@latest ${ultraciteArgs.join(" ")} --skip-install`;
 		const ultraciteInitCommand = getPackageExecutionCommand(packageManager, commandWithArgs);
+		const s = spinner();
+		s.start("Setting up Ultracite...");
 		await execa(ultraciteInitCommand, {
 			cwd: projectDir,
 			env: { CI: "true" },
 			shell: true
 		});
+		s.stop("Ultracite setup complete!");
 		if (hasHusky) await addPackageDependency({
 			devDependencies: ["husky", "lint-staged"],
 			projectDir
@@ -2655,8 +2687,12 @@ async function processTemplate(srcPath, destPath, context) {
 }
 handlebars.registerHelper("eq", (a, b) => a === b);
 handlebars.registerHelper("ne", (a, b) => a !== b);
-handlebars.registerHelper("and", (a, b) => a && b);
-handlebars.registerHelper("or", (a, b) => a || b);
+handlebars.registerHelper("and", (...args) => {
+	return args.slice(0, -1).every((value) => value);
+});
+handlebars.registerHelper("or", (...args) => {
+	return args.slice(0, -1).some((value) => value);
+});
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
 //#endregion
@@ -2718,6 +2754,10 @@ async function setupFrontendTemplates(projectDir, context) {
 					const apiWebBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/web/react/base`);
 					if (await fs.pathExists(apiWebBaseDir)) await processAndCopyFiles("**/*", apiWebBaseDir, webAppDir, context);
 				}
+				if (context.backend === "self" && reactFramework === "next" && context.api !== "none") {
+					const apiFullstackDir = path.join(PKG_ROOT, `templates/api/${context.api}/fullstack/next`);
+					if (await fs.pathExists(apiFullstackDir)) await processAndCopyFiles("**/*", apiFullstackDir, webAppDir, context);
+				}
 			}
 		} else if (hasNuxtWeb) {
 			const nuxtBaseDir = path.join(PKG_ROOT, "templates/frontend/nuxt");
@@ -2758,35 +2798,52 @@ async function setupFrontendTemplates(projectDir, context) {
 		}
 	}
 }
-async function setupBackendFramework(projectDir, context) {
-	if (context.backend === "none") return;
+async function setupApiPackage(projectDir, context) {
+	if (context.api === "none") return;
+	const apiPackageDir = path.join(projectDir, "packages/api");
+	await fs.ensureDir(apiPackageDir);
+	const apiServerDir = path.join(PKG_ROOT, `templates/api/${context.api}/server`);
+	if (await fs.pathExists(apiServerDir)) await processAndCopyFiles("**/*", apiServerDir, apiPackageDir, context);
+}
+async function setupDbPackage(projectDir, context) {
+	if (context.database === "none" || context.orm === "none") return;
+	const dbPackageDir = path.join(projectDir, "packages/db");
+	await fs.ensureDir(dbPackageDir);
+	const dbBaseDir = path.join(PKG_ROOT, "templates/db/base");
+	if (await fs.pathExists(dbBaseDir)) await processAndCopyFiles("**/*", dbBaseDir, dbPackageDir, context);
+	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
+	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, dbPackageDir, context);
+}
+async function setupConvexBackend(projectDir, context) {
+	const serverAppDir = path.join(projectDir, "apps/server");
+	if (await fs.pathExists(serverAppDir)) await fs.remove(serverAppDir);
+	const convexBackendDestDir = path.join(projectDir, "packages/backend");
+	const convexSrcDir = path.join(PKG_ROOT, "templates/backend/convex/packages/backend");
+	await fs.ensureDir(convexBackendDestDir);
+	if (await fs.pathExists(convexSrcDir)) await processAndCopyFiles("**/*", convexSrcDir, convexBackendDestDir, context);
+}
+async function setupServerApp(projectDir, context) {
 	const serverAppDir = path.join(projectDir, "apps/server");
-	if (context.backend === "convex") {
-		if (await fs.pathExists(serverAppDir)) await fs.remove(serverAppDir);
-		const convexBackendDestDir = path.join(projectDir, "packages/backend");
-		const convexSrcDir = path.join(PKG_ROOT, "templates/backend/convex/packages/backend");
-		await fs.ensureDir(convexBackendDestDir);
-		if (await fs.pathExists(convexSrcDir)) await processAndCopyFiles("**/*", convexSrcDir, convexBackendDestDir, context);
-		return;
-	}
 	await fs.ensureDir(serverAppDir);
-	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/server-base");
+	const serverBaseDir = path.join(PKG_ROOT, "templates/backend/server/base");
 	if (await fs.pathExists(serverBaseDir)) await processAndCopyFiles("**/*", serverBaseDir, serverAppDir, context);
 	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
 	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
-	if (context.api !== "none") {
-		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
-		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, serverAppDir, context, true);
-		const apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
-		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, serverAppDir, context, true);
-	}
 }
-async function setupDbOrmTemplates(projectDir, context) {
-	if (context.backend === "convex" || context.orm === "none" || context.database === "none") return;
-	const serverAppDir = path.join(projectDir, "apps/server");
-	await fs.ensureDir(serverAppDir);
-	const dbOrmSrcDir = path.join(PKG_ROOT, `templates/db/${context.orm}/${context.database}`);
-	if (await fs.pathExists(dbOrmSrcDir)) await processAndCopyFiles("**/*", dbOrmSrcDir, serverAppDir, context);
+async function setupBackendFramework(projectDir, context) {
+	if (context.backend === "none") return;
+	if (context.backend === "convex") {
+		await setupConvexBackend(projectDir, context);
+		return;
+	}
+	if (context.backend === "self") {
+		await setupApiPackage(projectDir, context);
+		await setupDbPackage(projectDir, context);
+		return;
+	}
+	await setupServerApp(projectDir, context);
+	await setupApiPackage(projectDir, context);
+	await setupDbPackage(projectDir, context);
 }
 async function setupAuthTemplate(projectDir, context) {
 	if (!context.auth || context.auth === "none") return;
@@ -2866,21 +2923,21 @@ async function setupAuthTemplate(projectDir, context) {
 		}
 		return;
 	}
-	if (serverAppDirExists && context.backend !== "convex") {
+	if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex") {
+		const authPackageDir = path.join(projectDir, "packages/auth");
+		await fs.ensureDir(authPackageDir);
 		const authServerBaseSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/base`);
-		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, serverAppDir, context);
-		if (context.backend === "next") {
-			const authServerNextSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/next`);
-			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, serverAppDir, context);
-		}
+		if (await fs.pathExists(authServerBaseSrc)) await processAndCopyFiles("**/*", authServerBaseSrc, authPackageDir, context);
 		if (context.orm !== "none" && context.database !== "none") {
+			const dbPackageDir = path.join(projectDir, "packages/db");
+			await fs.ensureDir(dbPackageDir);
 			const orm = context.orm;
 			const db = context.database;
 			let authDbSrc = "";
 			if (orm === "drizzle") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/drizzle/${db}`);
 			else if (orm === "prisma") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/prisma/${db}`);
 			else if (orm === "mongoose") authDbSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/db/mongoose/${db}`);
-			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, serverAppDir, context);
+			if (authDbSrc && await fs.pathExists(authDbSrc)) await processAndCopyFiles("**/*", authDbSrc, dbPackageDir, context);
 		}
 	}
 	if ((hasReactWeb || hasNuxtWeb || hasSvelteWeb || hasSolidWeb) && webAppDirExists) {
@@ -2896,6 +2953,10 @@ async function setupAuthTemplate(projectDir, context) {
 			if (reactFramework) {
 				const authWebFrameworkSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/web/react/${reactFramework}`);
 				if (await fs.pathExists(authWebFrameworkSrc)) await processAndCopyFiles("**/*", authWebFrameworkSrc, webAppDir, context);
+				if (context.backend === "self" && reactFramework === "next") {
+					const authFullstackSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/fullstack/next`);
+					if (await fs.pathExists(authFullstackSrc)) await processAndCopyFiles("**/*", authFullstackSrc, webAppDir, context);
+				}
 			}
 		} else if (hasNuxtWeb) {
 			const authWebNuxtSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/web/nuxt`);
@@ -2926,9 +2987,11 @@ async function setupPaymentsTemplate(projectDir, context) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	const serverAppDirExists = await fs.pathExists(serverAppDir);
 	const webAppDirExists = await fs.pathExists(webAppDir);
-	if (serverAppDirExists && context.backend !== "convex") {
+	if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex") {
+		const authPackageDir = path.join(projectDir, "packages/auth");
+		await fs.ensureDir(authPackageDir);
 		const paymentsServerSrc = path.join(PKG_ROOT, `templates/payments/${context.payments}/server/base`);
-		if (await fs.pathExists(paymentsServerSrc)) await processAndCopyFiles("**/*", paymentsServerSrc, serverAppDir, context);
+		if (await fs.pathExists(paymentsServerSrc)) await processAndCopyFiles("**/*", paymentsServerSrc, authPackageDir, context);
 	}
 	const hasReactWeb = context.frontend.some((f) => [
 		"tanstack-router",
@@ -3004,17 +3067,19 @@ async function setupExamplesTemplate(projectDir, context) {
 	for (const example of context.examples) {
 		if (example === "none") continue;
 		const exampleBaseDir = path.join(PKG_ROOT, `templates/examples/${example}`);
-		if (serverAppDirExists && context.backend !== "convex" && context.backend !== "none") {
+		if ((serverAppDirExists || context.backend === "self") && context.backend !== "convex" && context.backend !== "none") {
 			const exampleServerSrc = path.join(exampleBaseDir, "server");
-			if (example === "ai" && context.backend === "next") {
-				const aiNextServerSrc = path.join(exampleServerSrc, "next");
-				if (await fs.pathExists(aiNextServerSrc)) await processAndCopyFiles("**/*", aiNextServerSrc, serverAppDir, context, false);
+			if (context.api !== "none") {
+				const apiPackageDir = path.join(projectDir, "packages/api");
+				await fs.ensureDir(apiPackageDir);
+				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
+				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, apiPackageDir, context, false);
 			}
 			if (context.orm !== "none" && context.database !== "none") {
-				const exampleOrmBaseSrc = path.join(exampleServerSrc, context.orm, "base");
-				if (await fs.pathExists(exampleOrmBaseSrc)) await processAndCopyFiles("**/*", exampleOrmBaseSrc, serverAppDir, context, false);
+				const dbPackageDir = path.join(projectDir, "packages/db");
+				await fs.ensureDir(dbPackageDir);
 				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
-				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, serverAppDir, context, false);
+				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, dbPackageDir, context, false);
 			}
 		}
 		if (webAppDirExists) {
@@ -3034,6 +3099,10 @@ async function setupExamplesTemplate(projectDir, context) {
 					if (reactFramework) {
 						const exampleWebFrameworkSrc = path.join(exampleWebSrc, reactFramework);
 						if (await fs.pathExists(exampleWebFrameworkSrc)) await processAndCopyFiles("**/*", exampleWebFrameworkSrc, webAppDir, context, false);
+						if (context.backend === "self" && reactFramework === "next") {
+							const exampleFullstackSrc = path.join(exampleBaseDir, "fullstack/next");
+							if (await fs.pathExists(exampleFullstackSrc)) await processAndCopyFiles("**/*", exampleFullstackSrc, webAppDir, context, false);
+						}
 					}
 				}
 			} else if (hasNuxtWeb) {
@@ -3081,9 +3150,9 @@ async function handleExtras(projectDir, context) {
 }
 async function setupDockerComposeTemplates(projectDir, context) {
 	if (context.dbSetup !== "docker" || context.database === "none") return;
-	const serverAppDir = path.join(projectDir, "apps/server");
+	const dbPackageDir = path.join(projectDir, "packages/db");
 	const dockerSrcDir = path.join(PKG_ROOT, `templates/db-setup/docker-compose/${context.database}`);
-	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, serverAppDir, context);
+	if (await fs.pathExists(dockerSrcDir)) await processAndCopyFiles("**/*", dockerSrcDir, dbPackageDir, context);
 }
 async function setupDeploymentTemplates(projectDir, context) {
 	if (context.webDeploy === "alchemy" || context.serverDeploy === "alchemy") if (context.webDeploy === "alchemy" && context.serverDeploy === "alchemy") {
@@ -3244,7 +3313,6 @@ async function setupAlchemyServerDeploy(serverDir, _packageManager) {
 			"alchemy",
 			"wrangler",
 			"@types/node",
-			"dotenv",
 			"@cloudflare/workers-types"
 		],
 		projectDir: serverDir
@@ -3271,7 +3339,6 @@ async function setupNextAlchemyDeploy(projectDir, _packageManager, options) {
 		dependencies: ["@opennextjs/cloudflare"],
 		devDependencies: [
 			"alchemy",
-			"dotenv",
 			"wrangler",
 			"@cloudflare/workers-types"
 		],
@@ -3307,7 +3374,6 @@ async function setupNuxtAlchemyDeploy(projectDir, _packageManager, options) {
 		devDependencies: [
 			"alchemy",
 			"nitro-cloudflare-dev",
-			"dotenv",
 			"wrangler"
 		],
 		projectDir: webAppDir
@@ -3370,7 +3436,7 @@ async function setupReactRouterAlchemyDeploy(projectDir, _packageManager, option
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["alchemy", "dotenv"],
+		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3391,7 +3457,7 @@ async function setupSolidAlchemyDeploy(projectDir, _packageManager, options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["alchemy", "dotenv"],
+		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3412,11 +3478,7 @@ async function setupSvelteAlchemyDeploy(projectDir, _packageManager, options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: [
-			"alchemy",
-			"@sveltejs/adapter-cloudflare",
-			"dotenv"
-		],
+		devDependencies: ["alchemy", "@sveltejs/adapter-cloudflare"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3481,7 +3543,7 @@ async function setupTanStackRouterAlchemyDeploy(projectDir, _packageManager, opt
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["alchemy", "dotenv"],
+		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3502,11 +3564,7 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: [
-			"alchemy",
-			"dotenv",
-			"@cloudflare/vite-plugin"
-		],
+		devDependencies: ["alchemy", "@cloudflare/vite-plugin"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3561,7 +3619,7 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 //#region src/helpers/deployment/alchemy/alchemy-combined-setup.ts
 async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 	await addPackageDependency({
-		devDependencies: ["alchemy", "dotenv"],
+		devDependencies: ["alchemy"],
 		projectDir
 	});
 	const rootPkgPath = path.join(projectDir, "package.json");
@@ -3901,18 +3959,137 @@ async function addDeploymentToProject(input) {
 	}
 }
 
+//#endregion
+//#region src/utils/setup-catalogs.ts
+async function setupCatalogs(projectDir, options) {
+	if (options.packageManager === "npm") return;
+	const packagePaths = [
+		"apps/server",
+		"apps/web",
+		"packages/api",
+		"packages/db",
+		"packages/auth",
+		"packages/backend"
+	];
+	const packagesInfo = [];
+	for (const pkgPath of packagePaths) {
+		const fullPath = path.join(projectDir, pkgPath);
+		const pkgJsonPath = path.join(fullPath, "package.json");
+		if (await fs.pathExists(pkgJsonPath)) {
+			const pkgJson = await fs.readJson(pkgJsonPath);
+			packagesInfo.push({
+				path: fullPath,
+				dependencies: pkgJson.dependencies || {},
+				devDependencies: pkgJson.devDependencies || {}
+			});
+		}
+	}
+	const catalog = findDuplicateDependencies(packagesInfo, options.projectName);
+	if (Object.keys(catalog).length === 0) return;
+	if (options.packageManager === "bun") await setupBunCatalogs(projectDir, catalog);
+	else if (options.packageManager === "pnpm") await setupPnpmCatalogs(projectDir, catalog);
+	await updatePackageJsonsWithCatalogs(packagesInfo, catalog);
+}
+function findDuplicateDependencies(packagesInfo, projectName) {
+	const depCount = /* @__PURE__ */ new Map();
+	const projectScope = `@${projectName}/`;
+	for (const pkg of packagesInfo) {
+		const allDeps = {
+			...pkg.dependencies,
+			...pkg.devDependencies
+		};
+		for (const [depName, version] of Object.entries(allDeps)) {
+			if (depName.startsWith(projectScope)) continue;
+			if (version.startsWith("workspace:")) continue;
+			const existing = depCount.get(depName);
+			if (existing) existing.packages.push(pkg.path);
+			else depCount.set(depName, {
+				version,
+				packages: [pkg.path]
+			});
+		}
+	}
+	const catalog = {};
+	for (const [depName, info] of depCount.entries()) if (info.packages.length > 1) catalog[depName] = info.version;
+	return catalog;
+}
+async function setupBunCatalogs(projectDir, catalog) {
+	const rootPkgJsonPath = path.join(projectDir, "package.json");
+	const rootPkgJson = await fs.readJson(rootPkgJsonPath);
+	if (!rootPkgJson.workspaces) rootPkgJson.workspaces = {};
+	if (Array.isArray(rootPkgJson.workspaces)) rootPkgJson.workspaces = {
+		packages: rootPkgJson.workspaces,
+		catalog
+	};
+	else if (typeof rootPkgJson.workspaces === "object") {
+		if (!rootPkgJson.workspaces.catalog) rootPkgJson.workspaces.catalog = {};
+		rootPkgJson.workspaces.catalog = {
+			...rootPkgJson.workspaces.catalog,
+			...catalog
+		};
+	}
+	await fs.writeJson(rootPkgJsonPath, rootPkgJson, { spaces: 2 });
+}
+async function setupPnpmCatalogs(projectDir, catalog) {
+	const workspaceYamlPath = path.join(projectDir, "pnpm-workspace.yaml");
+	if (!await fs.pathExists(workspaceYamlPath)) return;
+	const workspaceContent = await fs.readFile(workspaceYamlPath, "utf-8");
+	const workspaceYaml = yaml.parse(workspaceContent);
+	if (!workspaceYaml.catalog) workspaceYaml.catalog = {};
+	workspaceYaml.catalog = {
+		...workspaceYaml.catalog,
+		...catalog
+	};
+	await fs.writeFile(workspaceYamlPath, yaml.stringify(workspaceYaml));
+}
+async function updatePackageJsonsWithCatalogs(packagesInfo, catalog) {
+	for (const pkg of packagesInfo) {
+		const pkgJsonPath = path.join(pkg.path, "package.json");
+		const pkgJson = await fs.readJson(pkgJsonPath);
+		let updated = false;
+		if (pkgJson.dependencies) {
+			for (const depName of Object.keys(pkgJson.dependencies)) if (catalog[depName]) {
+				pkgJson.dependencies[depName] = "catalog:";
+				updated = true;
+			}
+		}
+		if (pkgJson.devDependencies) {
+			for (const depName of Object.keys(pkgJson.devDependencies)) if (catalog[depName]) {
+				pkgJson.devDependencies[depName] = "catalog:";
+				updated = true;
+			}
+		}
+		if (updated) await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+	}
+}
+
 //#endregion
 //#region src/helpers/addons/examples-setup.ts
 async function setupExamples(config) {
-	const { examples, frontend, backend, projectDir } = config;
+	const { examples, frontend, backend, projectDir, orm } = config;
 	if (backend === "convex" || !examples || examples.length === 0 || examples[0] === "none") return;
+	const apiDir = path.join(projectDir, "packages/api");
+	if (await fs.pathExists(apiDir) && backend !== "none") {
+		if (orm === "drizzle") await addPackageDependency({
+			dependencies: ["drizzle-orm"],
+			projectDir: apiDir
+		});
+		else if (orm === "prisma") await addPackageDependency({
+			dependencies: ["@prisma/client"],
+			projectDir: apiDir
+		});
+		else if (orm === "mongoose") await addPackageDependency({
+			dependencies: ["mongoose"],
+			projectDir: apiDir
+		});
+	}
 	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 apiDir$1 = path.join(projectDir, "packages/api");
 		const webClientDirExists = await fs.pathExists(webClientDir);
 		const nativeClientDirExists = await fs.pathExists(nativeClientDir);
-		const serverDirExists = await fs.pathExists(serverDir);
+		const apiDirExists = await fs.pathExists(apiDir$1);
 		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");
@@ -3933,9 +4110,13 @@ async function setupExamples(config) {
 			dependencies: ["ai", "@ai-sdk/react"],
 			projectDir: nativeClientDir
 		});
-		if (serverDirExists && backend !== "none") await addPackageDependency({
+		if (apiDirExists && backend !== "none") await addPackageDependency({
 			dependencies: ["ai", "@ai-sdk/google"],
-			projectDir: serverDir
+			projectDir: apiDir$1
+		});
+		if (backend === "self" && webClientDirExists) await addPackageDependency({
+			dependencies: ["ai", "@ai-sdk/google"],
+			projectDir: webClientDir
 		});
 	}
 }
@@ -4051,32 +4232,61 @@ function getConvexDependencies(frontend) {
 	return deps;
 }
 async function setupApi(config) {
-	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
+	const { api, projectName, frontend, backend, packageManager, projectDir, auth } = 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);
+	await fs.pathExists(serverDir);
 	const frontendType = getFrontendType(frontend);
 	if (!isConvex && api !== "none") {
 		const apiDeps = getApiDependencies(api, frontendType);
-		if (serverDirExists && apiDeps.server) {
+		const apiPackageDir = path.join(projectDir, "packages/api");
+		if (apiDeps.server) {
 			await addPackageDependency({
 				dependencies: apiDeps.server.dependencies,
-				projectDir: serverDir
+				projectDir: apiPackageDir
+			});
+			if (backend === "self" && webDirExists) await addPackageDependency({
+				dependencies: apiDeps.server.dependencies,
+				projectDir: webDir
+			});
+			const frameworkDeps = [];
+			if (backend === "hono") frameworkDeps.push("hono");
+			else if (backend === "elysia") frameworkDeps.push("elysia");
+			else if (backend === "express") frameworkDeps.push("express", "@types/express");
+			else if (backend === "fastify") frameworkDeps.push("fastify");
+			else if (backend === "self") {
+				if (frontend.includes("next")) frameworkDeps.push("next");
+			}
+			if (frameworkDeps.length > 0) await addPackageDependency({
+				dependencies: frameworkDeps,
+				projectDir: apiPackageDir
 			});
 			if (api === "trpc") {
 				if (backend === "hono") await addPackageDependency({
 					dependencies: ["@hono/trpc-server"],
-					projectDir: serverDir
+					projectDir: apiPackageDir
 				});
 				else if (backend === "elysia") await addPackageDependency({
 					dependencies: ["@elysiajs/trpc"],
-					projectDir: serverDir
+					projectDir: apiPackageDir
+				});
+				else if (backend === "express") await addPackageDependency({
+					dependencies: ["@trpc/server"],
+					projectDir: apiPackageDir
+				});
+				else if (backend === "fastify") await addPackageDependency({
+					dependencies: ["@trpc/server"],
+					projectDir: apiPackageDir
 				});
 			}
+			if (auth === "better-auth") await addPackageDependency({
+				dependencies: ["better-auth"],
+				projectDir: apiPackageDir
+			});
 		}
 		if (webDirExists && apiDeps.web) await addPackageDependency({
 			dependencies: apiDeps.web.dependencies,
@@ -4120,7 +4330,7 @@ async function setupApi(config) {
 //#endregion
 //#region src/helpers/core/backend-setup.ts
 async function setupBackendDependencies(config) {
-	const { backend, runtime, api, projectDir } = config;
+	const { backend, runtime, api, auth, examples, projectDir } = config;
 	if (backend === "convex") return;
 	const framework = backend;
 	const serverDir = path.join(projectDir, "apps/server");
@@ -4148,6 +4358,13 @@ async function setupBackendDependencies(config) {
 		dependencies.push("fastify", "@fastify/cors");
 		if (runtime === "node") devDependencies.push("tsx", "@types/node");
 	}
+	if (api === "trpc") {
+		if (framework === "express") dependencies.push("@trpc/server");
+		else if (framework === "fastify") dependencies.push("@trpc/server");
+		else if (runtime === "workers") dependencies.push("@trpc/server");
+	} else if (api === "orpc") dependencies.push("@orpc/server", "@orpc/openapi", "@orpc/zod");
+	if (auth === "better-auth") dependencies.push("better-auth");
+	if (examples.includes("ai")) dependencies.push("ai", "@ai-sdk/google");
 	if (runtime === "bun") devDependencies.push("@types/bun");
 	if (dependencies.length > 0 || devDependencies.length > 0) await addPackageDependency({
 		dependencies,
@@ -4166,7 +4383,7 @@ async function setupAuth(config) {
 	const nativeDir = path.join(projectDir, "apps/native");
 	const clientDirExists = await fs.pathExists(clientDir);
 	const nativeDirExists = await fs.pathExists(nativeDir);
-	const serverDirExists = await fs.pathExists(serverDir);
+	await fs.pathExists(serverDir);
 	try {
 		if (backend === "convex") {
 			if (auth === "clerk" && clientDirExists) {
@@ -4222,9 +4439,11 @@ async function setupAuth(config) {
 			});
 			return;
 		}
-		if (serverDirExists && auth === "better-auth") await addPackageDependency({
+		const authPackageDir = path.join(projectDir, "packages/auth");
+		const authPackageDirExists = await fs.pathExists(authPackageDir);
+		if (authPackageDirExists && auth === "better-auth") await addPackageDependency({
 			dependencies: ["better-auth"],
-			projectDir: serverDir
+			projectDir: authPackageDir
 		});
 		if (frontend.some((f) => [
 			"react-router",
@@ -4246,9 +4465,9 @@ async function setupAuth(config) {
 					dependencies: ["better-auth", "@better-auth/expo"],
 					projectDir: nativeDir
 				});
-				if (serverDirExists) await addPackageDependency({
+				if (authPackageDirExists) await addPackageDependency({
 					dependencies: ["@better-auth/expo"],
-					projectDir: serverDir
+					projectDir: authPackageDir
 				});
 			}
 		}
@@ -4267,6 +4486,34 @@ function generateAuthSecret(length = 32) {
 
 //#endregion
 //#region src/helpers/core/env-setup.ts
+function getClientServerVar(frontend, backend) {
+	const hasNextJs = frontend.includes("next");
+	const hasNuxt = frontend.includes("nuxt");
+	const hasSvelte = frontend.includes("svelte");
+	if (backend === "self") return {
+		key: "",
+		value: "",
+		write: false
+	};
+	let key = "VITE_SERVER_URL";
+	if (hasNextJs) key = "NEXT_PUBLIC_SERVER_URL";
+	else if (hasNuxt) key = "NUXT_PUBLIC_SERVER_URL";
+	else if (hasSvelte) key = "PUBLIC_SERVER_URL";
+	return {
+		key,
+		value: "http://localhost:3000",
+		write: true
+	};
+}
+function getConvexVar(frontend) {
+	const hasNextJs = frontend.includes("next");
+	const hasNuxt = frontend.includes("nuxt");
+	const hasSvelte = frontend.includes("svelte");
+	if (hasNextJs) return "NEXT_PUBLIC_CONVEX_URL";
+	if (hasNuxt) return "NUXT_PUBLIC_CONVEX_URL";
+	if (hasSvelte) return "PUBLIC_CONVEX_URL";
+	return "VITE_CONVEX_URL";
+}
 async function addEnvVariablesToFile(filePath, variables) {
 	await fs.ensureDir(path.dirname(filePath));
 	let envContent = "";
@@ -4325,22 +4572,13 @@ async function setupEnvironmentVariables(config) {
 	if (hasReactRouter || hasTanStackRouter || hasTanStackStart || hasNextJs || hasNuxt || hasSolid || hasSvelte) {
 		const clientDir = path.join(projectDir, "apps/web");
 		if (await fs.pathExists(clientDir)) {
-			let envVarName = "VITE_SERVER_URL";
-			let serverUrl = "http://localhost:3000";
-			if (hasNextJs) envVarName = "NEXT_PUBLIC_SERVER_URL";
-			else if (hasNuxt) envVarName = "NUXT_PUBLIC_SERVER_URL";
-			else if (hasSvelte) envVarName = "PUBLIC_SERVER_URL";
-			if (backend === "convex") {
-				if (hasNextJs) envVarName = "NEXT_PUBLIC_CONVEX_URL";
-				else if (hasNuxt) envVarName = "NUXT_PUBLIC_CONVEX_URL";
-				else if (hasSvelte) envVarName = "PUBLIC_CONVEX_URL";
-				else envVarName = "VITE_CONVEX_URL";
-				serverUrl = "https://<YOUR_CONVEX_URL>";
-			}
+			const baseVar = getClientServerVar(frontend, backend);
+			const envVarName = backend === "convex" ? getConvexVar(frontend) : baseVar.key;
+			const serverUrl = backend === "convex" ? "https://<YOUR_CONVEX_URL>" : baseVar.value;
 			const clientVars = [{
 				key: envVarName,
 				value: serverUrl,
-				condition: true
+				condition: backend === "convex" ? true : baseVar.write
 			}];
 			if (backend === "convex" && auth === "clerk") {
 				if (hasNextJs) clientVars.push({
@@ -4431,10 +4669,9 @@ async function setupEnvironmentVariables(config) {
 		return;
 	}
 	const serverDir = path.join(projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
-	const envPath = path.join(serverDir, ".env");
 	let corsOrigin = "http://localhost:3001";
-	if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
+	if (backend === "self") corsOrigin = "http://localhost:3001";
+	else if (hasReactRouter || hasSvelte) corsOrigin = "http://localhost:5173";
 	let databaseUrl = null;
 	if (database !== "none" && dbSetup === "none") switch (database) {
 		case "postgres":
@@ -4448,15 +4685,13 @@ async function setupEnvironmentVariables(config) {
 			break;
 		case "sqlite":
 			if (config.runtime === "workers") databaseUrl = "http://127.0.0.1:8080";
-			else databaseUrl = "file:./local.db";
+			else {
+				const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
+				databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
+			}
 			break;
 	}
 	const serverVars = [
-		{
-			key: "CORS_ORIGIN",
-			value: corsOrigin,
-			condition: true
-		},
 		{
 			key: "BETTER_AUTH_SECRET",
 			value: generateAuthSecret(),
@@ -4464,19 +4699,9 @@ async function setupEnvironmentVariables(config) {
 		},
 		{
 			key: "BETTER_AUTH_URL",
-			value: "http://localhost:3000",
+			value: backend === "self" ? "http://localhost:3001" : "http://localhost:3000",
 			condition: !!auth
 		},
-		{
-			key: "DATABASE_URL",
-			value: databaseUrl,
-			condition: database !== "none" && dbSetup === "none"
-		},
-		{
-			key: "GOOGLE_GENERATIVE_AI_API_KEY",
-			value: "",
-			condition: examples?.includes("ai") || false
-		},
 		{
 			key: "POLAR_ACCESS_TOKEN",
 			value: "",
@@ -4486,9 +4711,27 @@ async function setupEnvironmentVariables(config) {
 			key: "POLAR_SUCCESS_URL",
 			value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
 			condition: config.payments === "polar"
+		},
+		{
+			key: "CORS_ORIGIN",
+			value: corsOrigin,
+			condition: true
+		},
+		{
+			key: "GOOGLE_GENERATIVE_AI_API_KEY",
+			value: "",
+			condition: examples?.includes("ai") || false
+		},
+		{
+			key: "DATABASE_URL",
+			value: databaseUrl,
+			condition: database !== "none" && dbSetup === "none"
 		}
 	];
-	await addEnvVariablesToFile(envPath, serverVars);
+	if (backend === "self") {
+		const webDir = path.join(projectDir, "apps/web");
+		if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverVars);
+	} else if (await fs.pathExists(serverDir)) await addEnvVariablesToFile(path.join(serverDir, ".env"), serverVars);
 	const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
 	const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
 	if (isUnifiedAlchemy) {
@@ -4508,12 +4751,15 @@ async function setupEnvironmentVariables(config) {
 			}]);
 		}
 		if (serverDeploy === "alchemy") {
-			const serverDir$1 = path.join(projectDir, "apps/server");
-			if (await fs.pathExists(serverDir$1)) await addEnvVariablesToFile(path.join(serverDir$1, ".env"), [{
+			const serverAlchemyVars = [{
 				key: "ALCHEMY_PASSWORD",
 				value: "please-change-this",
 				condition: true
-			}]);
+			}];
+			if (backend === "self") {
+				const webDir = path.join(projectDir, "apps/web");
+				if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverAlchemyVars);
+			} else await addEnvVariablesToFile(path.join(serverDir, ".env"), serverAlchemyVars);
 		}
 	}
 }
@@ -4521,9 +4767,10 @@ async function setupEnvironmentVariables(config) {
 //#endregion
 //#region src/helpers/database-providers/d1-setup.ts
 async function setupCloudflareD1(config) {
-	const { projectDir, serverDeploy, orm } = config;
+	const { projectDir, serverDeploy, orm, backend } = config;
 	if (serverDeploy === "wrangler") {
-		const envPath = path.join(projectDir, "apps/server", ".env");
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		const envPath = path.join(projectDir, targetApp, ".env");
 		const variables = [
 			{
 				key: "CLOUDFLARE_ACCOUNT_ID",
@@ -4546,16 +4793,17 @@ async function setupCloudflareD1(config) {
 		} catch (_err) {}
 	}
 	if ((serverDeploy === "wrangler" || serverDeploy === "alchemy") && orm === "prisma") {
-		const envPath = path.join(projectDir, "apps/server", ".env");
+		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
+		const envPath = path.join(projectDir, targetApp2, ".env");
 		const variables = [{
 			key: "DATABASE_URL",
-			value: "file:./local.db",
+			value: `file:${path.join(projectDir, "apps/server", "local.db")}`,
 			condition: true
 		}];
 		try {
 			await addEnvVariablesToFile(envPath, variables);
 		} catch (_err) {}
-		const serverDir = path.join(projectDir, "apps/server");
+		const serverDir = path.join(projectDir, backend === "self" ? "apps/web" : "apps/server");
 		await addPackageDependency({
 			dependencies: ["@prisma/adapter-d1"],
 			projectDir: serverDir
@@ -4606,14 +4854,13 @@ async function commandExists(command) {
 //#endregion
 //#region src/helpers/database-providers/mongodb-atlas-setup.ts
 async function checkAtlasCLI() {
-	const s = spinner();
-	s.start("Checking for MongoDB Atlas CLI...");
 	try {
 		const exists = await commandExists("atlas");
-		s.stop(exists ? "MongoDB Atlas CLI found" : pc.yellow("MongoDB Atlas CLI not found"));
+		if (exists) log.info("MongoDB Atlas CLI found");
+		else log.warn(pc.yellow("MongoDB Atlas CLI not found"));
 		return exists;
 	} catch (_error) {
-		s.stop(pc.red("Error checking MongoDB Atlas CLI"));
+		log.error(pc.red("Error checking MongoDB Atlas CLI"));
 		return false;
 	}
 }
@@ -4624,12 +4871,13 @@ async function initMongoDBAtlas(serverDir) {
 			log.info(pc.yellow("Please install it from: https://www.mongodb.com/docs/atlas/cli/current/install-atlas-cli/"));
 			return null;
 		}
-		log.info(pc.blue("Running MongoDB Atlas setup..."));
+		log.info("Running MongoDB Atlas setup...");
 		await execa("atlas", ["deployments", "setup"], {
 			cwd: serverDir,
+			shell: true,
 			stdio: "inherit"
 		});
-		log.info(pc.green("MongoDB Atlas deployment ready"));
+		log.success("MongoDB Atlas deployment ready");
 		const connectionString = await text({
 			message: "Enter your MongoDB connection string:",
 			placeholder: "mongodb+srv://username:password@cluster.mongodb.net/database",
@@ -4648,9 +4896,10 @@ async function initMongoDBAtlas(serverDir) {
 		return null;
 	}
 }
-async function writeEnvFile$3(projectDir, config) {
+async function writeEnvFile$3(projectDir, backend, config) {
 	try {
-		const envPath = path.join(projectDir, "apps/server", ".env");
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		const envPath = path.join(projectDir, targetApp, ".env");
 		const variables = [{
 			key: "DATABASE_URL",
 			value: config?.connectionString ?? "mongodb://localhost:27017/mydb",
@@ -4679,16 +4928,14 @@ ${pc.green("MongoDB Atlas Manual Setup Instructions:")}
 `);
 }
 async function setupMongoDBAtlas(config, cliInput) {
-	const { projectDir } = config;
+	const { projectDir, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
-	const mainSpinner = spinner();
-	mainSpinner.start("Setting up MongoDB Atlas...");
-	const serverDir = path.join(projectDir, "apps/server");
+	const serverDir = path.join(projectDir, "packages/db");
 	try {
 		await fs.ensureDir(serverDir);
 		if (manualDb) {
-			mainSpinner.stop("MongoDB Atlas manual setup selected");
-			await writeEnvFile$3(projectDir);
+			log.info("MongoDB Atlas manual setup selected");
+			await writeEnvFile$3(projectDir, backend);
 			displayManualSetupInstructions$3();
 			return;
 		}
@@ -4707,26 +4954,24 @@ async function setupMongoDBAtlas(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			mainSpinner.stop("MongoDB Atlas manual setup selected");
-			await writeEnvFile$3(projectDir);
+			log.info("MongoDB Atlas manual setup selected");
+			await writeEnvFile$3(projectDir, backend);
 			displayManualSetupInstructions$3();
 			return;
 		}
-		mainSpinner.stop("MongoDB Atlas setup ready");
 		const config$1 = await initMongoDBAtlas(serverDir);
 		if (config$1) {
-			await writeEnvFile$3(projectDir, config$1);
+			await writeEnvFile$3(projectDir, backend, config$1);
 			log.success(pc.green("MongoDB Atlas setup complete! Connection saved to .env file."));
 		} else {
 			log.warn(pc.yellow("Falling back to local MongoDB configuration"));
-			await writeEnvFile$3(projectDir);
+			await writeEnvFile$3(projectDir, backend);
 			displayManualSetupInstructions$3();
 		}
 	} catch (error) {
-		mainSpinner.stop(pc.red("MongoDB Atlas setup failed"));
 		consola.error(pc.red(`Error during MongoDB Atlas setup: ${error instanceof Error ? error.message : String(error)}`));
 		try {
-			await writeEnvFile$3(projectDir);
+			await writeEnvFile$3(projectDir, backend);
 			displayManualSetupInstructions$3();
 		} catch {}
 	}
@@ -4783,7 +5028,7 @@ async function executeNeonCommand(packageManager, commandArgsString, spinnerText
 }
 async function createNeonProject(projectName, regionId, packageManager) {
 	try {
-		const commandArgsString = `neonctl projects create --name ${projectName} --region-id ${regionId} --output json`;
+		const commandArgsString = `neonctl@latest projects create --name ${projectName} --region-id ${regionId} --output json`;
 		const { stdout } = await executeNeonCommand(packageManager, commandArgsString, `Creating Neon project "${projectName}"...`);
 		const response = JSON.parse(stdout);
 		if (response.project && response.connection_uris && response.connection_uris.length > 0) {
@@ -4803,8 +5048,9 @@ async function createNeonProject(projectName, regionId, packageManager) {
 		consola$1.error(pc.red("Failed to create Neon project"));
 	}
 }
-async function writeEnvFile$2(projectDir, config) {
-	const envPath = path.join(projectDir, "apps/server", ".env");
+async function writeEnvFile$2(projectDir, backend, config) {
+	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const envPath = path.join(projectDir, targetApp, ".env");
 	const variables = [{
 		key: "DATABASE_URL",
 		value: config?.connectionString ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
@@ -4813,16 +5059,17 @@ async function writeEnvFile$2(projectDir, config) {
 	await addEnvVariablesToFile(envPath, variables);
 	return true;
 }
-async function setupWithNeonDb(projectDir, packageManager) {
+async function setupWithNeonDb(projectDir, packageManager, backend) {
 	try {
 		const s = spinner();
 		s.start("Creating Neon database using neondb...");
-		const serverDir = path.join(projectDir, "apps/server");
-		await fs.ensureDir(serverDir);
-		const packageCmd = getPackageExecutionCommand(packageManager, "neondb --yes");
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		const targetDir = path.join(projectDir, targetApp);
+		await fs.ensureDir(targetDir);
+		const packageCmd = getPackageExecutionCommand(packageManager, "neondb@latest --yes");
 		await execa(packageCmd, {
 			shell: true,
-			cwd: serverDir
+			cwd: targetDir
 		});
 		s.stop(pc.green("Neon database created successfully!"));
 		return true;
@@ -4831,23 +5078,23 @@ async function setupWithNeonDb(projectDir, packageManager) {
 		throw error;
 	}
 }
-function displayManualSetupInstructions$2() {
+function displayManualSetupInstructions$2(target) {
 	log.info(`Manual Neon PostgreSQL Setup Instructions:
 
 1. Visit https://neon.tech and create an account
 2. Create a new project from the dashboard
 3. Get your connection string
-4. Add the database URL to the .env file in apps/server/.env
+4. Add the database URL to the .env file in ${target}/.env
 
 DATABASE_URL="your_connection_string"`);
 }
 async function setupNeonPostgres(config, cliInput) {
-	const { packageManager, projectDir } = config;
+	const { packageManager, projectDir, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
 	try {
 		if (manualDb) {
-			await writeEnvFile$2(projectDir);
-			displayManualSetupInstructions$2();
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const mode = await select({
@@ -4865,8 +5112,8 @@ async function setupNeonPostgres(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			await writeEnvFile$2(projectDir);
-			displayManualSetupInstructions$2();
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const setupMethod = await select({
@@ -4883,7 +5130,7 @@ async function setupNeonPostgres(config, cliInput) {
 			initialValue: "neondb"
 		});
 		if (isCancel(setupMethod)) return exitCancelled("Operation cancelled");
-		if (setupMethod === "neondb") await setupWithNeonDb(projectDir, packageManager);
+		if (setupMethod === "neondb") await setupWithNeonDb(projectDir, packageManager, backend);
 		else {
 			const suggestedProjectName = path.basename(projectDir);
 			const projectName = await text({
@@ -4901,22 +5148,22 @@ async function setupNeonPostgres(config, cliInput) {
 			if (!neonConfig) throw new Error("Failed to create project - couldn't get connection information");
 			const finalSpinner = spinner();
 			finalSpinner.start("Configuring database connection");
-			await fs.ensureDir(path.join(projectDir, "apps/server"));
-			await writeEnvFile$2(projectDir, neonConfig);
+			await writeEnvFile$2(projectDir, backend, neonConfig);
 			finalSpinner.stop("Neon database configured!");
 		}
 	} catch (error) {
 		if (error instanceof Error) consola$1.error(pc.red(error.message));
-		await writeEnvFile$2(projectDir);
-		displayManualSetupInstructions$2();
+		await writeEnvFile$2(projectDir, backend);
+		displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 	}
 }
 
 //#endregion
 //#region src/helpers/database-providers/planetscale-setup.ts
 async function setupPlanetScale(config) {
-	const { projectDir, database, orm } = config;
-	const envPath = path.join(projectDir, "apps/server", ".env");
+	const { projectDir, database, orm, backend } = config;
+	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const envPath = path.join(projectDir, targetApp, ".env");
 	if (database === "mysql" && orm === "drizzle") {
 		const variables = [
 			{
@@ -4940,7 +5187,7 @@ async function setupPlanetScale(config) {
 				condition: true
 			}
 		];
-		await fs.ensureDir(path.join(projectDir, "apps/server"));
+		await fs.ensureDir(path.join(projectDir, targetApp));
 		await addEnvVariablesToFile(envPath, variables);
 	}
 	if (database === "postgres" && orm === "prisma") {
@@ -4949,7 +5196,7 @@ async function setupPlanetScale(config) {
 			value: "postgresql://username:password@host/database?sslaccept=strict",
 			condition: true
 		}];
-		await fs.ensureDir(path.join(projectDir, "apps/server"));
+		await fs.ensureDir(path.join(projectDir, targetApp));
 		await addEnvVariablesToFile(envPath, variables);
 	}
 	if (database === "postgres" && orm === "drizzle") {
@@ -4958,7 +5205,7 @@ async function setupPlanetScale(config) {
 			value: "postgresql://username:password@host/database?sslmode=verify-full",
 			condition: true
 		}];
-		await fs.ensureDir(path.join(projectDir, "apps/server"));
+		await fs.ensureDir(path.join(projectDir, targetApp));
 		await addEnvVariablesToFile(envPath, variables);
 	}
 	if (database === "mysql" && orm === "prisma") {
@@ -4967,7 +5214,7 @@ async function setupPlanetScale(config) {
 			value: "mysql://username:password@host/database?sslaccept=strict",
 			condition: true
 		}];
-		await fs.ensureDir(path.join(projectDir, "apps/server"));
+		await fs.ensureDir(path.join(projectDir, targetApp));
 		await addEnvVariablesToFile(envPath, variables);
 	}
 }
@@ -5037,7 +5284,7 @@ async function initPrismaDatabase(serverDir, packageManager) {
 	try {
 		const prismaDir = path.join(serverDir, "prisma");
 		await fs.ensureDir(prismaDir);
-		log.info("Starting Prisma PostgreSQL setup. Please follow the instructions below:");
+		log.info("Starting Prisma PostgreSQL setup.");
 		const prismaInitCommand = getPackageExecutionCommand(packageManager, "prisma init --db");
 		await execa(prismaInitCommand, {
 			cwd: serverDir,
@@ -5059,9 +5306,10 @@ async function initPrismaDatabase(serverDir, packageManager) {
 		return null;
 	}
 }
-async function writeEnvFile$1(projectDir, config) {
+async function writeEnvFile$1(projectDir, backend, config) {
 	try {
-		const envPath = path.join(projectDir, "apps/server", ".env");
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		const envPath = path.join(projectDir, targetApp, ".env");
 		const variables = [{
 			key: "DATABASE_URL",
 			value: config?.databaseUrl ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
@@ -5077,31 +5325,32 @@ async function writeEnvFile$1(projectDir, config) {
 		consola$1.error("Failed to update environment configuration");
 	}
 }
-async function addDotenvImportToPrismaConfig(projectDir) {
+async function addDotenvImportToPrismaConfig(projectDir, backend) {
 	try {
-		const prismaConfigPath = path.join(projectDir, "apps/server/prisma.config.ts");
+		const prismaConfigPath = path.join(projectDir, "packages/db/prisma.config.ts");
 		let content = await fs.readFile(prismaConfigPath, "utf8");
-		content = `import "dotenv/config";\n${content}`;
+		content = `import dotenv from "dotenv";\ndotenv.config({ path: "${backend === "self" ? "../../apps/web/.env" : "../../apps/server/.env"}" });\n${content}`;
 		await fs.writeFile(prismaConfigPath, content);
 	} catch (_error) {
 		consola$1.error("Failed to update prisma.config.ts");
 	}
 }
-function displayManualSetupInstructions$1() {
+function displayManualSetupInstructions$1(target) {
 	log.info(`Manual Prisma PostgreSQL Setup Instructions:
 
 1. Visit https://console.prisma.io and create an account
 2. Create a new PostgreSQL database from the dashboard
 3. Get your database URL
-4. Add the database URL to the .env file in apps/server/.env
+4. Add the database URL to the .env file in ${target}/.env
 
 DATABASE_URL="your_database_url"`);
 }
-async function addPrismaAccelerateExtension(serverDir) {
+async function addPrismaAccelerateExtension(projectDir) {
 	try {
+		const dbPackageDir = path.join(projectDir, "packages/db");
 		await addPackageDependency({
 			dependencies: ["@prisma/extension-accelerate"],
-			projectDir: serverDir
+			projectDir: dbPackageDir
 		});
 		return true;
 	} catch (_error) {
@@ -5110,14 +5359,14 @@ async function addPrismaAccelerateExtension(serverDir) {
 	}
 }
 async function setupPrismaPostgres(config, cliInput) {
-	const { packageManager, projectDir, orm } = config;
+	const { packageManager, projectDir, orm, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
-	const serverDir = path.join(projectDir, "apps/server");
+	const dbDir = path.join(projectDir, "packages/db");
 	try {
-		await fs.ensureDir(serverDir);
+		await fs.ensureDir(dbDir);
 		if (manualDb) {
-			await writeEnvFile$1(projectDir);
-			displayManualSetupInstructions$1();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const mode = await select({
@@ -5135,8 +5384,8 @@ async function setupPrismaPostgres(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			await writeEnvFile$1(projectDir);
-			displayManualSetupInstructions$1();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
 		const setupOptions = [{
@@ -5156,26 +5405,26 @@ async function setupPrismaPostgres(config, cliInput) {
 		});
 		if (isCancel(setupMethod)) return exitCancelled("Operation cancelled");
 		let prismaConfig = null;
-		if (setupMethod === "create-db") prismaConfig = await setupWithCreateDb(serverDir, packageManager, orm);
-		else prismaConfig = await initPrismaDatabase(serverDir, packageManager);
+		if (setupMethod === "create-db") prismaConfig = await setupWithCreateDb(dbDir, packageManager, orm);
+		else prismaConfig = await initPrismaDatabase(dbDir, packageManager);
 		if (prismaConfig) {
-			await writeEnvFile$1(projectDir, prismaConfig);
+			await writeEnvFile$1(projectDir, backend, prismaConfig);
 			if (orm === "prisma") {
-				await addDotenvImportToPrismaConfig(projectDir);
-				await addPrismaAccelerateExtension(serverDir);
+				await addDotenvImportToPrismaConfig(projectDir, backend);
+				await addPrismaAccelerateExtension(projectDir);
 			}
 			const connectionType = orm === "drizzle" ? "direct connection" : "Prisma Accelerate";
 			log.success(pc.green(`Prisma Postgres database configured successfully with ${connectionType}!`));
 			if (prismaConfig.claimUrl) log.info(pc.blue(`Claim URL saved to .env: ${prismaConfig.claimUrl}`));
 		} else {
-			await writeEnvFile$1(projectDir);
-			displayManualSetupInstructions$1();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
 		}
 	} catch (error) {
 		consola$1.error(pc.red(`Error during Prisma Postgres setup: ${error instanceof Error ? error.message : String(error)}`));
 		try {
-			await writeEnvFile$1(projectDir);
-			displayManualSetupInstructions$1();
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1(backend === "self" ? "apps/web" : "apps/server");
 		} catch {}
 		log.info("Setup completed with manual configuration required.");
 	}
@@ -5183,9 +5432,10 @@ async function setupPrismaPostgres(config, cliInput) {
 
 //#endregion
 //#region src/helpers/database-providers/supabase-setup.ts
-async function writeSupabaseEnvFile(projectDir, databaseUrl) {
+async function writeSupabaseEnvFile(projectDir, backend, databaseUrl) {
 	try {
-		const envPath = path.join(projectDir, "apps/server", ".env");
+		const targetApp = backend === "self" ? "apps/web" : "apps/server";
+		const envPath = path.join(projectDir, targetApp, ".env");
 		const dbUrlToUse = databaseUrl || "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
 		await addEnvVariablesToFile(envPath, [{
 			key: "DATABASE_URL",
@@ -5262,23 +5512,23 @@ function displayManualSupabaseInstructions(output) {
 	log.info(`"Manual Supabase Setup Instructions:"
 1. Ensure Docker is installed and running.
 2. Install the Supabase CLI (e.g., \`npm install -g supabase\`).
-3. Run \`supabase init\` in your project's \`apps/server\` directory.
-4. Run \`supabase start\` in your project's \`apps/server\` directory.
+3. Run \`supabase init\` in your project's \`packages/db\` directory.
+4. Run \`supabase start\` in your project's \`packages/db\` directory.
 5. Copy the 'DB URL' from the output.${output ? `
 ${pc.bold("Relevant output from `supabase start`:")}
 ${pc.dim(output)}` : ""}
-6. Add the DB URL to the .env file in \`apps/server/.env\` as \`DATABASE_URL\`:
+6. Add the DB URL to the .env file in \`packages/db/.env\` as \`DATABASE_URL\`:
 			${pc.gray("DATABASE_URL=\"your_supabase_db_url\"")}`);
 }
 async function setupSupabase(config, cliInput) {
-	const { projectDir, packageManager } = config;
+	const { projectDir, packageManager, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
-	const serverDir = path.join(projectDir, "apps", "server");
+	const serverDir = path.join(projectDir, "packages", "db");
 	try {
 		await fs.ensureDir(serverDir);
 		if (manualDb) {
 			displayManualSupabaseInstructions();
-			await writeSupabaseEnvFile(projectDir, "");
+			await writeSupabaseEnvFile(projectDir, backend, "");
 			return;
 		}
 		const mode = await select({
@@ -5297,7 +5547,7 @@ async function setupSupabase(config, cliInput) {
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
 			displayManualSupabaseInstructions();
-			await writeSupabaseEnvFile(projectDir, "");
+			await writeSupabaseEnvFile(projectDir, backend, "");
 			return;
 		}
 		if (!await initializeSupabase(serverDir, packageManager)) {
@@ -5310,7 +5560,7 @@ async function setupSupabase(config, cliInput) {
 			return;
 		}
 		const dbUrl = extractDbUrl(supabaseOutput);
-		if (dbUrl) if (await writeSupabaseEnvFile(projectDir, dbUrl)) log.success(pc.green("Supabase local development setup ready!"));
+		if (dbUrl) if (await writeSupabaseEnvFile(projectDir, backend, dbUrl)) log.success(pc.green("Supabase local development setup ready!"));
 		else {
 			log.error(pc.red("Supabase setup completed, but failed to update .env automatically."));
 			displayManualSupabaseInstructions(supabaseOutput);
@@ -5438,8 +5688,9 @@ async function createTursoDatabase(dbName, groupName) {
 		s.stop(pc.red("Failed to retrieve database connection details"));
 	}
 }
-async function writeEnvFile(projectDir, config) {
-	const envPath = path.join(projectDir, "apps/server", ".env");
+async function writeEnvFile(projectDir, backend, config) {
+	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const envPath = path.join(projectDir, targetApp, ".env");
 	const variables = [{
 		key: "DATABASE_URL",
 		value: config?.dbUrl ?? "",
@@ -5463,12 +5714,12 @@ DATABASE_URL=your_database_url
 DATABASE_AUTH_TOKEN=your_auth_token`);
 }
 async function setupTurso(config, cliInput) {
-	const { orm, projectDir } = config;
+	const { orm, projectDir, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
 	const setupSpinner = spinner();
 	try {
 		if (manualDb) {
-			await writeEnvFile(projectDir);
+			await writeEnvFile(projectDir, backend);
 			displayManualSetupInstructions();
 			return;
 		}
@@ -5487,7 +5738,7 @@ async function setupTurso(config, cliInput) {
 		});
 		if (isCancel(mode)) return exitCancelled("Operation cancelled");
 		if (mode === "manual") {
-			await writeEnvFile(projectDir);
+			await writeEnvFile(projectDir, backend);
 			displayManualSetupInstructions();
 			return;
 		}
@@ -5497,7 +5748,7 @@ async function setupTurso(config, cliInput) {
 		if (platform === "win32") {
 			if (setupSpinner) setupSpinner.stop(pc.yellow("Turso setup not supported on Windows"));
 			log.warn(pc.yellow("Automatic Turso setup is not supported on Windows."));
-			await writeEnvFile(projectDir);
+			await writeEnvFile(projectDir, backend);
 			displayManualSetupInstructions();
 			return;
 		}
@@ -5509,7 +5760,7 @@ async function setupTurso(config, cliInput) {
 			});
 			if (isCancel(shouldInstall)) return exitCancelled("Operation cancelled");
 			if (!shouldInstall) {
-				await writeEnvFile(projectDir);
+				await writeEnvFile(projectDir, backend);
 				displayManualSetupInstructions();
 				return;
 			}
@@ -5531,7 +5782,7 @@ async function setupTurso(config, cliInput) {
 			dbName = dbNameResponse;
 			try {
 				const config$1 = await createTursoDatabase(dbName, selectedGroup);
-				await writeEnvFile(projectDir, config$1);
+				await writeEnvFile(projectDir, backend, config$1);
 				success = true;
 			} catch (error) {
 				if (error instanceof Error && error.message === "DATABASE_EXISTS") {
@@ -5544,7 +5795,7 @@ async function setupTurso(config, cliInput) {
 	} catch (error) {
 		if (setupSpinner) setupSpinner.stop(pc.red("Turso CLI availability check failed"));
 		consola.error(pc.red(`Error during Turso setup: ${error instanceof Error ? error.message : String(error)}`));
-		await writeEnvFile(projectDir);
+		await writeEnvFile(projectDir, backend);
 		displayManualSetupInstructions();
 		log.success("Setup completed with manual configuration required.");
 	}
@@ -5556,40 +5807,48 @@ async function setupDatabase(config, cliInput) {
 	const { database, orm, dbSetup, backend, projectDir } = config;
 	if (backend === "convex" || database === "none") {
 		if (backend !== "convex") {
-			const serverDir$1 = path.join(projectDir, "apps/server");
-			const serverDbDir = path.join(serverDir$1, "src/db");
+			const serverDir = path.join(projectDir, "apps/server");
+			const serverDbDir = path.join(serverDir, "src/db");
 			if (await fs.pathExists(serverDbDir)) await fs.remove(serverDbDir);
 		}
 		return;
 	}
 	const s = spinner();
-	const serverDir = path.join(projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
+	const dbPackageDir = path.join(projectDir, "packages/db");
+	if (!await fs.pathExists(dbPackageDir)) return;
 	try {
-		if (orm === "prisma") if (database === "mysql" && dbSetup === "planetscale") await addPackageDependency({
-			dependencies: [
-				"@prisma/client",
-				"@prisma/adapter-planetscale",
-				"@planetscale/database"
-			],
-			devDependencies: ["prisma"],
-			projectDir: serverDir
-		});
-		else if (database === "sqlite" && dbSetup === "turso") await addPackageDependency({
-			dependencies: ["@prisma/client", "@prisma/adapter-libsql"],
-			devDependencies: ["prisma"],
-			projectDir: serverDir
-		});
-		else await addPackageDependency({
-			dependencies: ["@prisma/client"],
-			devDependencies: ["prisma"],
-			projectDir: serverDir
-		});
-		else if (orm === "drizzle") {
+		if (orm === "prisma") {
+			if (database === "mysql" && dbSetup === "planetscale") await addPackageDependency({
+				dependencies: [
+					"@prisma/client",
+					"@prisma/adapter-planetscale",
+					"@planetscale/database"
+				],
+				devDependencies: ["prisma"],
+				projectDir: dbPackageDir
+			});
+			else if (database === "sqlite" && dbSetup === "turso") await addPackageDependency({
+				dependencies: ["@prisma/client", "@prisma/adapter-libsql"],
+				devDependencies: ["prisma"],
+				projectDir: dbPackageDir
+			});
+			else await addPackageDependency({
+				dependencies: ["@prisma/client"],
+				devDependencies: ["prisma"],
+				projectDir: dbPackageDir
+			});
+			if (backend === "self") {
+				const webDir = path.join(projectDir, "apps/web");
+				if (await fs.pathExists(webDir)) await addPackageDependency({
+					dependencies: ["@prisma/client"],
+					projectDir: webDir
+				});
+			}
+		} else if (orm === "drizzle") {
 			if (database === "sqlite") await addPackageDependency({
 				dependencies: ["drizzle-orm", "@libsql/client"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 			else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
 				dependencies: [
@@ -5598,32 +5857,32 @@ async function setupDatabase(config, cliInput) {
 					"ws"
 				],
 				devDependencies: ["drizzle-kit", "@types/ws"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 			else if (dbSetup === "planetscale") await addPackageDependency({
 				dependencies: ["drizzle-orm", "pg"],
 				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 			else await addPackageDependency({
 				dependencies: ["drizzle-orm", "pg"],
 				devDependencies: ["drizzle-kit", "@types/pg"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 			else if (database === "mysql") if (dbSetup === "planetscale") await addPackageDependency({
 				dependencies: ["drizzle-orm", "@planetscale/database"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 			else await addPackageDependency({
 				dependencies: ["drizzle-orm", "mysql2"],
 				devDependencies: ["drizzle-kit"],
-				projectDir: serverDir
+				projectDir: dbPackageDir
 			});
 		} else if (orm === "mongoose") await addPackageDependency({
 			dependencies: ["mongoose"],
 			devDependencies: [],
-			projectDir: serverDir
+			projectDir: dbPackageDir
 		});
 		if (dbSetup === "docker") await setupDockerCompose(config);
 		else if (database === "sqlite" && dbSetup === "turso") await setupTurso(config, cliInput);
@@ -5646,7 +5905,7 @@ async function setupDatabase(config, cliInput) {
 //#region src/helpers/core/runtime-setup.ts
 async function setupRuntime(config) {
 	const { runtime, backend, projectDir } = config;
-	if (backend === "convex" || backend === "next" || runtime === "none") return;
+	if (backend === "convex" || backend === "self" || runtime === "none") return;
 	const serverDir = path.join(projectDir, "apps/server");
 	if (!await fs.pathExists(serverDir)) return;
 	if (runtime === "bun") await setupBunRuntime(serverDir, backend);
@@ -6035,15 +6294,14 @@ async function initializeGit(projectDir, useGit) {
 async function setupPayments(config) {
 	const { payments, projectDir, frontend } = config;
 	if (!payments || payments === "none") return;
-	const serverDir = path.join(projectDir, "apps/server");
 	const clientDir = path.join(projectDir, "apps/web");
-	const serverDirExists = await fs.pathExists(serverDir);
+	const authDir = path.join(projectDir, "packages/auth");
 	const clientDirExists = await fs.pathExists(clientDir);
-	if (!serverDirExists) return;
+	const authDirExists = await fs.pathExists(authDir);
 	if (payments === "polar") {
-		await addPackageDependency({
+		if (authDirExists) await addPackageDependency({
 			dependencies: ["@polar-sh/better-auth", "@polar-sh/sdk"],
-			projectDir: serverDir
+			projectDir: authDir
 		});
 		if (clientDirExists) {
 			if (frontend.some((f) => [
@@ -6166,7 +6424,7 @@ async function displayPostInstallInstructions(config) {
 	else if (!hasNative && !addons?.includes("starlight")) output += `${pc.yellow("NOTE:")} You are creating a backend-only app\n   (no frontend selected)\n`;
 	if (!isConvex) {
 		output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
-		if (api === "orpc") if (backend === "next") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/rpc/api\n`;
+		if (api === "orpc") if (backend === "self") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/rpc/api\n`;
 		else output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api\n`;
 	}
 	if (addons?.includes("starlight")) output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
@@ -6280,12 +6538,81 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy) {
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
+//#endregion
+//#region src/helpers/core/workspace-setup.ts
+async function setupWorkspaceDependencies(projectDir, options) {
+	const projectName = options.projectName;
+	const workspaceVersion = options.packageManager === "npm" ? "*" : "workspace:*";
+	const commonDeps = ["dotenv", "zod"];
+	const commonDevDeps = ["tsdown"];
+	const dbPackageDir = path.join(projectDir, "packages/db");
+	if (await fs.pathExists(dbPackageDir)) await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		projectDir: dbPackageDir
+	});
+	const authPackageDir = path.join(projectDir, "packages/auth");
+	if (await fs.pathExists(authPackageDir)) await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		customDependencies: { [`@${projectName}/db`]: workspaceVersion },
+		projectDir: authPackageDir
+	});
+	const apiPackageDir = path.join(projectDir, "packages/api");
+	if (await fs.pathExists(apiPackageDir)) await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		customDependencies: {
+			[`@${projectName}/auth`]: workspaceVersion,
+			[`@${projectName}/db`]: workspaceVersion
+		},
+		projectDir: apiPackageDir
+	});
+	const serverPackageDir = path.join(projectDir, "apps/server");
+	if (await fs.pathExists(serverPackageDir)) await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		customDependencies: {
+			[`@${projectName}/api`]: workspaceVersion,
+			[`@${projectName}/auth`]: workspaceVersion,
+			[`@${projectName}/db`]: workspaceVersion
+		},
+		projectDir: serverPackageDir
+	});
+	const webPackageDir = path.join(projectDir, "apps/web");
+	if (await fs.pathExists(webPackageDir)) {
+		const webDeps = {};
+		webDeps[`@${projectName}/api`] = workspaceVersion;
+		webDeps[`@${projectName}/auth`] = workspaceVersion;
+		webDeps[`@${projectName}/db`] = workspaceVersion;
+		if (Object.keys(webDeps).length > 0) await addPackageDependency({
+			customDependencies: webDeps,
+			projectDir: webPackageDir
+		});
+	}
+	await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: commonDevDeps,
+		projectDir
+	});
+}
+
 //#endregion
 //#region src/helpers/core/project-config.ts
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
-	if (options.backend !== "convex") await updateServerPackageJson(projectDir, options);
-	else await updateConvexPackageJson(projectDir, options);
+	if (options.backend === "convex") await updateConvexPackageJson(projectDir, options);
+	else if (options.backend === "self") {
+		await updateDbPackageJson(projectDir, options);
+		await updateAuthPackageJson(projectDir, options);
+		await updateApiPackageJson(projectDir, options);
+		await setupWorkspaceDependencies(projectDir, options);
+	} else if (options.backend !== "none") {
+		await updateServerPackageJson(projectDir, options);
+		await updateAuthPackageJson(projectDir, options);
+		await updateApiPackageJson(projectDir, options);
+		await setupWorkspaceDependencies(projectDir, options);
+	}
 }
 async function updateRootPackageJson(projectDir, options) {
 	const rootPackageJsonPath = path.join(projectDir, "package.json");
@@ -6295,6 +6622,7 @@ async function updateRootPackageJson(projectDir, options) {
 	if (!packageJson.scripts) packageJson.scripts = {};
 	const scripts = packageJson.scripts;
 	const backendPackageName = options.backend === "convex" ? `@${options.projectName}/backend` : "server";
+	const dbPackageName = `@${options.projectName}/db`;
 	let serverDevScript = "";
 	if (options.addons.includes("turborepo")) serverDevScript = `turbo -F ${backendPackageName} dev`;
 	else if (options.packageManager === "bun") serverDevScript = `bun run --filter ${backendPackageName} dev`;
@@ -6311,24 +6639,24 @@ async function updateRootPackageJson(projectDir, options) {
 		scripts["check-types"] = "turbo check-types";
 		scripts["dev:native"] = "turbo -F native dev";
 		scripts["dev:web"] = "turbo -F web dev";
-		scripts["dev:server"] = serverDevScript;
+		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
 		if (options.backend === "convex") scripts["dev:setup"] = `turbo -F ${backendPackageName} dev:setup`;
 		if (needsDbScripts) {
-			scripts["db:push"] = `turbo -F ${backendPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `turbo -F ${backendPackageName} db:studio`;
+			scripts["db:push"] = `turbo -F ${dbPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `turbo -F ${dbPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
-				scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `turbo -F ${dbPackageName} db:generate`;
+				scripts["db:migrate"] = `turbo -F ${dbPackageName} db:migrate`;
 			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `turbo -F ${backendPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `turbo -F ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `turbo -F ${dbPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `turbo -F ${dbPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `turbo -F ${backendPackageName} db:start`;
-			scripts["db:watch"] = `turbo -F ${backendPackageName} db:watch`;
-			scripts["db:stop"] = `turbo -F ${backendPackageName} db:stop`;
-			scripts["db:down"] = `turbo -F ${backendPackageName} db:down`;
+			scripts["db:start"] = `turbo -F ${dbPackageName} db:start`;
+			scripts["db:watch"] = `turbo -F ${dbPackageName} db:watch`;
+			scripts["db:stop"] = `turbo -F ${dbPackageName} db:stop`;
+			scripts["db:down"] = `turbo -F ${dbPackageName} db:down`;
 		}
 	} else if (options.packageManager === "pnpm") {
 		scripts.dev = devScript;
@@ -6336,24 +6664,24 @@ async function updateRootPackageJson(projectDir, options) {
 		scripts["check-types"] = "pnpm -r check-types";
 		scripts["dev:native"] = "pnpm --filter native dev";
 		scripts["dev:web"] = "pnpm --filter web dev";
-		scripts["dev:server"] = serverDevScript;
+		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
 		if (options.backend === "convex") scripts["dev:setup"] = `pnpm --filter ${backendPackageName} dev:setup`;
 		if (needsDbScripts) {
-			scripts["db:push"] = `pnpm --filter ${backendPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `pnpm --filter ${backendPackageName} db:studio`;
+			scripts["db:push"] = `pnpm --filter ${dbPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `pnpm --filter ${dbPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
-				scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `pnpm --filter ${dbPackageName} db:generate`;
+				scripts["db:migrate"] = `pnpm --filter ${dbPackageName} db:migrate`;
 			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `pnpm --filter ${backendPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `pnpm --filter ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `pnpm --filter ${dbPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `pnpm --filter ${dbPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `pnpm --filter ${backendPackageName} db:start`;
-			scripts["db:watch"] = `pnpm --filter ${backendPackageName} db:watch`;
-			scripts["db:stop"] = `pnpm --filter ${backendPackageName} db:stop`;
-			scripts["db:down"] = `pnpm --filter ${backendPackageName} db:down`;
+			scripts["db:start"] = `pnpm --filter ${dbPackageName} db:start`;
+			scripts["db:watch"] = `pnpm --filter ${dbPackageName} db:watch`;
+			scripts["db:stop"] = `pnpm --filter ${dbPackageName} db:stop`;
+			scripts["db:down"] = `pnpm --filter ${dbPackageName} db:down`;
 		}
 	} else if (options.packageManager === "npm") {
 		scripts.dev = devScript;
@@ -6361,24 +6689,24 @@ async function updateRootPackageJson(projectDir, options) {
 		scripts["check-types"] = "npm run check-types --workspaces";
 		scripts["dev:native"] = "npm run dev --workspace native";
 		scripts["dev:web"] = "npm run dev --workspace web";
-		scripts["dev:server"] = serverDevScript;
+		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
 		if (options.backend === "convex") scripts["dev:setup"] = `npm run dev:setup --workspace ${backendPackageName}`;
 		if (needsDbScripts) {
-			scripts["db:push"] = `npm run db:push --workspace ${backendPackageName}`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `npm run db:studio --workspace ${backendPackageName}`;
+			scripts["db:push"] = `npm run db:push --workspace ${dbPackageName}`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `npm run db:studio --workspace ${dbPackageName}`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
-				scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+				scripts["db:generate"] = `npm run db:generate --workspace ${dbPackageName}`;
+				scripts["db:migrate"] = `npm run db:migrate --workspace ${dbPackageName}`;
 			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `npm run db:generate --workspace ${backendPackageName}`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `npm run db:migrate --workspace ${backendPackageName}`;
+				scripts["db:generate"] = `npm run db:generate --workspace ${dbPackageName}`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `npm run db:migrate --workspace ${dbPackageName}`;
 			}
 		}
 		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `npm run db:start --workspace ${backendPackageName}`;
-			scripts["db:watch"] = `npm run db:watch --workspace ${backendPackageName}`;
-			scripts["db:stop"] = `npm run db:stop --workspace ${backendPackageName}`;
-			scripts["db:down"] = `npm run db:down --workspace ${backendPackageName}`;
+			scripts["db:start"] = `npm run db:start --workspace ${dbPackageName}`;
+			scripts["db:watch"] = `npm run db:watch --workspace ${dbPackageName}`;
+			scripts["db:stop"] = `npm run db:stop --workspace ${dbPackageName}`;
+			scripts["db:down"] = `npm run db:down --workspace ${dbPackageName}`;
 		}
 	} else if (options.packageManager === "bun") {
 		scripts.dev = devScript;
@@ -6386,24 +6714,24 @@ async function updateRootPackageJson(projectDir, options) {
 		scripts["check-types"] = "bun run --filter '*' check-types";
 		scripts["dev:native"] = "bun run --filter native dev";
 		scripts["dev:web"] = "bun run --filter web dev";
-		scripts["dev:server"] = serverDevScript;
+		if (options.backend !== "self" && options.backend !== "none") scripts["dev:server"] = serverDevScript;
 		if (options.backend === "convex") scripts["dev:setup"] = `bun run --filter ${backendPackageName} dev:setup`;
 		if (needsDbScripts) {
-			scripts["db:push"] = `bun run --filter ${backendPackageName} db:push`;
-			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `bun run --filter ${backendPackageName} db:studio`;
+			scripts["db:push"] = `bun run --filter ${dbPackageName} db:push`;
+			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:studio"] = `bun run --filter ${dbPackageName} db:studio`;
 			if (options.orm === "prisma") {
-				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
-				scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `bun run --filter ${dbPackageName} db:generate`;
+				scripts["db:migrate"] = `bun run --filter ${dbPackageName} db:migrate`;
 			} else if (options.orm === "drizzle") {
-				scripts["db:generate"] = `bun run --filter ${backendPackageName} db:generate`;
-				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `bun run --filter ${backendPackageName} db:migrate`;
+				scripts["db:generate"] = `bun run --filter ${dbPackageName} db:generate`;
+				if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = `bun run --filter ${dbPackageName} db:migrate`;
 			}
 		}
 		if (options.dbSetup === "docker") {
-			scripts["db:start"] = `bun run --filter ${backendPackageName} db:start`;
-			scripts["db:watch"] = `bun run --filter ${backendPackageName} db:watch`;
-			scripts["db:stop"] = `bun run --filter ${backendPackageName} db:stop`;
-			scripts["db:down"] = `bun run --filter ${backendPackageName} db:down`;
+			scripts["db:start"] = `bun run --filter ${dbPackageName} db:start`;
+			scripts["db:watch"] = `bun run --filter ${dbPackageName} db:watch`;
+			scripts["db:stop"] = `bun run --filter ${dbPackageName} db:stop`;
+			scripts["db:down"] = `bun run --filter ${dbPackageName} db:down`;
 		}
 	}
 	try {
@@ -6428,7 +6756,16 @@ async function updateServerPackageJson(projectDir, options) {
 	if (!await fs.pathExists(serverPackageJsonPath)) return;
 	const serverPackageJson = await fs.readJson(serverPackageJsonPath);
 	if (!serverPackageJson.scripts) serverPackageJson.scripts = {};
-	const scripts = serverPackageJson.scripts;
+	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
+	await updateDbPackageJson(projectDir, options);
+}
+async function updateDbPackageJson(projectDir, options) {
+	const dbPackageJsonPath = path.join(projectDir, "packages/db/package.json");
+	if (!await fs.pathExists(dbPackageJsonPath)) return;
+	const dbPackageJson = await fs.readJson(dbPackageJsonPath);
+	dbPackageJson.name = `@${options.projectName}/db`;
+	if (!dbPackageJson.scripts) dbPackageJson.scripts = {};
+	const scripts = dbPackageJson.scripts;
 	if (options.database !== "none") {
 		if (options.database === "sqlite" && options.orm === "drizzle" && options.dbSetup !== "d1") scripts["db:local"] = "turso dev --db-file local.db";
 		if (options.orm === "prisma") {
@@ -6449,7 +6786,21 @@ async function updateServerPackageJson(projectDir, options) {
 		scripts["db:stop"] = "docker compose stop";
 		scripts["db:down"] = "docker compose down";
 	}
-	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
+	await fs.writeJson(dbPackageJsonPath, dbPackageJson, { spaces: 2 });
+}
+async function updateAuthPackageJson(projectDir, options) {
+	const authPackageJsonPath = path.join(projectDir, "packages/auth/package.json");
+	if (!await fs.pathExists(authPackageJsonPath)) return;
+	const authPackageJson = await fs.readJson(authPackageJsonPath);
+	authPackageJson.name = `@${options.projectName}/auth`;
+	await fs.writeJson(authPackageJsonPath, authPackageJson, { spaces: 2 });
+}
+async function updateApiPackageJson(projectDir, options) {
+	const apiPackageJsonPath = path.join(projectDir, "packages/api/package.json");
+	if (!await fs.pathExists(apiPackageJsonPath)) return;
+	const apiPackageJson = await fs.readJson(apiPackageJsonPath);
+	apiPackageJson.name = `@${options.projectName}/api`;
+	await fs.writeJson(apiPackageJsonPath, apiPackageJson, { spaces: 2 });
 }
 async function updateConvexPackageJson(projectDir, options) {
 	const convexPackageJsonPath = path.join(projectDir, "packages/backend/package.json");
@@ -6465,15 +6816,14 @@ async function updateConvexPackageJson(projectDir, options) {
 async function createProject(options, cliInput) {
 	const projectDir = options.projectDir;
 	const isConvex = options.backend === "convex";
+	const isSelfBackend = options.backend === "self";
+	const needsServerSetup = !isConvex && !isSelfBackend;
 	try {
 		await fs.ensureDir(projectDir);
 		await copyBaseTemplate(projectDir, options);
 		await setupFrontendTemplates(projectDir, options);
 		await setupBackendFramework(projectDir, options);
-		if (!isConvex) {
-			await setupDbOrmTemplates(projectDir, options);
-			await setupDockerComposeTemplates(projectDir, options);
-		}
+		if (needsServerSetup) await setupDockerComposeTemplates(projectDir, options);
 		await setupAuthTemplate(projectDir, options);
 		if (options.payments && options.payments !== "none") await setupPaymentsTemplate(projectDir, options);
 		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);
@@ -6481,9 +6831,11 @@ async function createProject(options, cliInput) {
 		await setupDeploymentTemplates(projectDir, options);
 		await setupApi(options);
 		if (!isConvex) {
-			await setupBackendDependencies(options);
+			if (needsServerSetup) {
+				await setupBackendDependencies(options);
+				await setupRuntime(options);
+			}
 			await setupDatabase(options, cliInput);
-			await setupRuntime(options);
 			if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamples(options);
 		}
 		if (options.addons.length > 0 && options.addons[0] !== "none") await setupAddons(options);
@@ -6492,6 +6844,7 @@ async function createProject(options, cliInput) {
 		await handleExtras(projectDir, options);
 		await setupEnvironmentVariables(options);
 		await updatePackageConfigurations(projectDir, options);
+		await setupCatalogs(projectDir, options);
 		await setupWebDeploy(options);
 		await setupServerDeploy(options);
 		await createReadme(projectDir, options);