create-better-t-stack 2.49.1-canary.80158905 → 2.50.0-canary.08568a05

package/dist/{src-CyG8-I-3.js → src-DfbhNFZ9.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
@@ -65,7 +66,7 @@ const dependencyVersionMap = {
 	"@better-auth/expo": "^1.3.13",
 	"@clerk/nextjs": "^6.31.5",
 	"@clerk/clerk-react": "^5.45.0",
-	"@clerk/tanstack-react-start": "^0.23.1",
+	"@clerk/tanstack-react-start": "^0.25.1",
 	"@clerk/clerk-expo": "^2.14.25",
 	"drizzle-orm": "^0.44.2",
 	"drizzle-kit": "^0.31.2",
@@ -124,6 +125,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",
@@ -139,13 +141,13 @@ const dependencyVersionMap = {
 	"@tanstack/solid-query": "^5.87.4",
 	"@tanstack/solid-query-devtools": "^5.87.4",
 	"@tanstack/solid-router-devtools": "^1.131.44",
-	wrangler: "^4.23.0",
-	"@cloudflare/vite-plugin": "^1.9.0",
+	wrangler: "^4.40.3",
+	"@cloudflare/vite-plugin": "^1.13.8",
 	"@opennextjs/cloudflare": "^1.6.5",
 	"nitro-cloudflare-dev": "^0.2.2",
 	"@sveltejs/adapter-cloudflare": "^7.2.1",
 	"@cloudflare/workers-types": "^4.20250822.0",
-	alchemy: "^0.67.0",
+	alchemy: "^0.70.0",
 	nitropack: "^2.12.4",
 	dotenv: "^17.2.2",
 	tsdown: "^0.15.5",
@@ -198,9 +200,9 @@ const BackendSchema = z.enum([
 	"hono",
 	"express",
 	"fastify",
-	"next",
 	"elysia",
 	"convex",
+	"self",
 	"none"
 ]).describe("Backend framework");
 const RuntimeSchema = z.enum([
@@ -346,6 +348,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.`);
@@ -667,36 +685,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 backend capabilities"
+	});
+	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",
@@ -710,7 +731,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;
@@ -1089,9 +1110,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",
@@ -1768,8 +1788,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");
@@ -1799,6 +1819,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) {
@@ -1852,6 +1873,7 @@ const CORE_STACK_FLAGS = new Set([
 	"examples",
 	"auth",
 	"dbSetup",
+	"payments",
 	"api",
 	"webDeploy",
 	"serverDeploy"
@@ -2660,8 +2682,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
@@ -2723,6 +2749,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");
@@ -2763,40 +2793,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/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 apiPackageDir = path.join(projectDir, "packages/api");
-		await fs.ensureDir(apiPackageDir);
-		const apiServerBaseDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/base`);
-		if (await fs.pathExists(apiServerBaseDir)) await processAndCopyFiles("**/*", apiServerBaseDir, apiPackageDir, context);
-		let apiServerFrameworkDir = "";
-		if (context.backend === "next") apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/${context.backend}`);
-		else apiServerFrameworkDir = path.join(PKG_ROOT, `templates/api/${context.api}/server/rest`);
-		if (await fs.pathExists(apiServerFrameworkDir)) await processAndCopyFiles("**/*", apiServerFrameworkDir, apiPackageDir, context, true);
-	}
-	if (context.database !== "none" && context.orm !== "none") {
-		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 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;
@@ -2876,15 +2918,11 @@ 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, authPackageDir, context);
-		if (context.backend === "next") {
-			const authServerNextSrc = path.join(PKG_ROOT, `templates/auth/${authProvider}/server/next`);
-			if (await fs.pathExists(authServerNextSrc)) await processAndCopyFiles("**/*", authServerNextSrc, authPackageDir, context);
-		}
 		if (context.orm !== "none" && context.database !== "none") {
 			const dbPackageDir = path.join(projectDir, "packages/db");
 			await fs.ensureDir(dbPackageDir);
@@ -2910,6 +2948,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`);
@@ -2940,7 +2982,7 @@ 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`);
@@ -3020,7 +3062,7 @@ 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 (context.api !== "none") {
 				const apiPackageDir = path.join(projectDir, "packages/api");
@@ -3034,10 +3076,6 @@ async function setupExamplesTemplate(projectDir, context) {
 				const exampleDbSchemaSrc = path.join(exampleServerSrc, context.orm, context.database);
 				if (await fs.pathExists(exampleDbSchemaSrc)) await processAndCopyFiles("**/*", exampleDbSchemaSrc, dbPackageDir, context, false);
 			}
-			if (example === "ai" && context.backend === "next") {
-				const aiNextServerSrc = path.join(exampleServerSrc, "next");
-				if (await fs.pathExists(aiNextServerSrc)) await processAndCopyFiles("**/*", aiNextServerSrc, serverAppDir, context, false);
-			}
 		}
 		if (webAppDirExists) {
 			if (hasReactWeb) {
@@ -3056,6 +3094,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) {
@@ -3526,8 +3568,8 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 	await addPackageDependency({
 		devDependencies: [
 			"alchemy",
-			"nitropack",
-			"dotenv"
+			"dotenv",
+			"@cloudflare/vite-plugin"
 		],
 		projectDir: webAppDir
 	});
@@ -3555,17 +3597,6 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 			defaultImport: "alchemy"
 		});
 		else alchemyImport.setModuleSpecifier("alchemy/cloudflare/tanstack-start");
-		const reactImport = sourceFile.getImportDeclaration("@vitejs/plugin-react");
-		let reactPluginIdentifier = "viteReact";
-		if (!reactImport) sourceFile.addImportDeclaration({
-			moduleSpecifier: "@vitejs/plugin-react",
-			defaultImport: "viteReact"
-		});
-		else {
-			const defaultImport = reactImport.getDefaultImport();
-			if (defaultImport) reactPluginIdentifier = defaultImport.getText();
-			else reactImport.setDefaultImport("viteReact");
-		}
 		const exportAssignment = sourceFile.getExportAssignment((d) => !d.isExportEquals());
 		if (!exportAssignment) return;
 		const defineConfigCall = exportAssignment.getExpression();
@@ -3573,47 +3604,11 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 		let configObject = defineConfigCall.getArguments()[0];
 		if (!configObject) configObject = defineConfigCall.addArgument("{}");
 		if (Node.isObjectLiteralExpression(configObject)) {
-			if (!configObject.getProperty("build")) configObject.addPropertyAssignment({
-				name: "build",
-				initializer: `{
-    target: "esnext",
-    rollupOptions: {
-      external: ["node:async_hooks", "cloudflare:workers"],
-    },
-  }`
-			});
 			const pluginsProperty = configObject.getProperty("plugins");
 			if (pluginsProperty && Node.isPropertyAssignment(pluginsProperty)) {
 				const initializer = pluginsProperty.getInitializer();
 				if (Node.isArrayLiteralExpression(initializer)) {
-					if (!initializer.getElements().some((el) => el.getText().includes("alchemy"))) initializer.addElement("alchemy()");
-					const tanstackElements = initializer.getElements().filter((el) => el.getText().includes("tanstackStart"));
-					let needsReactPlugin = false;
-					tanstackElements.forEach((element) => {
-						if (Node.isCallExpression(element)) {
-							const args = element.getArguments();
-							if (args.length === 0) {
-								element.addArgument(`{
-      target: "cloudflare-module",
-      customViteReactPlugin: true,
-    }`);
-								needsReactPlugin = true;
-							} else if (args.length === 1 && Node.isObjectLiteralExpression(args[0])) {
-								const configObj = args[0];
-								if (!configObj.getProperty("target")) configObj.addPropertyAssignment({
-									name: "target",
-									initializer: "\"cloudflare-module\""
-								});
-								if (!!!configObj.getProperty("customViteReactPlugin")) configObj.addPropertyAssignment({
-									name: "customViteReactPlugin",
-									initializer: "true"
-								});
-								needsReactPlugin = true;
-							}
-						}
-					});
-					const hasReactPlugin = initializer.getElements().some((el) => Node.isCallExpression(el) && el.getExpression().getText() === reactPluginIdentifier);
-					if (needsReactPlugin && !hasReactPlugin) initializer.addElement(`${reactPluginIdentifier}()`);
+					if (!initializer.getElements().some((el) => el.getText().includes("alchemy("))) initializer.addElement("alchemy()");
 				}
 			} else configObject.addPropertyAssignment({
 				name: "plugins",
@@ -3624,16 +3619,6 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 	} catch (error) {
 		console.warn("Failed to update vite.config.ts:", error);
 	}
-	const nitroConfigPath = path.join(webAppDir, "nitro.config.ts");
-	await fs.writeFile(nitroConfigPath, `import { defineNitroConfig } from "nitropack/config";
-
-export default defineNitroConfig({
-    preset: "cloudflare-module",
-    cloudflare: {
-        nodeCompat: true,
-    },
-});
-`, "utf-8");
 }
 
 //#endregion
@@ -3800,7 +3785,7 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
-		devDependencies: ["wrangler"],
+		devDependencies: ["wrangler", "@cloudflare/vite-plugin"],
 		projectDir: webAppDir
 	});
 	const pkgPath = path.join(webAppDir, "package.json");
@@ -3817,6 +3802,12 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	if (!await fs.pathExists(viteConfigPath)) return;
 	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
 	if (!sourceFile) return;
+	const cfImport = sourceFile.getImportDeclaration("@cloudflare/vite-plugin");
+	if (!cfImport) sourceFile.addImportDeclaration({
+		moduleSpecifier: "@cloudflare/vite-plugin",
+		namedImports: [{ name: "cloudflare" }]
+	});
+	else if (!cfImport.getNamedImports().some((ni) => ni.getName() === "cloudflare")) cfImport.addNamedImport({ name: "cloudflare" });
 	const reactImport = sourceFile.getImportDeclaration("@vitejs/plugin-react");
 	let reactPluginIdentifier = "viteReact";
 	if (!reactImport) sourceFile.addImportDeclaration({
@@ -3836,10 +3827,7 @@ async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
 	const configObj = defineCall.getArguments()[0];
 	if (!configObj) return;
 	const pluginsArray = ensureArrayProperty(configObj, "plugins");
-	const tanstackPluginIndex = pluginsArray.getElements().findIndex((el) => el.getText().includes("tanstackStart("));
-	const tanstackPluginText = "tanstackStart({ target: \"cloudflare-module\", customViteReactPlugin: true })";
-	if (tanstackPluginIndex === -1) pluginsArray.addElement(tanstackPluginText);
-	else pluginsArray.getElements()[tanstackPluginIndex].replaceWithText(tanstackPluginText);
+	if (!pluginsArray.getElements().some((el) => el.getText().includes("cloudflare("))) pluginsArray.insertElement(0, "cloudflare({ viteEnvironment: { name: 'ssr' } })");
 	if (!pluginsArray.getElements().some((el) => Node.isCallExpression(el) && el.getExpression().getText() === reactPluginIdentifier)) {
 		const nextIndex = pluginsArray.getElements().findIndex((el) => el.getText().includes("tanstackStart(")) + 1;
 		if (nextIndex > 0) pluginsArray.insertElement(nextIndex, `${reactPluginIdentifier}()`);
@@ -3977,18 +3965,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 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");
@@ -4011,7 +4118,7 @@ async function setupExamples(config) {
 		});
 		if (apiDirExists && backend !== "none") await addPackageDependency({
 			dependencies: ["ai", "@ai-sdk/google"],
-			projectDir: apiDir
+			projectDir: apiDir$1
 		});
 	}
 }
@@ -4149,6 +4256,9 @@ async function setupApi(config) {
 			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
@@ -4447,7 +4557,7 @@ async function setupEnvironmentVariables(config) {
 			const clientVars = [{
 				key: envVarName,
 				value: serverUrl,
-				condition: true
+				condition: backend !== "self"
 			}];
 			if (backend === "convex" && auth === "clerk") {
 				if (hasNextJs) clientVars.push({
@@ -4556,47 +4666,47 @@ async function setupEnvironmentVariables(config) {
 			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"
-			}
-		];
-		await addEnvVariablesToFile(serverEnvPath, serverVars);
-	}
+	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"
+		}
+	];
+	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) {
@@ -4615,11 +4725,17 @@ 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);
+		}
 	}
 }
 
@@ -5756,7 +5872,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);
@@ -6276,7 +6392,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`;
@@ -6431,10 +6547,17 @@ async function setupWorkspaceDependencies(projectDir, options) {
 		},
 		projectDir: serverPackageDir
 	});
-	if (options.api && options.api !== "none") {
-		const webPackageDir = path.join(projectDir, "apps/web");
-		if (await fs.pathExists(webPackageDir)) await addPackageDependency({
-			customDependencies: { [`@${projectName}/api`]: workspaceVersion },
+	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;
+		if (Object.keys(webDeps).length > 0) await addPackageDependency({
+			customDependencies: webDeps,
 			projectDir: webPackageDir
 		});
 	}
@@ -6444,12 +6567,18 @@ async function setupWorkspaceDependencies(projectDir, options) {
 //#region src/helpers/core/project-config.ts
 async function updatePackageConfigurations(projectDir, options) {
 	await updateRootPackageJson(projectDir, options);
-	if (options.backend !== "convex") {
+	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);
-	} else await updateConvexPackageJson(projectDir, options);
+	}
 }
 async function updateRootPackageJson(projectDir, options) {
 	const rootPackageJsonPath = path.join(projectDir, "package.json");
@@ -6476,7 +6605,7 @@ 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 ${dbPackageName} db:push`;
@@ -6501,7 +6630,7 @@ 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 ${dbPackageName} db:push`;
@@ -6526,7 +6655,7 @@ 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 ${dbPackageName}`;
@@ -6551,7 +6680,7 @@ 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 ${dbPackageName} db:push`;
@@ -6654,12 +6783,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 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);
@@ -6667,9 +6798,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);
@@ -6678,6 +6811,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);