create-better-t-stack 2.50.0-canary.dd7000f2 → 2.50.1-canary.58bbe5f6

package/dist/{src-dv6H37db.js → src-CulfT5QB.js}

@@ -71,8 +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: "^0.5.22",
+	"@libsql/client": "^0.14.0",
 	"@neondatabase/serverless": "^1.0.1",
 	pg: "^8.14.1",
 	"@types/pg": "^8.11.11",
@@ -125,7 +124,7 @@ const dependencyVersionMap = {
 	"@trpc/tanstack-react-query": "^11.5.0",
 	"@trpc/server": "^11.5.0",
 	"@trpc/client": "^11.5.0",
-	next: "^15.1.0",
+	next: "15.5.4",
 	convex: "^1.27.0",
 	"@convex-dev/react-query": "^0.0.0-alpha.8",
 	"convex-svelte": "^0.0.11",
@@ -348,21 +347,16 @@ 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"
-];
+const FULLSTACK_FRONTENDS$1 = ["next"];
 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.some((f) => FULLSTACK_FRONTENDS$1.includes(f))) exitWithError("Backend 'self' (fullstack) currently only supports Next.js frontend. Please use --frontend next. Support for Nuxt, SvelteKit, and TanStack Start will be added in a future update.");
 		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.");
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") exitWithError("Backend 'self' (fullstack) currently only supports Next.js frontend. Please use --frontend next or choose a different backend. Support for Nuxt, SvelteKit, and TanStack Start will be added in a future update.");
 }
 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.`);
@@ -685,12 +679,7 @@ async function getAuthChoice(auth, hasDatabase, backend, frontend) {
 
 //#endregion
 //#region src/prompts/backend.ts
-const FULLSTACK_FRONTENDS = [
-	"next",
-	"nuxt",
-	"svelte",
-	"tanstack-start"
-];
+const FULLSTACK_FRONTENDS = ["next"];
 async function getBackendFrameworkChoice(backendFramework, frontends) {
 	if (backendFramework !== void 0) return backendFramework;
 	const hasIncompatibleFrontend = frontends?.some((f) => f === "solid");
@@ -699,7 +688,7 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 	if (hasFullstackFrontend) backendOptions.push({
 		value: "self",
 		label: "Self (Fullstack)",
-		hint: "Use frontend's built-in backend capabilities"
+		hint: "Use frontend's built-in api routes"
 	});
 	backendOptions.push({
 		value: "hono",
@@ -2089,11 +2078,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)) {
@@ -2334,11 +2326,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
@@ -2749,6 +2744,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");
@@ -2944,6 +2943,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`);
@@ -3086,6 +3089,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) {
@@ -3138,25 +3145,29 @@ async function setupDockerComposeTemplates(projectDir, 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") {
+	const isBackendSelf = context.backend === "self";
+	if (context.webDeploy === "alchemy" || context.serverDeploy === "alchemy") {
 		const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-		if (await fs.pathExists(alchemyTemplateSrc)) {
-			await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, projectDir, context);
-			const serverAppDir = path.join(projectDir, "apps/server");
-			if (await fs.pathExists(serverAppDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-		}
-	} else {
-		if (context.webDeploy === "alchemy") {
-			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-			const webAppDir = path.join(projectDir, "apps/web");
-			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(webAppDir)) await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, webAppDir, context);
-		}
-		if (context.serverDeploy === "alchemy") {
-			const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-			const serverAppDir = path.join(projectDir, "apps/server");
-			if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
-				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-				await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+		if (context.webDeploy === "alchemy" && (context.serverDeploy === "alchemy" || isBackendSelf)) {
+			if (await fs.pathExists(alchemyTemplateSrc)) {
+				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, projectDir, context);
+				await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+			}
+		} else {
+			if (context.webDeploy === "alchemy") {
+				const webAppDir = path.join(projectDir, "apps/web");
+				if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(webAppDir)) {
+					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, webAppDir, context);
+					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+				}
+			}
+			if (context.serverDeploy === "alchemy" && !isBackendSelf) {
+				const serverAppDir = path.join(projectDir, "apps/server");
+				if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
+					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+					await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+				}
 			}
 		}
 	}
@@ -3179,7 +3190,7 @@ async function setupDeploymentTemplates(projectDir, context) {
 			}
 		}
 	}
-	if (context.serverDeploy !== "none" && context.serverDeploy !== "alchemy") {
+	if (context.serverDeploy !== "none" && context.serverDeploy !== "alchemy" && !isBackendSelf) {
 		const serverAppDir = path.join(projectDir, "apps/server");
 		if (await fs.pathExists(serverAppDir)) {
 			const deployTemplateSrc = path.join(PKG_ROOT, `templates/deploy/${context.serverDeploy}/server`);
@@ -3187,6 +3198,18 @@ async function setupDeploymentTemplates(projectDir, context) {
 		}
 	}
 }
+async function addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc) {
+	for (const packageName of [
+		"packages/api",
+		"packages/auth",
+		"packages/db"
+	]) {
+		const packageDir = path.join(projectDir, packageName);
+		if (await fs.pathExists(packageDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, packageDir, context);
+	}
+	const serverAppDir = path.join(projectDir, "apps/server");
+	if (await fs.pathExists(serverAppDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+}
 
 //#endregion
 //#region src/helpers/core/add-addons.ts
@@ -3252,7 +3275,7 @@ async function setupServerDeploy(config) {
 			serverDir,
 			packageManager
 		});
-	} else if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, packageManager);
+	} else if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, packageManager, projectDir);
 }
 async function setupWorkersServerDeploy(serverDir, _packageManager) {
 	const packageJsonPath = path.join(serverDir, "package.json");
@@ -3289,18 +3312,18 @@ async function generateCloudflareWorkerTypes({ serverDir, packageManager }) {
 		log.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
 	}
 }
-async function setupAlchemyServerDeploy(serverDir, _packageManager) {
+async function setupAlchemyServerDeploy(serverDir, _packageManager, projectDir) {
 	if (!await fs.pathExists(serverDir)) return;
 	await addPackageDependency({
 		devDependencies: [
 			"alchemy",
 			"wrangler",
 			"@types/node",
-			"dotenv",
 			"@cloudflare/workers-types"
 		],
 		projectDir: serverDir
 	});
+	if (projectDir) await addAlchemyPackagesDependencies$1(projectDir);
 	const packageJsonPath = path.join(serverDir, "package.json");
 	if (await fs.pathExists(packageJsonPath)) {
 		const packageJson = await fs.readJson(packageJsonPath);
@@ -3313,6 +3336,19 @@ async function setupAlchemyServerDeploy(serverDir, _packageManager) {
 		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 	}
 }
+async function addAlchemyPackagesDependencies$1(projectDir) {
+	for (const packageName of [
+		"packages/api",
+		"packages/auth",
+		"packages/db"
+	]) {
+		const packageDir = path.join(projectDir, packageName);
+		if (await fs.pathExists(packageDir)) await addPackageDependency({
+			devDependencies: ["@cloudflare/workers-types"],
+			projectDir: packageDir
+		});
+	}
+}
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-next-setup.ts
@@ -3323,7 +3359,6 @@ async function setupNextAlchemyDeploy(projectDir, _packageManager, options) {
 		dependencies: ["@opennextjs/cloudflare"],
 		devDependencies: [
 			"alchemy",
-			"dotenv",
 			"wrangler",
 			"@cloudflare/workers-types"
 		],
@@ -3359,7 +3394,6 @@ async function setupNuxtAlchemyDeploy(projectDir, _packageManager, options) {
 		devDependencies: [
 			"alchemy",
 			"nitro-cloudflare-dev",
-			"dotenv",
 			"wrangler"
 		],
 		projectDir: webAppDir
@@ -3422,7 +3456,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");
@@ -3443,7 +3477,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");
@@ -3464,11 +3498,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");
@@ -3533,7 +3563,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");
@@ -3554,11 +3584,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");
@@ -3613,7 +3639,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");
@@ -3628,7 +3654,7 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
 	}
 	const serverDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, packageManager);
+	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, packageManager, projectDir);
 	const frontend = config.frontend;
 	const isNext = frontend.includes("next");
 	const isNuxt = frontend.includes("nuxt");
@@ -3861,6 +3887,7 @@ async function setupWebDeploy(config) {
 	if (webDeploy !== "wrangler" && webDeploy !== "alchemy") return;
 	if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
 		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
+		await addAlchemyPackagesDependencies(projectDir);
 		return;
 	}
 	const isNext = frontend.includes("next");
@@ -3884,6 +3911,7 @@ async function setupWebDeploy(config) {
 		else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
 		else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
 		else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
+		await addAlchemyPackagesDependencies(projectDir);
 	}
 }
 async function setupWorkersWebDeploy(projectDir, pkgManager) {
@@ -3901,6 +3929,19 @@ async function setupWorkersWebDeploy(projectDir, pkgManager) {
 	}
 	await setupWorkersVitePlugin(projectDir);
 }
+async function addAlchemyPackagesDependencies(projectDir) {
+	for (const packageName of [
+		"packages/api",
+		"packages/auth",
+		"packages/db"
+	]) {
+		const packageDir = path.join(projectDir, packageName);
+		if (await fs.pathExists(packageDir)) await addPackageDependency({
+			devDependencies: ["@cloudflare/workers-types"],
+			projectDir: packageDir
+		});
+	}
+}
 
 //#endregion
 //#region src/helpers/core/add-deployment.ts
@@ -4060,15 +4101,30 @@ async function updatePackageJsonsWithCatalogs(packagesInfo, catalog) {
 //#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 apiDir = path.join(projectDir, "packages/api");
+		const apiDir$1 = path.join(projectDir, "packages/api");
 		const webClientDirExists = await fs.pathExists(webClientDir);
 		const nativeClientDirExists = await fs.pathExists(nativeClientDir);
-		const apiDirExists = await fs.pathExists(apiDir);
+		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");
@@ -4091,7 +4147,11 @@ async function setupExamples(config) {
 		});
 		if (apiDirExists && backend !== "none") await addPackageDependency({
 			dependencies: ["ai", "@ai-sdk/google"],
-			projectDir: apiDir
+			projectDir: apiDir$1
+		});
+		if (backend === "self" && webClientDirExists) await addPackageDependency({
+			dependencies: ["ai", "@ai-sdk/google"],
+			projectDir: webClientDir
 		});
 	}
 }
@@ -4207,7 +4267,7 @@ function getConvexDependencies(frontend) {
 	return deps;
 }
 async function setupApi(config) {
-	const { api, projectName, frontend, backend, packageManager, projectDir, auth } = config;
+	const { api, projectName, frontend, backend, packageManager, projectDir } = config;
 	const isConvex = backend === "convex";
 	const webDir = path.join(projectDir, "apps/web");
 	const nativeDir = path.join(projectDir, "apps/native");
@@ -4224,40 +4284,18 @@ async function setupApi(config) {
 				dependencies: apiDeps.server.dependencies,
 				projectDir: apiPackageDir
 			});
-			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 (backend === "self" && webDirExists) await addPackageDependency({
+				dependencies: apiDeps.server.dependencies,
+				projectDir: webDir
 			});
-			if (api === "trpc") {
-				if (backend === "hono") await addPackageDependency({
-					dependencies: ["@hono/trpc-server"],
-					projectDir: apiPackageDir
-				});
-				else if (backend === "elysia") await addPackageDependency({
-					dependencies: ["@elysiajs/trpc"],
-					projectDir: apiPackageDir
-				});
-				else if (backend === "express") await addPackageDependency({
-					dependencies: ["@trpc/server"],
-					projectDir: apiPackageDir
-				});
-				else if (backend === "fastify") await addPackageDependency({
-					dependencies: ["@trpc/server"],
+			if (backend === "self") {
+				const frameworkDeps = [];
+				if (frontend.includes("next")) frameworkDeps.push("next");
+				if (frameworkDeps.length > 0) await addPackageDependency({
+					dependencies: frameworkDeps,
 					projectDir: apiPackageDir
 				});
 			}
-			if (auth === "better-auth") await addPackageDependency({
-				dependencies: ["better-auth"],
-				projectDir: apiPackageDir
-			});
 		}
 		if (webDirExists && apiDeps.web) await addPackageDependency({
 			dependencies: apiDeps.web.dependencies,
@@ -4309,34 +4347,23 @@ async function setupBackendDependencies(config) {
 	const devDependencies = [];
 	if (framework === "hono") {
 		dependencies.push("hono");
-		if (api === "trpc") dependencies.push("@hono/trpc-server");
-		if (runtime === "node") {
-			dependencies.push("@hono/node-server");
-			devDependencies.push("tsx", "@types/node");
-		}
+		if (runtime === "node") dependencies.push("@hono/node-server");
 	} else if (framework === "elysia") {
 		dependencies.push("elysia", "@elysiajs/cors");
-		if (api === "trpc") dependencies.push("@elysiajs/trpc");
-		if (runtime === "node") {
-			dependencies.push("@elysiajs/node");
-			devDependencies.push("tsx", "@types/node");
-		}
+		if (runtime === "node") dependencies.push("@elysiajs/node");
 	} else if (framework === "express") {
 		dependencies.push("express", "cors");
 		devDependencies.push("@types/express", "@types/cors");
-		if (runtime === "node") devDependencies.push("tsx", "@types/node");
-	} else if (framework === "fastify") {
-		dependencies.push("fastify", "@fastify/cors");
-		if (runtime === "node") devDependencies.push("tsx", "@types/node");
-	}
+	} else if (framework === "fastify") dependencies.push("fastify", "@fastify/cors");
 	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");
+		dependencies.push("@trpc/server");
+		if (framework === "hono") dependencies.push("@hono/trpc-server");
+		else if (framework === "elysia") dependencies.push("@elysiajs/trpc");
 	} else if (api === "orpc") dependencies.push("@orpc/server", "@orpc/openapi", "@orpc/zod");
 	if (auth === "better-auth") dependencies.push("better-auth");
 	if (examples.includes("ai")) dependencies.push("ai", "@ai-sdk/google");
-	if (runtime === "bun") devDependencies.push("@types/bun");
+	if (runtime === "node") devDependencies.push("tsx", "@types/node");
+	else if (runtime === "bun") devDependencies.push("@types/bun");
 	if (dependencies.length > 0 || devDependencies.length > 0) await addPackageDependency({
 		dependencies,
 		devDependencies,
@@ -4457,6 +4484,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 = "";
@@ -4515,22 +4570,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({
@@ -4622,7 +4668,8 @@ async function setupEnvironmentVariables(config) {
 	}
 	const serverDir = path.join(projectDir, "apps/server");
 	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":
@@ -4636,50 +4683,53 @@ async function setupEnvironmentVariables(config) {
 			break;
 		case "sqlite":
 			if (config.runtime === "workers") databaseUrl = "http://127.0.0.1:8080";
-			else databaseUrl = `file:${path.join(config.projectDir, "apps/server", "local.db")}`;
-			break;
-	}
-	if (await fs.pathExists(serverDir)) {
-		const serverEnvPath = path.join(serverDir, ".env");
-		const serverVars = [
-			{
-				key: "BETTER_AUTH_SECRET",
-				value: generateAuthSecret(),
-				condition: !!auth
-			},
-			{
-				key: "BETTER_AUTH_URL",
-				value: "http://localhost:3000",
-				condition: !!auth
-			},
-			{
-				key: "POLAR_ACCESS_TOKEN",
-				value: "",
-				condition: config.payments === "polar"
-			},
-			{
-				key: "POLAR_SUCCESS_URL",
-				value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
-				condition: config.payments === "polar"
-			},
-			{
-				key: "CORS_ORIGIN",
-				value: corsOrigin,
-				condition: true
-			},
-			{
-				key: "GOOGLE_GENERATIVE_AI_API_KEY",
-				value: "",
-				condition: examples?.includes("ai") || false
-			},
-			{
-				key: "DATABASE_URL",
-				value: databaseUrl,
-				condition: database !== "none" && dbSetup === "none"
+			else {
+				const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
+				databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
 			}
-		];
-		await addEnvVariablesToFile(serverEnvPath, serverVars);
+			break;
 	}
+	const serverVars = [
+		{
+			key: "BETTER_AUTH_SECRET",
+			value: generateAuthSecret(),
+			condition: !!auth
+		},
+		{
+			key: "BETTER_AUTH_URL",
+			value: backend === "self" ? "http://localhost:3001" : "http://localhost:3000",
+			condition: !!auth
+		},
+		{
+			key: "POLAR_ACCESS_TOKEN",
+			value: "",
+			condition: config.payments === "polar"
+		},
+		{
+			key: "POLAR_SUCCESS_URL",
+			value: `${corsOrigin}/success?checkout_id={CHECKOUT_ID}`,
+			condition: config.payments === "polar"
+		},
+		{
+			key: "CORS_ORIGIN",
+			value: corsOrigin,
+			condition: true
+		},
+		{
+			key: "GOOGLE_GENERATIVE_AI_API_KEY",
+			value: "",
+			condition: examples?.includes("ai") || false
+		},
+		{
+			key: "DATABASE_URL",
+			value: databaseUrl,
+			condition: database !== "none" && dbSetup === "none"
+		}
+	];
+	if (backend === "self") {
+		const webDir = path.join(projectDir, "apps/web");
+		if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverVars);
+	} else if (await fs.pathExists(serverDir)) await addEnvVariablesToFile(path.join(serverDir, ".env"), serverVars);
 	const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
 	const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
 	if (isUnifiedAlchemy) {
@@ -4698,20 +4748,27 @@ async function setupEnvironmentVariables(config) {
 				condition: true
 			}]);
 		}
-		if (serverDeploy === "alchemy") await addEnvVariablesToFile(path.join(serverDir, ".env"), [{
-			key: "ALCHEMY_PASSWORD",
-			value: "please-change-this",
-			condition: true
-		}]);
+		if (serverDeploy === "alchemy") {
+			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);
+		}
 	}
 }
 
 //#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",
@@ -4734,7 +4791,8 @@ 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:${path.join(projectDir, "apps/server", "local.db")}`,
@@ -4743,7 +4801,7 @@ async function setupCloudflareD1(config) {
 		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
@@ -4794,14 +4852,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;
 	}
 }
@@ -4812,12 +4869,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",
@@ -4836,9 +4894,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",
@@ -4867,16 +4926,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;
 		}
@@ -4895,26 +4952,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 {}
 	}
@@ -4971,7 +5026,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) {
@@ -4991,8 +5046,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",
@@ -5001,16 +5057,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;
@@ -5019,23 +5076,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({
@@ -5053,8 +5110,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({
@@ -5071,7 +5128,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({
@@ -5089,22 +5146,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 = [
 			{
@@ -5128,7 +5185,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") {
@@ -5137,7 +5194,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") {
@@ -5146,7 +5203,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") {
@@ -5155,7 +5212,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);
 	}
 }
@@ -5225,7 +5282,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,
@@ -5247,9 +5304,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",
@@ -5265,23 +5323,23 @@ 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, "packages/db/prisma.config.ts");
 		let content = await fs.readFile(prismaConfigPath, "utf8");
-		content = `import dotenv from "dotenv";\ndotenv.config({ path: "../../apps/server/.env" });\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"`);
 }
@@ -5299,14 +5357,14 @@ async function addPrismaAccelerateExtension(projectDir) {
 	}
 }
 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({
@@ -5324,8 +5382,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 = [{
@@ -5345,26 +5403,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 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.");
 	}
@@ -5372,9 +5430,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",
@@ -5460,14 +5519,14 @@ ${pc.dim(output)}` : ""}
 			${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, "packages", "db");
 	try {
 		await fs.ensureDir(serverDir);
 		if (manualDb) {
 			displayManualSupabaseInstructions();
-			await writeSupabaseEnvFile(projectDir, "");
+			await writeSupabaseEnvFile(projectDir, backend, "");
 			return;
 		}
 		const mode = await select({
@@ -5486,7 +5545,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)) {
@@ -5499,7 +5558,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);
@@ -5627,8 +5686,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 ?? "",
@@ -5652,12 +5712,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;
 		}
@@ -5676,7 +5736,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;
 		}
@@ -5686,7 +5746,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;
 		}
@@ -5698,7 +5758,7 @@ async function setupTurso(config, cliInput) {
 			});
 			if (isCancel(shouldInstall)) return exitCancelled("Operation cancelled");
 			if (!shouldInstall) {
-				await writeEnvFile(projectDir);
+				await writeEnvFile(projectDir, backend);
 				displayManualSetupInstructions();
 				return;
 			}
@@ -5720,7 +5780,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") {
@@ -5733,7 +5793,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.");
 	}
@@ -5755,32 +5815,36 @@ async function setupDatabase(config, cliInput) {
 	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: 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
-		});
-		else if (orm === "drizzle") {
-			if (database === "sqlite") await addPackageDependency({
+		if (orm === "prisma") {
+			if (database === "mysql" && dbSetup === "planetscale") await addPackageDependency({
 				dependencies: [
-					"drizzle-orm",
-					"@libsql/client",
-					"libsql"
+					"@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: dbPackageDir
 			});
@@ -5929,7 +5993,7 @@ This project uses Convex as a backend. You'll need to set up Convex before runni
 ${packageManagerRunCmd} dev:setup
 \`\`\`
 
-Follow the prompts to create a new Convex project and connect it to your application.${auth === "clerk" ? " See [Convex + Clerk guide](https://docs.convex.dev/auth/clerk) for auth setup." : ""}` : generateDatabaseSetup(database, auth, packageManagerRunCmd, orm, options.dbSetup, options.serverDeploy)}
+Follow the prompts to create a new Convex project and connect it to your application.${auth === "clerk" ? " See [Convex + Clerk guide](https://docs.convex.dev/auth/clerk) for auth setup." : ""}` : generateDatabaseSetup(database, auth, packageManagerRunCmd, orm, options.dbSetup, options.serverDeploy, options.backend)}
 
 Then, run the development server:
 
@@ -5982,6 +6046,7 @@ function generateRunningInstructions(frontend, backend, webPort, hasNative, isCo
 	const instructions = [];
 	const hasFrontendNone = frontend.length === 0 || frontend.includes("none");
 	const isBackendNone = backend === "none";
+	const isBackendSelf = backend === "self";
 	if (!hasFrontendNone) {
 		const hasTanstackRouter = frontend.includes("tanstack-router");
 		const hasReactRouter = frontend.includes("react-router");
@@ -5990,17 +6055,19 @@ function generateRunningInstructions(frontend, backend, webPort, hasNative, isCo
 		const hasSvelte = frontend.includes("svelte");
 		const hasNuxt = frontend.includes("nuxt");
 		const hasSolid = frontend.includes("solid");
-		if (hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid) instructions.push(`Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see the web application.`);
+		if (hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid) if (isBackendSelf) instructions.push(`Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see your fullstack application.`);
+		else instructions.push(`Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see the web application.`);
 	}
 	if (hasNative) instructions.push("Use the Expo Go app to run the mobile application.");
 	if (isConvex) instructions.push("Your app will connect to the Convex cloud backend automatically.");
-	else if (!isBackendNone) instructions.push("The API is running at [http://localhost:3000](http://localhost:3000).");
+	else if (!isBackendNone && !isBackendSelf) instructions.push("The API is running at [http://localhost:3000](http://localhost:3000).");
 	return instructions.join("\n");
 }
 function generateProjectStructure(projectName, frontend, backend, addons, isConvex, api, auth) {
 	const structure = [`${projectName}/`, "├── apps/"];
 	const hasFrontendNone = frontend.length === 0 || frontend.includes("none");
 	const isBackendNone = backend === "none";
+	const isBackendSelf = backend === "self";
 	if (!hasFrontendNone) {
 		const hasTanstackRouter = frontend.includes("tanstack-router");
 		const hasReactRouter = frontend.includes("react-router");
@@ -6018,21 +6085,32 @@ function generateProjectStructure(projectName, frontend, backend, addons, isConv
 			else if (hasSvelte) frontendType = "SvelteKit";
 			else if (hasNuxt) frontendType = "Nuxt";
 			else if (hasSolid) frontendType = "SolidJS";
-			structure.push(`│   ├── web/         # Frontend application (${frontendType})`);
+			if (isBackendSelf) structure.push(`│   └── web/         # Fullstack application (${frontendType})`);
+			else structure.push(`│   ├── web/         # Frontend application (${frontendType})`);
 		}
 	}
-	if (frontend.includes("native-nativewind") || frontend.includes("native-unistyles")) structure.push("│   ├── native/      # Mobile application (React Native, Expo)");
-	if (addons.includes("starlight")) structure.push("│   ├── docs/        # Documentation site (Astro Starlight)");
-	if (isConvex) {
-		structure.push("├── packages/");
-		structure.push("│   └── backend/     # Convex backend functions and schema");
-		if (auth === "clerk") structure.push("│       ├── convex/    # Convex functions and schema", "│       └── .env.local # Convex environment variables");
-	} else if (!isBackendNone) {
+	if (frontend.includes("native-nativewind") || frontend.includes("native-unistyles")) if (isBackendSelf) structure.push("│   ├── native/      # Mobile application (React Native, Expo)");
+	else structure.push("│   ├── native/      # Mobile application (React Native, Expo)");
+	if (addons.includes("starlight")) if (isBackendSelf) structure.push("│   ├── docs/        # Documentation site (Astro Starlight)");
+	else structure.push("│   ├── docs/        # Documentation site (Astro Starlight)");
+	if (!isBackendSelf && !isBackendNone && !isConvex) {
 		const backendName = backend[0].toUpperCase() + backend.slice(1);
 		const apiName = api !== "none" ? api.toUpperCase() : "";
 		const backendDesc = apiName ? `${backendName}, ${apiName}` : backendName;
 		structure.push(`│   └── server/      # Backend API (${backendDesc})`);
 	}
+	if (isConvex || !isBackendNone) {
+		structure.push("├── packages/");
+		if (isConvex) {
+			structure.push("│   ├── backend/     # Convex backend functions and schema");
+			if (auth === "clerk") structure.push("│   │   ├── convex/    # Convex functions and schema", "│   │   └── .env.local # Convex environment variables");
+		}
+		if (!isConvex) {
+			structure.push("│   ├── api/         # API layer / business logic");
+			if (auth !== "none") structure.push("│   ├── auth/        # Authentication configuration & logic");
+			if (api !== "none" || auth !== "none") structure.push("│   └── db/          # Database schema & queries");
+		}
+	}
 	return structure.join("\n");
 }
 function generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api) {
@@ -6090,33 +6168,36 @@ function generateFeaturesList(database, auth, addons, orm, runtime, frontend, ba
 	else if (addon === "turborepo") addonsList.push("- **Turborepo** - Optimized monorepo build system");
 	return addonsList.join("\n");
 }
-function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSetup, serverDeploy) {
+function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSetup, serverDeploy, backend) {
 	if (database === "none") return "";
+	const isBackendSelf = backend === "self";
+	const envPath = isBackendSelf ? "apps/web/.env" : "apps/server/.env";
+	const dbLocalPath = isBackendSelf ? "apps/web" : "apps/server";
 	let setup = "## Database Setup\n\n";
 	if (database === "sqlite") setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
 
 1. Start the local SQLite database:
 ${dbSetup === "d1" ? serverDeploy === "alchemy" ? "D1 local development and migrations are handled automatically by Alchemy during dev and deploy." : "Local development for a Cloudflare D1 database will already be running as part of the `wrangler dev` command." : `\`\`\`bash
-cd apps/server && ${packageManagerRunCmd} db:local
+cd ${dbLocalPath} && ${packageManagerRunCmd} db:local
 \`\`\`
 `}
 
-2. Update your \`.env\` file in the \`apps/server\` directory with the appropriate connection details if needed.
+2. Update your \`.env\` file in the \`${isBackendSelf ? "apps/web" : "apps/server"}\` directory with the appropriate connection details if needed.
 `;
 	else if (database === "postgres") setup += `This project uses PostgreSQL${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
 
 1. Make sure you have a PostgreSQL database set up.
-2. Update your \`apps/server/.env\` file with your PostgreSQL connection details.
+2. Update your \`${envPath}\` file with your PostgreSQL connection details.
 `;
 	else if (database === "mysql") setup += `This project uses MySQL${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
 
 1. Make sure you have a MySQL database set up.
-2. Update your \`apps/server/.env\` file with your MySQL connection details.
+2. Update your \`${envPath}\` file with your MySQL connection details.
 `;
 	else if (database === "mongodb") setup += `This project uses MongoDB ${orm === "mongoose" ? "with Mongoose" : orm === "prisma" ? "with Prisma ORM" : `with ${orm}`}.
 
 1. Make sure you have MongoDB set up.
-2. Update your \`apps/server/.env\` file with your MongoDB connection URI.
+2. Update your \`${envPath}\` file with your MongoDB connection URI.
 `;
 	setup += `
 3. ${orm === "prisma" ? `Generate the Prisma client and push the schema:
@@ -6135,13 +6216,14 @@ ${packageManagerRunCmd} db:push
 function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNative, addons, backend) {
 	const isConvex = backend === "convex";
 	const isBackendNone = backend === "none";
+	const isBackendSelf = backend === "self";
 	let scripts = `- \`${packageManagerRunCmd} dev\`: Start all applications in development mode
 - \`${packageManagerRunCmd} build\`: Build all applications`;
-	scripts += `
+	if (!isBackendSelf) scripts += `
 - \`${packageManagerRunCmd} dev:web\`: Start only the web application`;
 	if (isConvex) scripts += `
 - \`${packageManagerRunCmd} dev:setup\`: Setup and configure your Convex project`;
-	else if (!isBackendNone) scripts += `
+	else if (!isBackendNone && !isBackendSelf) scripts += `
 - \`${packageManagerRunCmd} dev:server\`: Start only the server`;
 	scripts += `
 - \`${packageManagerRunCmd} check-types\`: Check TypeScript types across all apps`;
@@ -6152,7 +6234,7 @@ function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNati
 - \`${packageManagerRunCmd} db:push\`: Push schema changes to database
 - \`${packageManagerRunCmd} db:studio\`: Open database studio UI`;
 		if (database === "sqlite" && orm === "drizzle") scripts += `
-- \`cd apps/server && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
+- \`cd ${isBackendSelf ? "apps/web" : "apps/server"} && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
 	}
 	if (addons.includes("biome")) scripts += `
 - \`${packageManagerRunCmd} check\`: Run Biome formatting and linting`;
@@ -6228,15 +6310,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) => [
@@ -6310,19 +6391,20 @@ async function getDockerStatus(database) {
 async function displayPostInstallInstructions(config) {
 	const { api, database, relativePath, packageManager, depsInstalled, orm, addons, runtime, frontend, backend, dbSetup, webDeploy, serverDeploy } = config;
 	const isConvex = backend === "convex";
+	const isBackendSelf = backend === "self";
 	const runCmd = packageManager === "npm" ? "npm run" : packageManager === "pnpm" ? "pnpm run" : "bun run";
 	const cdCmd = `cd ${relativePath}`;
 	const hasHuskyOrBiome = addons?.includes("husky") || addons?.includes("biome");
-	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy) : "";
+	const databaseInstructions = !isConvex && database !== "none" ? await getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy, backend) : "";
 	const tauriInstructions = addons?.includes("tauri") ? getTauriInstructions(runCmd) : "";
 	const lintingInstructions = hasHuskyOrBiome ? getLintingInstructions(runCmd) : "";
 	const nativeInstructions = frontend?.includes("native-nativewind") || frontend?.includes("native-unistyles") ? getNativeInstructions(isConvex) : "";
 	const pwaInstructions = addons?.includes("pwa") && frontend?.includes("react-router") ? getPwaInstructions() : "";
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
 	const clerkInstructions = isConvex && config.auth === "clerk" ? getClerkInstructions() : "";
-	const polarInstructions = config.payments === "polar" && config.auth === "better-auth" ? getPolarInstructions() : "";
-	const wranglerDeployInstructions = getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy);
-	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy);
+	const polarInstructions = config.payments === "polar" && config.auth === "better-auth" ? getPolarInstructions(backend) : "";
+	const wranglerDeployInstructions = getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy, backend);
+	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend);
 	const hasWeb = frontend?.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -6346,7 +6428,8 @@ async function displayPostInstallInstructions(config) {
 		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev:setup\n${pc.dim("   (this will guide you through Convex project setup)")}\n`;
 		output += `${pc.cyan(`${stepCounter++}.`)} Copy environment variables from\n${pc.white("   packages/backend/.env.local")} to ${pc.white("apps/*/.env")}\n`;
 		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n\n`;
-	} else {
+	} else if (isBackendSelf) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
+	else {
 		if (runtime !== "workers") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
 		if (runtime === "workers") {
 			if (dbSetup === "d1") output += `${pc.yellow("IMPORTANT:")} Complete D1 database setup first\n   (see Database commands below)\n`;
@@ -6357,11 +6440,11 @@ async function displayPostInstallInstructions(config) {
 	output += `${pc.bold("Your project will be available at:")}\n`;
 	if (hasWeb) output += `${pc.cyan("•")} Frontend: http://localhost:${webPort}\n`;
 	else if (!hasNative && !addons?.includes("starlight")) output += `${pc.yellow("NOTE:")} You are creating a backend-only app\n   (no frontend selected)\n`;
-	if (!isConvex) {
+	if (!isConvex && !isBackendSelf) {
 		output += `${pc.cyan("•")} Backend API: http://localhost:3000\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 (api === "orpc") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api\n`;
 	}
+	if (isBackendSelf && api === "orpc") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}/rpc/api\n`;
 	if (addons?.includes("starlight")) output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
 	if (addons?.includes("fumadocs")) output += `${pc.cyan("•")} Fumadocs: http://localhost:4000\n`;
 	if (nativeInstructions) output += `\n${nativeInstructions.trim()}\n`;
@@ -6393,7 +6476,7 @@ function getNativeInstructions(isConvex) {
 function getLintingInstructions(runCmd) {
 	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
 }
-async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy) {
+async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy, backend) {
 	const instructions = [];
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
@@ -6407,8 +6490,9 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup,
 		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
 		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
 		instructions.push(`${pc.cyan("2.")} Create D1 database: ${pc.white(`${packageManager} wrangler d1 create your-database-name`)}`);
-		instructions.push(`${pc.cyan("3.")} Update apps/server/wrangler.jsonc with database_id and database_name`);
-		instructions.push(`${pc.cyan("4.")} Generate migrations: ${pc.white(`cd apps/server && ${runCmd} db:generate`)}`);
+		const wranglerPath = backend === "self" ? "apps/web" : "apps/server";
+		instructions.push(`${pc.cyan("3.")} Update ${wranglerPath}/wrangler.jsonc with database_id and database_name`);
+		instructions.push(`${pc.cyan("4.")} Generate migrations: ${pc.white(`cd ${wranglerPath} && ${runCmd} db:generate`)}`);
 		instructions.push(`${pc.cyan("5.")} Apply migrations locally: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME --local`)}`);
 		instructions.push(`${pc.cyan("6.")} Apply migrations to production: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME`)}`);
 	}
@@ -6432,7 +6516,10 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup,
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 		if (dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
 		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
-		if (database === "sqlite" && dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Start local DB (if needed): ${`cd apps/server && ${runCmd} db:local`}`);
+		if (database === "sqlite" && dbSetup !== "d1") {
+			const dbLocalPath = backend === "self" ? "apps/web" : "apps/server";
+			instructions.push(`${pc.cyan("•")} Start local DB (if needed): ${`cd ${dbLocalPath} && ${runCmd} db:local`}`);
+		}
 	} else if (orm === "mongoose") {
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 	} else if (orm === "none") instructions.push(`${pc.yellow("NOTE:")} Manual database schema setup\n   required.`);
@@ -6453,23 +6540,28 @@ function getNoOrmWarning() {
 function getBunWebNativeWarning() {
 	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo.\n   Use 'pnpm' if problems arise.`;
 }
-function getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy) {
+function getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
-	if (webDeploy === "wrangler") instructions.push(`${pc.bold("Deploy web to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} run deploy`}`);
-	if (serverDeploy === "wrangler") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} run deploy`}`);
+	if (webDeploy === "wrangler") {
+		const deployPath = backend === "self" ? "apps/web" : "apps/web";
+		instructions.push(`${pc.bold("Deploy web to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd ${deployPath} && ${runCmd} run deploy`}`);
+	}
+	if (serverDeploy === "wrangler" && backend !== "self") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} run deploy`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 function getClerkInstructions() {
 	return `${pc.bold("Clerk Authentication Setup:")}\n${pc.cyan("•")} Follow the guide: ${pc.underline("https://docs.convex.dev/auth/clerk")}\n${pc.cyan("•")} Set CLERK_JWT_ISSUER_DOMAIN in Convex Dashboard\n${pc.cyan("•")} Set CLERK_PUBLISHABLE_KEY in apps/*/.env`;
 }
-function getPolarInstructions() {
-	return `${pc.bold("Polar Payments Setup:")}\n${pc.cyan("•")} Get access token & product ID from ${pc.underline("https://sandbox.polar.sh/")}\n${pc.cyan("•")} Set POLAR_ACCESS_TOKEN in apps/server/.env`;
+function getPolarInstructions(backend) {
+	const envPath = backend === "self" ? "apps/web/.env" : "apps/server/.env";
+	return `${pc.bold("Polar Payments Setup:")}\n${pc.cyan("•")} Get access token & product ID from ${pc.underline("https://sandbox.polar.sh/")}\n${pc.cyan("•")} Set POLAR_ACCESS_TOKEN in ${envPath}`;
 }
-function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy) {
+function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
+	const isBackendSelf = backend === "self";
 	if (webDeploy === "alchemy" && serverDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy web with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
-	else if (serverDeploy === "alchemy" && webDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy server with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
-	else if (webDeploy === "alchemy" && serverDeploy === "alchemy") instructions.push(`${pc.bold("Deploy with Alchemy:")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	else if (serverDeploy === "alchemy" && webDeploy !== "alchemy" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
+	else if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Alchemy:")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
@@ -6514,20 +6606,31 @@ async function setupWorkspaceDependencies(projectDir, options) {
 		},
 		projectDir: serverPackageDir
 	});
-	const needsApiDependency = options.api && options.api !== "none";
 	const webPackageDir = path.join(projectDir, "apps/web");
 	if (await fs.pathExists(webPackageDir)) {
 		const webDeps = {};
-		if (options.backend === "self") {
-			webDeps[`@${projectName}/api`] = workspaceVersion;
-			webDeps[`@${projectName}/auth`] = workspaceVersion;
-			webDeps[`@${projectName}/db`] = workspaceVersion;
-		} else if (needsApiDependency) webDeps[`@${projectName}/api`] = workspaceVersion;
+		webDeps[`@${projectName}/api`] = workspaceVersion;
+		webDeps[`@${projectName}/auth`] = workspaceVersion;
+		webDeps[`@${projectName}/db`] = workspaceVersion;
 		if (Object.keys(webDeps).length > 0) await addPackageDependency({
 			customDependencies: webDeps,
 			projectDir: webPackageDir
 		});
 	}
+	const runtimeDevDeps = getRuntimeDevDeps(options);
+	await addPackageDependency({
+		dependencies: commonDeps,
+		devDependencies: [...commonDevDeps, ...runtimeDevDeps],
+		projectDir
+	});
+}
+function getRuntimeDevDeps(options) {
+	const { runtime, backend } = options;
+	if (runtime === "none" && backend === "self") return ["@types/node"];
+	if (runtime === "node") return ["@types/node"];
+	if (runtime === "bun") return ["@types/bun"];
+	if (runtime === "workers") return ["@types/node"];
+	return [];
 }
 
 //#endregion
@@ -6536,6 +6639,7 @@ async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(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);
@@ -6585,10 +6689,10 @@ async function updateRootPackageJson(projectDir, options) {
 			}
 		}
 		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;
@@ -6610,10 +6714,10 @@ async function updateRootPackageJson(projectDir, options) {
 			}
 		}
 		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;
@@ -6635,10 +6739,10 @@ async function updateRootPackageJson(projectDir, options) {
 			}
 		}
 		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;
@@ -6660,10 +6764,10 @@ async function updateRootPackageJson(projectDir, options) {
 			}
 		}
 		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 {
@@ -6688,13 +6792,6 @@ 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;
-	if (options.dbSetup === "docker") {
-		scripts["db:start"] = "docker compose up -d";
-		scripts["db:watch"] = "docker compose up";
-		scripts["db:stop"] = "docker compose stop";
-		scripts["db:down"] = "docker compose down";
-	}
 	await fs.writeJson(serverPackageJsonPath, serverPackageJson, { spaces: 2 });
 	await updateDbPackageJson(projectDir, options);
 }
@@ -6719,6 +6816,12 @@ async function updateDbPackageJson(projectDir, options) {
 			if (!(options.dbSetup === "d1" && options.serverDeploy === "alchemy")) scripts["db:migrate"] = "drizzle-kit migrate";
 		}
 	}
+	if (options.dbSetup === "docker") {
+		scripts["db:start"] = "docker compose up -d";
+		scripts["db:watch"] = "docker compose up";
+		scripts["db:stop"] = "docker compose stop";
+		scripts["db:down"] = "docker compose down";
+	}
 	await fs.writeJson(dbPackageJsonPath, dbPackageJson, { spaces: 2 });
 }
 async function updateAuthPackageJson(projectDir, options) {