create-better-t-stack 3.4.2 → 3.5.1

package/dist/{src-BmqgKPgS.js → src-C4e8E70x.js}

@@ -72,17 +72,22 @@ const dependencyVersionMap = {
 	"drizzle-kit": "^0.31.2",
 	"@planetscale/database": "^1.19.0",
 	"@libsql/client": "^0.14.0",
-	"@neondatabase/serverless": "^1.0.1",
+	libsql: "^0.5.22",
+	"@neondatabase/serverless": "^1.0.2",
 	pg: "^8.14.1",
 	"@types/pg": "^8.11.11",
 	"@types/ws": "^8.18.1",
 	ws: "^8.18.3",
 	mysql2: "^3.14.0",
-	"@prisma/client": "^6.15.0",
-	prisma: "^6.15.0",
-	"@prisma/adapter-d1": "^6.15.0",
-	"@prisma/adapter-libsql": "^6.15.0",
-	"@prisma/adapter-planetscale": "^6.15.0",
+	"@prisma/client": "^7.0.0",
+	prisma: "^7.0.0",
+	"@prisma/adapter-d1": "^7.0.0",
+	"@prisma/adapter-neon": "^7.0.0",
+	"@prisma/adapter-mariadb": "^7.0.0",
+	"@prisma/adapter-libsql": "^7.0.0",
+	"@prisma/adapter-better-sqlite3": "^7.0.0",
+	"@prisma/adapter-pg": "^7.0.0",
+	"@prisma/adapter-planetscale": "^7.0.0",
 	mongoose: "^8.14.0",
 	"vite-plugin-pwa": "^1.0.1",
 	"@vite-pwa/assets-generator": "^1.0.0",
@@ -147,7 +152,7 @@ const dependencyVersionMap = {
 	"@cloudflare/workers-types": "^4.20250822.0",
 	alchemy: "^0.77.0",
 	dotenv: "^17.2.2",
-	tsdown: "^0.15.5",
+	tsdown: "^0.16.5",
 	zod: "^4.1.11",
 	srvx: "0.8.15",
 	"@polar-sh/better-auth": "^1.1.3",
@@ -278,16 +283,8 @@ const ProjectNameSchema = z.string().min(1, "Project name cannot be empty").max(
 		"*"
 	].some((char) => name.includes(char));
 }, "Project name contains invalid characters").refine((name) => name.toLowerCase() !== "node_modules", "Project name is reserved").describe("Project name or path");
-const WebDeploySchema = z.enum([
-	"wrangler",
-	"alchemy",
-	"none"
-]).describe("Web deployment");
-const ServerDeploySchema = z.enum([
-	"wrangler",
-	"alchemy",
-	"none"
-]).describe("Server deployment");
+const WebDeploySchema = z.enum(["alchemy", "none"]).describe("Web deployment");
+const ServerDeploySchema = z.enum(["alchemy", "none"]).describe("Server deployment");
 const DirectoryConflictSchema = z.enum([
 	"merge",
 	"overwrite",
@@ -1131,10 +1128,6 @@ async function getRuntimeChoice(runtime, backend) {
 //#endregion
 //#region src/prompts/server-deploy.ts
 function getDeploymentDisplay$1(deployment) {
-	if (deployment === "wrangler") return {
-		label: "Wrangler",
-		hint: "Deploy to Cloudflare Workers using Wrangler"
-	};
 	if (deployment === "alchemy") return {
 		label: "Alchemy",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
@@ -1144,40 +1137,17 @@ function getDeploymentDisplay$1(deployment) {
 		hint: `Add ${deployment} deployment`
 	};
 }
-async function getServerDeploymentChoice(deployment, runtime, backend, webDeploy) {
+async function getServerDeploymentChoice(deployment, runtime, backend, _webDeploy) {
 	if (deployment !== void 0) return deployment;
 	if (backend === "none" || backend === "convex") return "none";
 	if (backend !== "hono") return "none";
-	const options = [];
-	if (runtime !== "workers") return "none";
-	["alchemy", "wrangler"].forEach((deploy) => {
-		const { label, hint } = getDeploymentDisplay$1(deploy);
-		options.unshift({
-			value: deploy,
-			label,
-			hint
-		});
-	});
-	const response = await select({
-		message: "Select server deployment",
-		options,
-		initialValue: webDeploy === "alchemy" ? "alchemy" : runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
-	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
-	return response;
+	if (runtime === "workers") return "alchemy";
+	return "none";
 }
 async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	if (backend !== "hono") return "none";
 	const options = [];
 	if (runtime === "workers") {
-		if (existingDeployment !== "wrangler") {
-			const { label, hint } = getDeploymentDisplay$1("wrangler");
-			options.push({
-				value: "wrangler",
-				label,
-				hint
-			});
-		}
 		if (existingDeployment !== "alchemy") {
 			const { label, hint } = getDeploymentDisplay$1("alchemy");
 			options.push({
@@ -1193,7 +1163,7 @@ async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	const response = await select({
 		message: "Select server deployment",
 		options,
-		initialValue: runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
+		initialValue: DEFAULT_CONFIG.serverDeploy
 	});
 	if (isCancel(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1205,10 +1175,6 @@ function hasWebFrontend(frontends) {
 	return frontends.some((f) => WEB_FRAMEWORKS.includes(f));
 }
 function getDeploymentDisplay(deployment) {
-	if (deployment === "wrangler") return {
-		label: "Wrangler",
-		hint: "Deploy to Cloudflare Workers using Wrangler"
-	};
 	if (deployment === "alchemy") return {
 		label: "Alchemy",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
@@ -1223,11 +1189,7 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 	if (!hasWebFrontend(frontend)) return "none";
 	const response = await select({
 		message: "Select web deployment",
-		options: [
-			"wrangler",
-			"alchemy",
-			"none"
-		].map((deploy) => {
+		options: ["alchemy", "none"].map((deploy) => {
 			const { label, hint } = getDeploymentDisplay(deploy);
 			return {
 				value: deploy,
@@ -1243,14 +1205,6 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 async function getDeploymentToAdd(frontend, existingDeployment) {
 	if (!hasWebFrontend(frontend)) return "none";
 	const options = [];
-	if (existingDeployment !== "wrangler") {
-		const { label, hint } = getDeploymentDisplay("wrangler");
-		options.push({
-			value: "wrangler",
-			label,
-			hint
-		});
-	}
 	if (existingDeployment !== "alchemy") {
 		const { label, hint } = getDeploymentDisplay("alchemy");
 		options.push({
@@ -1814,8 +1768,8 @@ function validateFullConfig(config, providedFlags, 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 (providedFlags.has("serverDeploy") && (config.serverDeploy === "alchemy" || config.serverDeploy === "wrangler") && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
+	if (config.runtime === "workers" && config.serverDeploy === "none") exitWithError("Cloudflare Workers runtime requires a server deployment. Please choose 'alchemy' for --server-deploy.");
+	if (providedFlags.has("serverDeploy") && config.serverDeploy === "alchemy" && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
 	if (config.addons && config.addons.length > 0) {
 		validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
 		config.addons = [...new Set(config.addons)];
@@ -2735,6 +2689,38 @@ handlebars.registerHelper("or", (...args) => {
 });
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
+//#endregion
+//#region src/helpers/deployment/alchemy/env-dts-setup.ts
+const tsProject$1 = new Project({
+	useInMemoryFileSystem: false,
+	skipAddingFilesFromTsConfig: true
+});
+function determineImportPath(envDtsPath, projectDir, config) {
+	const { webDeploy, serverDeploy, backend } = config;
+	const isBackendSelf = backend === "self";
+	let alchemyRunPath;
+	if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) if (isBackendSelf) alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+	else if (webDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
+	else if (serverDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/server/alchemy.run.ts");
+	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
+	const relativePath = path.relative(path.dirname(envDtsPath), alchemyRunPath.replace(/\.ts$/, ""));
+	return (relativePath.startsWith(".") ? relativePath : `./${relativePath}`).replace(/\\/g, "/");
+}
+async function setupEnvDtsImport(envDtsPath, projectDir, config) {
+	if (!await fs.pathExists(envDtsPath)) return;
+	const importPath = determineImportPath(envDtsPath, projectDir, config);
+	const sourceFile = tsProject$1.addSourceFileAtPath(envDtsPath);
+	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === importPath && imp.getNamedImports().some((named) => named.getName() === "server"))) sourceFile.insertImportDeclaration(0, {
+		moduleSpecifier: importPath,
+		namedImports: [{
+			name: "server",
+			isTypeOnly: true
+		}]
+	});
+	await sourceFile.save();
+}
+
 //#endregion
 //#region src/helpers/core/template-manager.ts
 async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
@@ -3226,21 +3212,23 @@ async function setupDeploymentTemplates(projectDir, context) {
 			if (await fs.pathExists(alchemyTemplateSrc)) {
 				const webAppDir = path.join(projectDir, "apps/web");
 				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, isBackendSelf && await fs.pathExists(webAppDir) ? webAppDir : projectDir, context);
-				await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+				if (!isBackendSelf) 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 (!isBackendSelf) 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);
+					const envDtsPath = path.join(serverAppDir, "env.d.ts");
+					await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+					await setupEnvDtsImport(envDtsPath, projectDir, context);
 					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
 				}
 			}
@@ -3280,10 +3268,18 @@ async function addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc) {
 		"packages/db"
 	]) {
 		const packageDir = path.join(projectDir, packageName);
-		if (await fs.pathExists(packageDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, packageDir, context);
+		if (await fs.pathExists(packageDir)) {
+			const envDtsPath = path.join(packageDir, "env.d.ts");
+			await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+			await setupEnvDtsImport(envDtsPath, projectDir, context);
+		}
 	}
 	const serverAppDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverAppDir)) await processAndCopyFiles("env.d.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
+	if (await fs.pathExists(serverAppDir)) {
+		const envDtsPath = path.join(serverAppDir, "env.d.ts");
+		await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
+		await setupEnvDtsImport(envDtsPath, projectDir, context);
+	}
 }
 
 //#endregion
@@ -3337,54 +3333,13 @@ async function addAddonsToProject(input) {
 //#region src/helpers/deployment/server-deploy-setup.ts
 async function setupServerDeploy(config) {
 	const { serverDeploy, webDeploy, projectDir } = config;
-	const { packageManager } = config;
 	if (serverDeploy === "none") return;
 	if (serverDeploy === "alchemy" && webDeploy === "alchemy") return;
 	const serverDir = path.join(projectDir, "apps/server");
 	if (!await fs.pathExists(serverDir)) return;
-	if (serverDeploy === "wrangler") {
-		await setupWorkersServerDeploy(serverDir, packageManager);
-		await generateCloudflareWorkerTypes({
-			serverDir,
-			packageManager
-		});
-	} else if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, packageManager, projectDir);
+	if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, projectDir);
 }
-async function setupWorkersServerDeploy(serverDir, _packageManager) {
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return;
-	const packageJson = await fs.readJson(packageJsonPath);
-	packageJson.scripts = {
-		...packageJson.scripts,
-		dev: "wrangler dev --port=3000",
-		start: "wrangler dev",
-		deploy: "wrangler deploy",
-		build: "wrangler deploy --dry-run",
-		"cf-typegen": "wrangler types --env-interface CloudflareBindings"
-	};
-	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	await addPackageDependency({
-		devDependencies: ["wrangler", "@types/node"],
-		projectDir: serverDir
-	});
-}
-async function generateCloudflareWorkerTypes({ serverDir, packageManager }) {
-	if (!await fs.pathExists(serverDir)) return;
-	const s = spinner();
-	try {
-		s.start("Generating Cloudflare Workers types...");
-		await execa(getPackageExecutionCommand(packageManager, "wrangler types --env-interface CloudflareBindings"), {
-			cwd: serverDir,
-			shell: true
-		});
-		s.stop("Cloudflare Workers types generated successfully!");
-	} catch {
-		s.stop(pc.yellow("Failed to generate Cloudflare Workers types"));
-		const managerCmd = `${packageManager} run`;
-		log.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
-	}
-}
-async function setupAlchemyServerDeploy(serverDir, _packageManager, projectDir) {
+async function setupAlchemyServerDeploy(serverDir, projectDir) {
 	if (!await fs.pathExists(serverDir)) return;
 	await addPackageDependency({
 		devDependencies: [
@@ -3719,7 +3674,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, projectDir);
+	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, projectDir);
 	const frontend = config.frontend;
 	const isNext = frontend.includes("next");
 	const isNuxt = frontend.includes("nuxt");
@@ -3737,219 +3692,13 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
 }
 
-//#endregion
-//#region src/helpers/deployment/workers/workers-next-setup.ts
-async function setupNextWorkersDeploy(projectDir, _packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		dependencies: ["@opennextjs/cloudflare"],
-		devDependencies: ["wrangler"],
-		projectDir: webAppDir
-	});
-	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const pkg = await fs.readJson(packageJsonPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
-			deploy: "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
-			upload: "opennextjs-cloudflare build && opennextjs-cloudflare upload",
-			"cf-typegen": "wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts"
-		};
-		await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-nuxt-setup.ts
-async function setupNuxtWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["nitro-cloudflare-dev", "wrangler"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
-	if (!await fs.pathExists(nuxtConfigPath)) return;
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(nuxtConfigPath);
-	if (!sourceFile) return;
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineNuxtConfig";
-	});
-	if (!defineCall) return;
-	const configObj = defineCall.getArguments()[0];
-	if (!configObj) return;
-	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-	const compatProp = configObj.getProperty("compatibilityDate");
-	if (compatProp && compatProp.getKind() === SyntaxKind.PropertyAssignment) compatProp.setInitializer(`'${today}'`);
-	else configObj.addPropertyAssignment({
-		name: "compatibilityDate",
-		initializer: `'${today}'`
-	});
-	const nitroInitializer = `{
-    preset: "cloudflare_module",
-    cloudflare: {
-      deployConfig: true,
-      nodeCompat: true
-    }
-  }`;
-	const nitroProp = configObj.getProperty("nitro");
-	if (nitroProp && nitroProp.getKind() === SyntaxKind.PropertyAssignment) nitroProp.setInitializer(nitroInitializer);
-	else configObj.addPropertyAssignment({
-		name: "nitro",
-		initializer: nitroInitializer
-	});
-	const modulesProp = configObj.getProperty("modules");
-	if (modulesProp && modulesProp.getKind() === SyntaxKind.PropertyAssignment) {
-		const arrayExpr = modulesProp.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
-		if (arrayExpr) {
-			if (!arrayExpr.getElements().some((el) => el.getText().replace(/['"`]/g, "") === "nitro-cloudflare-dev")) arrayExpr.addElement("'nitro-cloudflare-dev'");
-		}
-	} else configObj.addPropertyAssignment({
-		name: "modules",
-		initializer: "['nitro-cloudflare-dev']"
-	});
-	await tsProject.save();
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-svelte-setup.ts
-async function setupSvelteWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["@sveltejs/adapter-cloudflare", "wrangler"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types ./src/worker-configuration.d.ts"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const possibleConfigFiles = [path.join(webAppDir, "svelte.config.js"), path.join(webAppDir, "svelte.config.ts")];
-	const existingConfigPath = (await Promise.all(possibleConfigFiles.map(async (p) => await fs.pathExists(p) ? p : ""))).find((p) => p);
-	if (existingConfigPath) {
-		const sourceFile = tsProject.addSourceFileAtPathIfExists(existingConfigPath);
-		if (!sourceFile) return;
-		const adapterImport = sourceFile.getImportDeclarations().find((imp) => ["@sveltejs/adapter-auto", "@sveltejs/adapter-node"].includes(imp.getModuleSpecifierValue()));
-		if (adapterImport) adapterImport.setModuleSpecifier("@sveltejs/adapter-cloudflare");
-		else if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@sveltejs/adapter-cloudflare")) sourceFile.insertImportDeclaration(0, {
-			defaultImport: "adapter",
-			moduleSpecifier: "@sveltejs/adapter-cloudflare"
-		});
-		await tsProject.save();
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-tanstack-start-setup.ts
-async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["wrangler", "@cloudflare/vite-plugin"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types --env-interface Env"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
-	if (!await fs.pathExists(viteConfigPath)) return;
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) return;
-	const 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({
-		moduleSpecifier: "@vitejs/plugin-react",
-		defaultImport: "viteReact"
-	});
-	else {
-		const defaultImport = reactImport.getDefaultImport();
-		if (defaultImport) reactPluginIdentifier = defaultImport.getText();
-		else reactImport.setDefaultImport("viteReact");
-	}
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) return;
-	const configObj = defineCall.getArguments()[0];
-	if (!configObj) return;
-	const pluginsArray = ensureArrayProperty(configObj, "plugins");
-	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}()`);
-		else pluginsArray.addElement(`${reactPluginIdentifier}()`);
-	}
-	await tsProject.save();
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-vite-setup.ts
-async function setupWorkersVitePlugin(projectDir) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
-	if (!await fs.pathExists(viteConfigPath)) throw new Error("vite.config.ts not found in web app directory");
-	await addPackageDependency({
-		devDependencies: ["@cloudflare/vite-plugin", "wrangler"],
-		projectDir: webAppDir
-	});
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) throw new Error("vite.config.ts not found in web app directory");
-	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@cloudflare/vite-plugin")) sourceFile.insertImportDeclaration(0, {
-		namedImports: ["cloudflare"],
-		moduleSpecifier: "@cloudflare/vite-plugin"
-	});
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
-	const configObject = defineCall.getArguments()[0];
-	if (!configObject) throw new Error("defineConfig argument is not an object literal");
-	const pluginsArray = ensureArrayProperty(configObject, "plugins");
-	if (!pluginsArray.getElements().some((el) => el.getText().includes("cloudflare("))) pluginsArray.addElement("cloudflare()");
-	await tsProject.save();
-}
-
 //#endregion
 //#region src/helpers/deployment/web-deploy-setup.ts
 async function setupWebDeploy(config) {
 	const { webDeploy, serverDeploy, frontend, projectDir } = config;
 	const { packageManager } = config;
 	if (webDeploy === "none") return;
-	if (webDeploy !== "wrangler" && webDeploy !== "alchemy") return;
+	if (webDeploy !== "alchemy") return;
 	if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
 		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
 		await addAlchemyPackagesDependencies(projectDir);
@@ -3962,37 +3711,14 @@ async function setupWebDeploy(config) {
 	const isTanstackStart = frontend.includes("tanstack-start");
 	const isReactRouter = frontend.includes("react-router");
 	const isSolid = frontend.includes("solid");
-	if (webDeploy === "wrangler") {
-		if (isNext) await setupNextWorkersDeploy(projectDir, packageManager);
-		else if (isNuxt) await setupNuxtWorkersDeploy(projectDir, packageManager);
-		else if (isSvelte) await setupSvelteWorkersDeploy(projectDir, packageManager);
-		else if (isTanstackStart) await setupTanstackStartWorkersDeploy(projectDir, packageManager);
-		else if (isTanstackRouter || isReactRouter || isSolid) await setupWorkersWebDeploy(projectDir, packageManager);
-	} else if (webDeploy === "alchemy") {
-		if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager);
-		else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager);
-		else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager);
-		else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
-		else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
-		else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
-		else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
-		await addAlchemyPackagesDependencies(projectDir);
-	}
-}
-async function setupWorkersWebDeploy(projectDir, pkgManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			"wrangler:dev": "wrangler dev --port=3001",
-			deploy: `${pkgManager} run build && wrangler deploy`
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-	await setupWorkersVitePlugin(projectDir);
+	if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager);
+	else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager);
+	else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager);
+	else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
+	else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
+	else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
+	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
+	await addAlchemyPackagesDependencies(projectDir);
 }
 async function addAlchemyPackagesDependencies(projectDir) {
 	await addPackageDependency({
@@ -4853,7 +4579,7 @@ ${hasWeb ? "# npx convex env set SITE_URL http://localhost:3001\n" : ""}
 			databaseUrl = "mongodb://localhost:27017/mydatabase";
 			break;
 		case "sqlite":
-			if (config.runtime === "workers" || webDeploy === "wrangler" || serverDeploy === "wrangler" || webDeploy === "alchemy" || serverDeploy === "alchemy") databaseUrl = "http://127.0.0.1:8080";
+			if (config.runtime === "workers" || webDeploy === "alchemy" || serverDeploy === "alchemy") databaseUrl = "http://127.0.0.1:8080";
 			else {
 				const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
 				databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
@@ -4935,31 +4661,7 @@ ${hasWeb ? "# npx convex env set SITE_URL http://localhost:3001\n" : ""}
 //#region src/helpers/database-providers/d1-setup.ts
 async function setupCloudflareD1(config) {
 	const { projectDir, serverDeploy, orm, backend } = config;
-	if (serverDeploy === "wrangler") {
-		const targetApp = backend === "self" ? "apps/web" : "apps/server";
-		const envPath = path.join(projectDir, targetApp, ".env");
-		const variables = [
-			{
-				key: "CLOUDFLARE_ACCOUNT_ID",
-				value: "",
-				condition: true
-			},
-			{
-				key: "CLOUDFLARE_DATABASE_ID",
-				value: "",
-				condition: true
-			},
-			{
-				key: "CLOUDFLARE_D1_TOKEN",
-				value: "",
-				condition: true
-			}
-		];
-		try {
-			await addEnvVariablesToFile(envPath, variables);
-		} catch (_err) {}
-	}
-	if ((serverDeploy === "wrangler" || serverDeploy === "alchemy") && orm === "prisma") {
+	if (serverDeploy === "alchemy" && orm === "prisma") {
 		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
 		const envPath = path.join(projectDir, targetApp2, ".env");
 		const variables = [{
@@ -5951,40 +5653,60 @@ async function setupDatabase(config, cliInput) {
 	}
 	const s = spinner();
 	const dbPackageDir = path.join(projectDir, "packages/db");
+	const webDir = path.join(projectDir, "apps/web");
 	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"],
+			if (database === "mongodb") await addPackageDependency({
+				customDependencies: { "@prisma/client": "6.19.0" },
+				customDevDependencies: { prisma: "6.19.0" },
 				projectDir: dbPackageDir
 			});
-			else if (database === "sqlite" && dbSetup === "turso") await addPackageDependency({
-				dependencies: ["@prisma/client", "@prisma/adapter-libsql"],
-				devDependencies: ["prisma"],
-				projectDir: dbPackageDir
+			else {
+				const prismaDependencies = ["@prisma/client"];
+				const prismaDevDependencies = ["prisma"];
+				if (database === "mysql" && dbSetup === "planetscale") prismaDependencies.push("@prisma/adapter-planetscale", "@planetscale/database");
+				else if (database === "mysql") prismaDependencies.push("@prisma/adapter-mariadb");
+				else if (database === "sqlite") if (dbSetup === "d1") prismaDependencies.push("@prisma/adapter-d1");
+				else prismaDependencies.push("@prisma/adapter-libsql");
+				else if (database === "postgres") if (dbSetup === "neon") {
+					prismaDependencies.push("@prisma/adapter-neon", "@neondatabase/serverless", "ws");
+					prismaDevDependencies.push("@types/ws");
+				} else {
+					prismaDependencies.push("@prisma/adapter-pg");
+					prismaDependencies.push("pg");
+					prismaDevDependencies.push("@types/pg");
+				}
+				await addPackageDependency({
+					dependencies: prismaDependencies,
+					devDependencies: prismaDevDependencies,
+					projectDir: dbPackageDir
+				});
+			}
+			if (await fs.pathExists(webDir)) if (database === "mongodb") await addPackageDependency({
+				customDependencies: { "@prisma/client": "6.19.0" },
+				projectDir: webDir
 			});
 			else await addPackageDependency({
-				dependencies: ["@prisma/client"],
-				devDependencies: ["prisma"],
-				projectDir: dbPackageDir
-			});
-			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
-			});
-			else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
+			if (database === "sqlite") {
+				await addPackageDependency({
+					dependencies: [
+						"drizzle-orm",
+						"@libsql/client",
+						"libsql"
+					],
+					devDependencies: ["drizzle-kit"],
+					projectDir: dbPackageDir
+				});
+				await addPackageDependency({
+					dependencies: ["@libsql/client", "libsql"],
+					projectDir: webDir
+				});
+			} else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
 				dependencies: [
 					"drizzle-orm",
 					"@neondatabase/serverless",
@@ -6303,7 +6025,7 @@ 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, backend) {
+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";
@@ -6312,7 +6034,7 @@ function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSet
 	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
+${dbSetup === "d1" ? "D1 local development and migrations are handled automatically by Alchemy during dev and deploy." : `\`\`\`bash
 cd ${dbLocalPath} && ${packageManagerRunCmd} db:local
 \`\`\`
 `}
@@ -6410,11 +6132,6 @@ function generateDeploymentCommands(packageManagerRunCmd, webDeploy, serverDeplo
 		if (serverDeploy === "alchemy" && webDeploy !== "alchemy") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`, `- Server destroy: cd apps/server && ${packageManagerRunCmd} destroy`);
 		if (webDeploy === "alchemy" && serverDeploy === "alchemy") lines.push(`- Dev: ${packageManagerRunCmd} dev`, `- Deploy: ${packageManagerRunCmd} deploy`, `- Destroy: ${packageManagerRunCmd} destroy`);
 	}
-	if (webDeploy === "wrangler" || serverDeploy === "wrangler") {
-		lines.push("\n## Deployment (Cloudflare Wrangler)");
-		if (webDeploy === "wrangler") lines.push(`- Web deploy: cd apps/web && ${packageManagerRunCmd} deploy`);
-		if (serverDeploy === "wrangler") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`);
-	}
 	return lines.length ? `\n${lines.join("\n")}\n` : "";
 }
 
@@ -6538,7 +6255,6 @@ async function displayPostInstallInstructions(config) {
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
 	const clerkInstructions = isConvex && config.auth === "clerk" ? getClerkInstructions() : "";
 	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",
@@ -6558,7 +6274,7 @@ async function displayPostInstallInstructions(config) {
 	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
 	let stepCounter = 2;
 	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
-	if (database === "sqlite" && dbSetup === "none" && (serverDeploy === "wrangler" || serverDeploy === "alchemy" || webDeploy === "wrangler" || webDeploy === "alchemy")) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (starts local SQLite server for Workers compatibility)")}\n`;
+	if (database === "sqlite" && dbSetup === "none" && (serverDeploy === "alchemy" || webDeploy === "alchemy")) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (starts local SQLite server for Workers compatibility)")}\n`;
 	if (isConvex) {
 		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`;
@@ -6569,7 +6285,6 @@ async function displayPostInstallInstructions(config) {
 		if (runtime === "workers") {
 			if (dbSetup === "d1") output += `${pc.yellow("IMPORTANT:")} Complete D1 database setup first\n   (see Database commands below)\n`;
 			output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
-			if (serverDeploy === "wrangler") output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} cf-typegen\n`;
 		}
 	}
 	output += `${pc.bold("Your project will be available at:")}\n`;
@@ -6587,7 +6302,6 @@ async function displayPostInstallInstructions(config) {
 	if (tauriInstructions) output += `\n${tauriInstructions.trim()}\n`;
 	if (lintingInstructions) output += `\n${lintingInstructions.trim()}\n`;
 	if (pwaInstructions) output += `\n${pwaInstructions.trim()}\n`;
-	if (wranglerDeployInstructions) output += `\n${wranglerDeployInstructions.trim()}\n`;
 	if (alchemyDeployInstructions) output += `\n${alchemyDeployInstructions.trim()}\n`;
 	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
 	if (clerkInstructions) output += `\n${clerkInstructions.trim()}\n`;
@@ -6610,7 +6324,7 @@ function getNativeInstructions(isConvex, isBackendSelf, _frontend) {
 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, backend) {
+async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup, serverDeploy, _backend) {
 	const instructions = [];
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
@@ -6619,21 +6333,10 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup,
 			instructions.push("");
 		}
 	}
-	if (serverDeploy === "wrangler" && dbSetup === "d1") {
-		if (orm === "prisma" && runtime === "workers") instructions.push(`\n${pc.yellow("WARNING:")} Prisma + D1 on Workers with Wrangler has migration issues.\n   Consider using Alchemy deploy instead of Wrangler for D1 projects.\n`);
-		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`)}`);
-		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`)}`);
-	}
 	if (dbSetup === "d1" && serverDeploy === "alchemy") {
-		if (orm === "drizzle") instructions.push(`${pc.yellow("NOTE:")} D1 migrations are automatically handled by Alchemy`);
+		if (orm === "drizzle") instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
 		else if (orm === "prisma") {
-			instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
+			instructions.push(`${pc.cyan("•")} Generate Prisma client: ${`${runCmd} db:generate`}`);
 			instructions.push(`${pc.cyan("•")} Apply migrations: ${`${runCmd} db:migrate`}`);
 		}
 	}
@@ -6641,10 +6344,14 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup,
 		if (database === "mysql" && orm === "drizzle") instructions.push(`${pc.yellow("NOTE:")} Enable foreign key constraints in PlanetScale database settings`);
 		if (database === "mysql" && orm === "prisma") instructions.push(`${pc.yellow("NOTE:")} How to handle Prisma migrations with PlanetScale:\n   https://github.com/prisma/prisma/issues/7292`);
 	}
+	if (dbSetup === "turso" && orm === "prisma") instructions.push(`${pc.yellow("NOTE:")} Follow Turso's Prisma guide for migrations via the Turso CLI:\n   https://docs.turso.tech/sdk/ts/orm/prisma`);
 	if (orm === "prisma") {
 		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
-		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) {
+			instructions.push(`${pc.cyan("•")} Generate Prisma Client: ${`${runCmd} db:generate`}`);
+			instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
+		}
 		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 	} else if (orm === "drizzle") {
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
@@ -6670,15 +6377,6 @@ 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, backend) {
-	const instructions = [];
-	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} deploy`}`);
-	}
-	if (serverDeploy === "wrangler" && backend !== "self") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} 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`;
 }
@@ -6689,7 +6387,7 @@ function getPolarInstructions(backend) {
 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`}`);
+	if (webDeploy === "alchemy" && serverDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy web with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy 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" && !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")}` : "";
@@ -6701,7 +6399,7 @@ async function setupWorkspaceDependencies(projectDir, options) {
 	const projectName = options.projectName;
 	const workspaceVersion = options.packageManager === "npm" ? "*" : "workspace:*";
 	const commonDeps = ["dotenv", "zod"];
-	const commonDevDeps = ["tsdown"];
+	const commonDevDeps = [];
 	const configPackageDir = path.join(projectDir, "packages/config");
 	const configDep = {};
 	if (await fs.pathExists(configPackageDir)) configDep[`@${projectName}/config`] = workspaceVersion;
@@ -6745,7 +6443,7 @@ async function setupWorkspaceDependencies(projectDir, options) {
 		if (options.database !== "none" && await fs.pathExists(dbPackageDir)) serverDeps[`@${projectName}/db`] = workspaceVersion;
 		await addPackageDependency({
 			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
+			devDependencies: [...commonDevDeps, "tsdown"],
 			customDependencies: serverDeps,
 			customDevDependencies: configDep,
 			projectDir: serverPackageDir