create-better-t-stack 3.38.2 → 3.39.2

package/README.md

@@ -27,12 +27,23 @@ npx create-better-t-stack@latest
 
 Follow the prompts to configure your project or use the `--yes` flag for defaults.
 
+## Requirements
+
+- Node.js 22 or newer to run the CLI with Node.js. The selected framework may require a newer release; the CLI checks the exact stack before writing files.
+- Bun 1.3 or newer is recommended. Bun 1.2.14 remains the minimum because generated workspaces use dependency catalogs.
+- pnpm 10.26.0 or newer when using pnpm (catalogs and `allowBuilds`).
+- npm 11.16.0 or newer when using npm (`allowScripts`).
+
+Docker Compose 2.24 or newer is required by generated Docker stacks. Git, Rust, Docker,
+and platform SDKs otherwise remain optional and are only needed when you use their corresponding
+generated commands.
+
 ## Features
 
 | Category                 | Options                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | **TypeScript**           | End-to-end type safety across all parts of your application                                                                                                                                                                                                                                                                                                                                                                               |
-| **Frontend**             | • React with TanStack Router<br>• React with React Router<br>• React with TanStack Start (SSR)<br>• Next.js<br>• SvelteKit<br>• Nuxt (Vue)<br>• SolidJS<br>• Astro<br>• React Native bare Expo<br>• React Native with NativeWind (via Expo)<br>• React Native with Unistyles (via Expo)<br>• None                                                                                                                                         |
+| **Frontend**             | • React with TanStack Router<br>• React with React Router<br>• React with TanStack Start (SSR)<br>• Next.js<br>• SvelteKit<br>• Nuxt (Vue)<br>• SolidStart v2 (SSR)<br>• Astro<br>• React Native bare Expo<br>• React Native with NativeWind (via Expo)<br>• React Native with Unistyles (via Expo)<br>• None                                                                                                                             |
 | **Backend**              | • Hono<br>• Express<br>• Elysia<br>• Fastify<br>• Self (fullstack inside the web app)<br>• Convex<br>• None                                                                                                                                                                                                                                                                                                                               |
 | **API Layer**            | • tRPC (type-safe APIs)<br>• oRPC (OpenAPI-compatible type-safe APIs)<br>• None                                                                                                                                                                                                                                                                                                                                                           |
 | **Runtime**              | • Bun<br>• Node.js<br>• Cloudflare Workers<br>• None                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -245,13 +256,13 @@ npx create-better-t-stack --frontend none --backend hono --api trpc --database n
 - **ORM 'none'**: Can be used when you want to handle database operations manually or use a different ORM.
 - **Runtime 'none'**: Only available with Convex backend, backend `none`, or backend `self`.
 - **Cloudflare Workers runtime**: Only compatible with Hono backend. If a database is used, MongoDB is not supported.
-- **Cloudflare D1 setup**: Requires `sqlite` and either `--runtime workers --server-deploy cloudflare` or `--backend self --web-deploy cloudflare`. For `backend self`, D1 is supported on `next`, `tanstack-start`, `nuxt`, `svelte`, and `astro`.
+- **Cloudflare D1 setup**: Requires `sqlite` and either `--runtime workers --server-deploy cloudflare` or `--backend self --web-deploy cloudflare`. For `backend self`, D1 is supported on `next`, `tanstack-start`, `nuxt`, `svelte`, `solid`, and `astro`.
 - **Addons 'none'**: Skips all addons.
 - **Examples 'none'**: Skips all example implementations (todo, AI chat).
-- **Nuxt, Svelte, SolidJS, and Astro** frontends are only compatible with oRPC API layer
-- **PWA support** requires TanStack Router, React Router, Next.js, or SolidJS
-- **Tauri desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, SolidJS, or Astro
-- **Electrobun desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, SolidJS, or Astro. Desktop packaging uses static web assets, so SSR-first frontends need a static/export build before desktop builds will work.
+- **Nuxt, Svelte, SolidStart, and Astro** frontends are only compatible with the oRPC API layer
+- **PWA support** requires TanStack Router, React Router, Next.js, or SolidStart
+- **Tauri desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, or Astro
+- **Electrobun desktop app** requires TanStack Router, React Router, TanStack Start, Next.js, Nuxt, SvelteKit, or Astro. Desktop packaging uses static web assets, so SSR-first frontends need a static/export build before desktop builds will work.
 - **AI example** is not compatible with Solid or Astro. With Convex backend, it also excludes Nuxt and Svelte.
 
 ## Project Structure

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { _ as types_exports, i as SchemaNameSchema, l as create, m as getSchemaResult, s as add, u as createBtsCli, v as getLatestCLIVersion } from "./src-ihjK9T9S.mjs";
+import { _ as types_exports, i as SchemaNameSchema, l as create, m as getSchemaResult, s as add, u as createBtsCli, v as getLatestCLIVersion } from "./src-BYgmfow5.mjs";
 import z from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -44,8 +44,8 @@ function formatToolSuccess(data) {
 		}
 	};
 }
-function formatToolError(error) {
-	const message = error instanceof Error ? error.message : String(error);
+function formatToolError(cause) {
+	const message = cause instanceof Error ? cause.message : String(cause);
 	return {
 		content: [{
 			type: "text",

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Result, Result as Result$1 } from "better-result";
-import { TrpcCliMeta, createCli } from "trpc-cli";
+import { TrpcCli, TrpcCliMeta } from "trpc-cli";
 import z from "zod";
 import { EMBEDDED_TEMPLATES, GeneratorError, GeneratorError as GeneratorError$1, GeneratorOptions, TEMPLATE_COUNT, VirtualDirectory, VirtualFile, VirtualFileSystem, VirtualFileTree, VirtualFileTree as VirtualFileTree$1, VirtualNode, generate } from "@better-t-stack/template-generator";
 import * as import__better_t_stack_types from "@better-t-stack/types";
@@ -31,12 +31,12 @@ declare const ValidationError_base: import("better-result").TaggedErrorClass<"Va
  */
 declare class ValidationError extends ValidationError_base<{
   field?: string;
-  value?: unknown;
+  value?: string | number | boolean | null;
   message: string;
 }> {
   constructor(args: {
     field?: string;
-    value?: unknown;
+    value?: string | number | boolean | null;
     message: string;
   });
 }
@@ -179,8 +179,8 @@ declare const router: import("@trpc/server").TRPCBuiltRouter<{
       backend?: "none" | "hono" | "express" | "fastify" | "elysia" | "convex" | "self" | undefined;
       runtime?: "none" | "bun" | "node" | "workers" | undefined;
       api?: "none" | "trpc" | "orpc" | undefined;
-      webDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
-      serverDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
+      webDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
+      serverDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
       directoryConflict?: "merge" | "overwrite" | "increment" | "error" | undefined;
       renderTitle?: boolean | undefined;
       disableAnalytics?: boolean | undefined;
@@ -278,8 +278,8 @@ declare const router: import("@trpc/server").TRPCBuiltRouter<{
       backend?: "none" | "hono" | "express" | "fastify" | "elysia" | "convex" | "self" | undefined;
       runtime?: "none" | "bun" | "node" | "workers" | undefined;
       api?: "none" | "trpc" | "orpc" | undefined;
-      webDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
-      serverDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
+      webDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
+      serverDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
       directoryConflict?: "merge" | "overwrite" | "increment" | "error" | undefined;
       renderTitle?: boolean | undefined;
       disableAnalytics?: boolean | undefined;
@@ -359,8 +359,8 @@ declare const router: import("@trpc/server").TRPCBuiltRouter<{
           hooks?: ("cursor" | "windsurf" | "codebuddy" | "claude" | "copilot")[] | undefined;
         } | undefined;
       } | undefined;
-      webDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
-      serverDeploy?: "none" | "docker" | "cloudflare" | "vercel" | undefined;
+      webDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
+      serverDeploy?: "none" | "prisma" | "docker" | "cloudflare" | "vercel" | undefined;
       projectDir?: string | undefined;
       install?: boolean | undefined;
       packageManager?: "bun" | "npm" | "pnpm" | undefined;
@@ -379,7 +379,7 @@ declare const router: import("@trpc/server").TRPCBuiltRouter<{
     meta: TrpcCliMeta;
   }>;
 }>>;
-declare function createBtsCli(): ReturnType<typeof createCli>;
+declare function createBtsCli(): TrpcCli;
 /**
  * Error types that can be returned from create/createVirtual
  */

package/dist/index.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { C as ProjectCreationError, S as DirectoryConflictError, T as ValidationError, a as TEMPLATE_COUNT, b as CompatibilityError, c as builder, d as createVirtual, f as docs, g as sponsors, h as router, i as SchemaNameSchema, l as create, m as getSchemaResult, n as GeneratorError, o as VirtualFileSystem, p as generate, r as Result, s as add, t as EMBEDDED_TEMPLATES, u as createBtsCli, w as UserCancelledError, x as DatabaseSetupError, y as CLIError } from "./src-ihjK9T9S.mjs";
+import { C as ProjectCreationError, S as DirectoryConflictError, T as ValidationError, a as TEMPLATE_COUNT, b as CompatibilityError, c as builder, d as createVirtual, f as docs, g as sponsors, h as router, i as SchemaNameSchema, l as create, m as getSchemaResult, n as GeneratorError, o as VirtualFileSystem, p as generate, r as Result, s as add, t as EMBEDDED_TEMPLATES, u as createBtsCli, w as UserCancelledError, x as DatabaseSetupError, y as CLIError } from "./src-BYgmfow5.mjs";
 export { CLIError, CompatibilityError, DatabaseSetupError, DirectoryConflictError, EMBEDDED_TEMPLATES, GeneratorError, ProjectCreationError, Result, SchemaNameSchema, TEMPLATE_COUNT, UserCancelledError, ValidationError, VirtualFileSystem, add, builder, create, createBtsCli, createVirtual, docs, generate, getSchemaResult, router, sponsors };

package/dist/{src-ihjK9T9S.mjs → src-BYgmfow5.mjs}

@@ -11,7 +11,7 @@ import path from "node:path";
 import envPaths from "env-paths";
 import fs from "fs-extra";
 import { fileURLToPath } from "node:url";
-import { desktopWebFrontends as desktopWebFrontends$3 } from "@better-t-stack/types";
+import { desktopWebFrontends as desktopWebFrontends$2, usesAlchemyManagedDatabase } from "@better-t-stack/types";
 import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, processAddonTemplates, processAddonsDeps, processNxConfig, processPackageConfigs, processTemplateString, processTurboConfig, processVitePlusConfig } from "@better-t-stack/template-generator";
 import { consola, createConsola } from "consola";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -21,6 +21,7 @@ import { writeTree } from "@better-t-stack/template-generator/fs-writer";
 import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
 import { applyEdits, modify, parse } from "jsonc-parser";
 import os from "node:os";
+import { clean, coerce, satisfies } from "semver";
 import { format } from "oxfmt";
 //#region src/utils/display-config.ts
 const VALUE_LABELS = {
@@ -90,11 +91,16 @@ const VALUE_LABELS = {
 	npm: "npm",
 	pnpm: "pnpm"
 };
+function isKnownValueLabel(value) {
+	return Object.hasOwn(VALUE_LABELS, value);
+}
 function formatConfigValue(value) {
-	if (typeof value === "boolean") return value ? "Yes" : "No";
+	if (value === true) return "Yes";
+	if (value === false) return "No";
 	if (Array.isArray(value)) return value.length > 0 ? value.map(formatConfigValue).join(", ") : "None";
 	const text = String(value);
-	return VALUE_LABELS[text] ?? text.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+	if (isKnownValueLabel(text)) return VALUE_LABELS[text];
+	return text.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 function section(title, entries) {
 	const rows = entries.filter(([, value]) => value !== void 0).map(([label, value, format]) => ({
@@ -202,8 +208,8 @@ const ADDON_COMPATIBILITY = {
 		"solid",
 		"next"
 	],
-	tauri: desktopWebFrontends$3,
-	electrobun: desktopWebFrontends$3,
+	tauri: desktopWebFrontends$2,
+	electrobun: desktopWebFrontends$2,
 	biome: [],
 	husky: [],
 	lefthook: [],
@@ -820,19 +826,19 @@ async function fetchSponsorsData({ url = SPONSORS_JSON_URL, withSpinner = false,
 		if (timeout) clearTimeout(timeout);
 	}
 }
-function normalizeSponsorFetchError(error) {
-	if (error instanceof Error && error.name === "AbortError") return new CLIError({
+function normalizeSponsorFetchError(cause) {
+	if (cause instanceof Error && cause.name === "AbortError") return new CLIError({
 		message: "Failed to fetch sponsors: request timed out",
-		cause: error
+		cause
 	});
-	if (CLIError.is(error)) return error;
-	if (error instanceof Error) return new CLIError({
-		message: error.message.startsWith("Failed to fetch sponsors:") ? error.message : `Failed to fetch sponsors: ${error.message}`,
-		cause: error
+	if (CLIError.is(cause)) return cause;
+	if (cause instanceof Error) return new CLIError({
+		message: cause.message.startsWith("Failed to fetch sponsors:") ? cause.message : `Failed to fetch sponsors: ${cause.message}`,
+		cause
 	});
 	return new CLIError({
-		message: `Failed to fetch sponsors: ${String(error)}`,
-		cause: error
+		message: `Failed to fetch sponsors: ${String(cause)}`,
+		cause
 	});
 }
 //#endregion
@@ -927,6 +933,7 @@ const FULLSTACK_FRONTENDS$1 = [
 	"tanstack-start",
 	"nuxt",
 	"svelte",
+	"solid",
 	"astro"
 ];
 const EVLOG_SERVER_BACKENDS = [
@@ -935,7 +942,13 @@ const EVLOG_SERVER_BACKENDS = [
 	"fastify",
 	"elysia"
 ];
-const EVLOG_FULLSTACK_FRONTENDS = FULLSTACK_FRONTENDS$1;
+const EVLOG_FULLSTACK_FRONTENDS = [
+	"next",
+	"tanstack-start",
+	"nuxt",
+	"svelte",
+	"astro"
+];
 const evlogCompatibilityMessage = "evlog addon supports Hono, Express, Fastify, Elysia, or backend self with Next.js, TanStack Start, Nuxt, SvelteKit, or Astro. Convex and backend none are not supported yet.";
 function supportsEvlogAddon(frontend = [], backend, _runtime) {
 	if (!backend) return true;
@@ -951,11 +964,11 @@ function validateSelfBackendCompatibility(providedFlags, options, config) {
 	const frontends = config.frontend || options.frontend || [];
 	if (backend === "self") {
 		const { web, native } = splitFrontends(frontends);
-		if (!(web.length === 1 && FULLSTACK_FRONTENDS$1.includes(web[0]))) return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, or --frontend astro.");
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS$1.includes(web[0]))) return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, SolidStart, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend solid, or --frontend astro.");
 		if (native.length > 1) return validationErr$1("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
 	}
 	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS$1.includes(f));
-	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend astro, or choose a different backend.");
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, SolidStart, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend solid, --frontend astro, or choose a different backend.");
 	return Result.ok(void 0);
 }
 function validateWorkersCompatibility(providedFlags, options, config) {
@@ -1041,7 +1054,35 @@ function validateVercelServerDeploy(serverDeploy, backend, runtime) {
 	if (runtime === "workers") return validationErr$1("'--server-deploy vercel' is not compatible with '--runtime workers'. Use '--runtime bun' or '--runtime node', or choose '--server-deploy cloudflare'.");
 	return Result.ok(void 0);
 }
-const DOCKER_SERVER_OUTPUT_FRONTENDS = [
+function validatePrismaServerDeploy(serverDeploy, backend, runtime) {
+	if (serverDeploy !== "prisma") return Result.ok(void 0);
+	if (backend === "convex" || backend === "self") return validationErr$1("'--server-deploy prisma' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy prisma' instead.");
+	if (runtime !== "bun" && runtime !== "node") return validationErr$1("'--server-deploy prisma' requires '--runtime bun' or '--runtime node'. Use '--server-deploy cloudflare' for Workers.");
+	return Result.ok(void 0);
+}
+const PRISMA_COMPUTE_WEB_FRONTENDS = [
+	"next",
+	"nuxt",
+	"astro",
+	"react-router",
+	"tanstack-start",
+	"svelte",
+	"solid"
+];
+function supportsPrismaWebDeploy(frontend) {
+	return frontend.some((value) => PRISMA_COMPUTE_WEB_FRONTENDS.includes(value));
+}
+function validatePrismaWebDeploy(webDeploy, frontend) {
+	if (webDeploy !== "prisma" || !frontend) return Result.ok(void 0);
+	if (!supportsPrismaWebDeploy(frontend)) return validationErr$1("'--web-deploy prisma' requires a supported server frontend. Choose Next.js, Nuxt, Astro, React Router, TanStack Start, SvelteKit, or SolidStart. TanStack Router is a static SPA, while Prisma Compute requires an executable server artifact.");
+	return Result.ok(void 0);
+}
+function validateCloudflareWebDeployKnownIssues(config) {
+	if (config.webDeploy !== "cloudflare" || !config.frontend?.includes("next")) return Result.ok(void 0);
+	if (config.database === "postgres" && config.orm === "prisma" && config.dbSetup !== "neon" && config.dbSetup !== "prisma-postgres") return validationErr$1("This Prisma PostgreSQL setup with Next.js on Cloudflare is temporarily unavailable because OpenNext does not preserve pg-cloudflare's workerd files. Use Neon or Prisma Postgres, choose another Cloudflare frontend, or choose Prisma, Docker, or Vercel deployment.");
+	return Result.ok(void 0);
+}
+const DESKTOP_STATIC_EXPORT_FRONTENDS = [
 	"next",
 	"svelte",
 	"astro",
@@ -1051,10 +1092,18 @@ function validateDockerWebDeployDesktopAddons(webDeploy, addons, frontend, backe
 	if (webDeploy !== "docker" || !addons || !frontend) return Result.ok(void 0);
 	const desktopAddons = addons.filter((addon) => STATIC_DESKTOP_ADDONS.includes(addon));
 	if (desktopAddons.length === 0) return Result.ok(void 0);
-	const affected = frontend.find((f) => DOCKER_SERVER_OUTPUT_FRONTENDS.includes(f));
+	const affected = frontend.find((f) => DESKTOP_STATIC_EXPORT_FRONTENDS.includes(f));
 	if (!affected) return Result.ok(void 0);
 	if (affected === "next" && !desktopAddons.includes("tauri") && backend === "convex" && auth === "better-auth") return Result.ok(void 0);
-	return validationErr$1(`'--web-deploy docker' is not compatible with the ${desktopAddons.join(", ")} addon on '${affected}' because desktop addons switch the web build to a static export, which the docker image cannot serve. Remove the addon or use a static-serving frontend (tanstack-router, solid).`);
+	return validationErr$1(`'--web-deploy docker' is not compatible with the ${desktopAddons.join(", ")} addon on '${affected}' because desktop addons switch the web build to a static export, which the docker image cannot serve. Remove the addon or use the static-serving tanstack-router frontend.`);
+}
+function validatePrismaWebDeployDesktopAddons(webDeploy, addons, frontend) {
+	if (webDeploy !== "prisma" || !addons || !frontend) return Result.ok(void 0);
+	const desktopAddons = addons.filter((addon) => STATIC_DESKTOP_ADDONS.includes(addon));
+	if (desktopAddons.length === 0) return Result.ok(void 0);
+	const affected = frontend.find((value) => DESKTOP_STATIC_EXPORT_FRONTENDS.includes(value));
+	if (!affected) return Result.ok(void 0);
+	return validationErr$1(`'--web-deploy prisma' is not compatible with the ${desktopAddons.join(", ")} addon on '${affected}' because desktop addons replace its executable server output with a static export, while Prisma Compute requires an executable server artifact. Remove the addon or choose a server deployment that supports this desktop build.`);
 }
 function validateAddonCompatibility(addon, frontend, auth, backend, runtime) {
 	if (addon === "evlog" && !supportsEvlogAddon(frontend, backend, runtime)) return {
@@ -1101,7 +1150,13 @@ function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backe
 	return Result.ok(void 0);
 }
 function validateAddonsAgainstConfig(addons = [], config) {
-	return validateAddonsAgainstFrontends(addons, config.frontend ?? [], config.auth, config.backend, config.runtime);
+	const addonResult = validateAddonsAgainstFrontends(addons, config.frontend ?? [], config.auth, config.backend, config.runtime);
+	if (addonResult.isErr()) return addonResult;
+	const cloudflareResult = validateCloudflareWebDeployKnownIssues(config);
+	if (cloudflareResult.isErr()) return cloudflareResult;
+	const dockerResult = validateDockerWebDeployDesktopAddons(config.webDeploy, addons, config.frontend, config.backend, config.auth);
+	if (dockerResult.isErr()) return dockerResult;
+	return validatePrismaWebDeployDesktopAddons(config.webDeploy, addons, config.frontend);
 }
 function validatePaymentsCompatibility(payments, auth, _backend, _frontends = []) {
 	if (!payments || payments === "none") return Result.ok(void 0);
@@ -1344,7 +1399,7 @@ async function navigableGroupMultiselect(opts) {
 	const required = opts.required ?? true;
 	const opt = (option, state, options = []) => {
 		const label = option.label ?? String(option.value);
-		const isItem = typeof option.group === "string";
+		const isItem = option.group !== true && option.group !== false;
 		const next = isItem && (options[options.indexOf(option) + 1] ?? { group: true });
 		const isLast = isItem && next && next.group === true;
 		const prefix = isItem ? `${isLast ? S_BAR_END : S_BAR} ` : "";
@@ -1378,7 +1433,7 @@ async function navigableGroupMultiselect(opts) {
 			const value = this.value ?? [];
 			const styleOption = (option, active) => {
 				const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
-				if (!active && typeof option.group === "string" && this.options[this.cursor]?.value === option.group) return opt(option, selected ? "group-active-selected" : "group-active", this.options);
+				if (!active && option.group !== true && option.group !== false && this.options[this.cursor]?.value === option.group) return opt(option, selected ? "group-active-selected" : "group-active", this.options);
 				if (active && selected) return opt(option, "active-selected", this.options);
 				if (selected) return opt(option, "selected", this.options);
 				return opt(option, active ? "active" : "inactive", this.options);
@@ -1665,6 +1720,157 @@ function validateAgentSafePathInput(value, field) {
 	return Result.ok(void 0);
 }
 //#endregion
+//#region src/utils/external-commands.ts
+function shouldSkipExternalCommands() {
+	return process.env.BTS_SKIP_EXTERNAL_COMMANDS === "1" || process.env.BTS_TEST_MODE === "1";
+}
+//#endregion
+//#region src/utils/requirements.ts
+const PACKAGE_MANAGER_VERSION_RANGES = {
+	bun: ">=1.2.14",
+	npm: ">=11.16.0",
+	pnpm: ">=10.26.0"
+};
+const PACKAGE_MANAGER_REASONS = {
+	bun: "generated Bun workspaces use dependency catalogs",
+	npm: "generated npm workspaces use the allowScripts install-script policy",
+	pnpm: "generated pnpm workspaces use catalogs and the allowBuilds policy"
+};
+const PACKAGE_MANAGER_UPGRADE_INSTRUCTIONS = {
+	bun: "Run `bun upgrade`.",
+	npm: "After updating Node.js, run `npm install --global npm@latest`.",
+	pnpm: "Run `pnpm self-update`, or install the latest pnpm globally."
+};
+const NODE_UPGRADE_INSTRUCTION = "Install the latest Node.js 24 LTS release from https://nodejs.org, then rerun the command.";
+function normalizeVersion(value) {
+	const trimmed = value.trim();
+	return clean(trimmed) ?? coerce(trimmed)?.version ?? null;
+}
+function addNodeRequirement(requirements, range, reason) {
+	requirements.push({
+		tool: "node",
+		range,
+		reason
+	});
+}
+function getNodeToolingRequirements(config) {
+	const requirements = [];
+	for (const frontend of config.frontend) switch (frontend) {
+		case "astro":
+			addNodeRequirement(requirements, ">=22.12.0", "Astro 7");
+			break;
+		case "nuxt":
+			addNodeRequirement(requirements, "^22.19.0 || ^24.11.0 || >=26.0.0", "Nuxt 4");
+			break;
+		case "solid":
+			addNodeRequirement(requirements, ">=24.0.0", "SolidStart 2");
+			break;
+		case "react-router":
+			addNodeRequirement(requirements, ">=22.22.0", "React Router 8");
+			break;
+		case "svelte":
+		case "tanstack-router":
+		case "tanstack-start":
+			addNodeRequirement(requirements, "^20.19.0 || >=22.12.0", "Vite 8");
+			break;
+		case "next":
+			addNodeRequirement(requirements, ">=20.9.0", "Next.js 16");
+			break;
+		case "native-bare":
+		case "native-uniwind":
+		case "native-unistyles":
+			addNodeRequirement(requirements, "^22.13.0 || ^24.3.0 || >=26.0.0", "React Native 0.86");
+			break;
+	}
+	if (![
+		"none",
+		"self",
+		"convex"
+	].includes(config.backend)) addNodeRequirement(requirements, "^22.18.0 || >=24.11.0", "the generated server build (tsdown)");
+	if (config.orm === "prisma") addNodeRequirement(requirements, "^20.19.0 || ^22.12.0 || >=24.0.0", "Prisma 7");
+	if (config.orm === "mongoose") addNodeRequirement(requirements, ">=20.19.0", "Mongoose 9 and MongoDB 7");
+	if (config.examples.includes("ai")) addNodeRequirement(requirements, ">=22.0.0", "AI SDK 7");
+	if (config.addons.includes("oxlint") || config.addons.includes("ultracite") && config.addonOptions?.ultracite?.linter === "oxlint") addNodeRequirement(requirements, "^20.19.0 || >=22.12.0", "Oxlint and Oxfmt");
+	if (config.addons.includes("husky")) addNodeRequirement(requirements, ">=22.22.1", "lint-staged 17");
+	if (config.addons.includes("vite-plus")) addNodeRequirement(requirements, "^20.19.0 || ^22.18.0 || >=24.11.0", "Vite+");
+	if (config.addons.includes("starlight")) addNodeRequirement(requirements, ">=22.12.0", "Starlight's Astro toolchain");
+	if (config.addons.includes("wxt")) addNodeRequirement(requirements, ">=22.0.0", "WXT");
+	if (config.webDeploy === "cloudflare" || config.serverDeploy === "cloudflare") addNodeRequirement(requirements, ">=22.0.0", "Wrangler 4");
+	return requirements;
+}
+function getLocalVersionRequirements(config, hostRuntime) {
+	const requirements = [{
+		tool: config.packageManager,
+		range: PACKAGE_MANAGER_VERSION_RANGES[config.packageManager],
+		reason: PACKAGE_MANAGER_REASONS[config.packageManager]
+	}];
+	if (hostRuntime === "node") addNodeRequirement(requirements, ">=22.0.0", "create-better-t-stack");
+	if (config.packageManager !== "bun") requirements.push(...getNodeToolingRequirements(config));
+	else if (config.runtime === "node") addNodeRequirement(requirements, ">=22.0.0", "the selected Node.js server runtime");
+	return requirements;
+}
+function formatRequirementError(requirement, rawVersion) {
+	const label = requirement.tool === "node" ? "Node.js" : requirement.tool;
+	if (!rawVersion) return `${label} is not available (required ${requirement.range} for ${requirement.reason}).`;
+	const version = normalizeVersion(rawVersion);
+	if (!version) return `Could not read the ${label} version from "${rawVersion}".`;
+	if (!satisfies(version, requirement.range, { includePrerelease: true })) return `${label} ${version} does not satisfy ${requirement.range} required by ${requirement.reason}.`;
+	return null;
+}
+function validateLocalToolVersions(config, versions, hostRuntime) {
+	const requirements = getLocalVersionRequirements(config, hostRuntime);
+	const failures = requirements.map((requirement) => formatRequirementError(requirement, versions[requirement.tool])).filter((failure) => failure !== null);
+	if (failures.length === 0) return Result.ok(void 0);
+	const upgradeInstructions = /* @__PURE__ */ new Set();
+	for (const requirement of requirements) {
+		if (!formatRequirementError(requirement, versions[requirement.tool])) continue;
+		if (requirement.tool === "node") upgradeInstructions.add(NODE_UPGRADE_INSTRUCTION);
+		else upgradeInstructions.add(PACKAGE_MANAGER_UPGRADE_INSTRUCTIONS[requirement.tool]);
+	}
+	return Result.err(new CLIError({ message: [
+		"Your local toolchain does not meet this stack's requirements:",
+		...failures.map((failure) => `- ${failure}`),
+		"",
+		...upgradeInstructions
+	].join("\n") }));
+}
+function getLocalToolRecommendations(config, versions) {
+	if (config.packageManager !== "bun") return [];
+	const rawVersion = versions.bun;
+	if (!rawVersion) return [];
+	const version = normalizeVersion(rawVersion);
+	if (!version || !satisfies(version, PACKAGE_MANAGER_VERSION_RANGES.bun, { includePrerelease: true }) || satisfies(version, ">=1.3.0", { includePrerelease: true })) return [];
+	return [`Bun ${version} meets the minimum requirement, but Bun 1.3 or newer is recommended. Run \`bun upgrade\`.`];
+}
+async function readToolVersion(tool) {
+	const result = await Result.tryPromise({
+		try: async () => {
+			const { stdout } = await execa(tool, ["--version"], {
+				cwd: os.tmpdir(),
+				stderr: "pipe"
+			});
+			return normalizeVersion(stdout);
+		},
+		catch: () => null
+	});
+	return result.isOk() ? result.value : null;
+}
+async function checkLocalRequirements(config) {
+	const hostRuntime = process.versions.bun ? "bun" : "node";
+	const versions = {};
+	const packageManagerVersion = await readToolVersion(config.packageManager);
+	if (packageManagerVersion) versions[config.packageManager] = packageManagerVersion;
+	if (getLocalVersionRequirements(config, hostRuntime).some((requirement) => requirement.tool === "node")) versions.node = hostRuntime === "node" ? process.versions.node : await readToolVersion("node") ?? void 0;
+	if (!shouldSkipExternalCommands()) {
+		const validationResult = validateLocalToolVersions(config, versions, hostRuntime);
+		if (validationResult.isErr()) return Result.err(validationResult.error);
+	}
+	return Result.ok({
+		packageManagerVersion: packageManagerVersion ?? "latest",
+		warnings: getLocalToolRecommendations(config, versions)
+	});
+}
+//#endregion
 //#region src/utils/add-package-deps.ts
 const addPackageDependency = async (opts) => {
 	const { dependencies = [], devDependencies = [], customDependencies = {}, customDevDependencies = {}, projectDir } = opts;
@@ -1873,7 +2079,7 @@ function addNuxtEvlogSetup(content, serviceName) {
 function addSvelteViteEvlogSetup(content, serviceName) {
 	let nextContent = prependMissingImports(content, ["import evlog from \"evlog/vite\";"]);
 	if (nextContent.includes("evlog({")) return nextContent;
-	return nextContent.replace("plugins: [tailwindcss(), sveltekit()],", `plugins: [\n    tailwindcss(),\n    sveltekit(),\n    evlog({ service: "${serviceName}" }),\n  ],`);
+	return nextContent.replace("sveltekit(),", `sveltekit(),\n    evlog({ service: "${serviceName}" }),`);
 }
 function getSvelteEvlogHooksCall(fsDrain) {
 	return fsDrain ? `createEvlogHooks({ drain: ${SVELTE_DEV_FS_DRAIN_EXPRESSION} })` : "createEvlogHooks()";
@@ -2104,18 +2310,23 @@ export default defineNitroPlugin((nitroApp) => {
 `;
 }
 function getNuxtEvlogAuthMiddlewareFile(config) {
-	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+	if (usesCreateAuthFactory(config)) {
+		const usesCloudflareRequestEnv = config.backend === "self" && config.webDeploy === "cloudflare";
+		const authExpression = usesCloudflareRequestEnv ? "createAuth((event.context.cloudflare as { env: CloudflareEnv }).env)" : getAuthExpression(config);
+		return `${getAuthImportLine(config)}
+${usesCloudflareRequestEnv ? `import type { CloudflareEnv } from "@${config.projectName}/env/server";\n` : ""}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 
 export default defineEventHandler(async (event) => {
   if (!event.context.log) return;
-  const identify = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+  const identify = createAuthMiddleware(${authExpression} as BetterAuthInstance, {
     exclude: ["/api/auth/**"],
     maskEmail: true,
   });
   await identify(event.context.log, event.headers, event.path);
 });
 `;
+	}
 	return `${getAuthImportLine(config)}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 
@@ -2360,7 +2571,7 @@ async function navigableGroup(prompts, opts) {
 				continue;
 			}
 			if (isCancel$1(result)) {
-				if (typeof opts?.onCancel === "function") {
+				if (opts?.onCancel) {
 					results[name] = "canceled";
 					opts.onCancel({ results });
 				}
@@ -2383,11 +2594,6 @@ async function navigableGroup(prompts, opts) {
 	return results;
 }
 //#endregion
-//#region src/utils/external-commands.ts
-function shouldSkipExternalCommands() {
-	return process.env.BTS_SKIP_EXTERNAL_COMMANDS === "1" || process.env.BTS_TEST_MODE === "1";
-}
-//#endregion
 //#region src/utils/package-runner.ts
 function splitCommandArgs(commandWithArgs) {
 	const args = [];
@@ -4007,21 +4213,21 @@ const DEFAULT_EDITORS = ["vscode"];
 const DEFAULT_AGENTS = ["universal"];
 const DEFAULT_HOOKS = [];
 function getFrameworksFromFrontend(frontend) {
-	const frameworkMap = {
-		"tanstack-router": ["react", "tanstack"],
-		"react-router": ["react", "remix"],
-		"tanstack-start": ["react", "tanstack"],
-		next: ["react", "next"],
-		nuxt: ["vue"],
-		"native-bare": ["react"],
-		"native-uniwind": ["react"],
-		"native-unistyles": ["react"],
-		svelte: ["svelte"],
-		solid: ["solid"],
-		astro: ["astro"]
-	};
+	const frameworkMap = /* @__PURE__ */ new Map([
+		["tanstack-router", ["react", "tanstack"]],
+		["react-router", ["react", "remix"]],
+		["tanstack-start", ["react", "tanstack"]],
+		["next", ["react", "next"]],
+		["nuxt", ["vue"]],
+		["native-bare", ["react"]],
+		["native-uniwind", ["react"]],
+		["native-unistyles", ["react"]],
+		["svelte", ["svelte"]],
+		["solid", ["solid"]],
+		["astro", ["astro"]]
+	]);
 	const frameworks = /* @__PURE__ */ new Set();
-	for (const f of frontend) for (const framework of frameworkMap[f] ?? []) frameworks.add(framework);
+	for (const f of frontend) for (const framework of frameworkMap.get(f) ?? []) frameworks.add(framework);
 	return Array.from(frameworks);
 }
 function buildUltraciteInitArgs({ packageManager, linter, frameworks, editors, agents, hooks, gitHooks }) {
@@ -4445,16 +4651,23 @@ const TASK_RUNNER_ADDONS = [
 ];
 function mergeAddonOptions(existingAddonOptions, nextAddonOptions) {
 	if (!existingAddonOptions && !nextAddonOptions) return;
-	const mergedAddonOptions = { ...existingAddonOptions };
-	if (nextAddonOptions) for (const addonKey of Object.keys(nextAddonOptions)) {
-		const existingOptionsForAddon = existingAddonOptions?.[addonKey];
-		const nextOptionsForAddon = nextAddonOptions[addonKey];
-		mergedAddonOptions[addonKey] = existingOptionsForAddon && nextOptionsForAddon ? {
-			...existingOptionsForAddon,
-			...nextOptionsForAddon
-		} : nextOptionsForAddon;
-	}
-	return Object.keys(mergedAddonOptions).length > 0 ? mergedAddonOptions : void 0;
+	const mergeOption = (existing, next) => {
+		if (!existing) return next;
+		if (!next) return existing;
+		return {
+			...existing,
+			...next
+		};
+	};
+	const mergedAddonOptions = {
+		wxt: mergeOption(existingAddonOptions?.wxt, nextAddonOptions?.wxt),
+		fumadocs: mergeOption(existingAddonOptions?.fumadocs, nextAddonOptions?.fumadocs),
+		opentui: mergeOption(existingAddonOptions?.opentui, nextAddonOptions?.opentui),
+		mcp: mergeOption(existingAddonOptions?.mcp, nextAddonOptions?.mcp),
+		skills: mergeOption(existingAddonOptions?.skills, nextAddonOptions?.skills),
+		ultracite: mergeOption(existingAddonOptions?.ultracite, nextAddonOptions?.ultracite)
+	};
+	return Object.values(mergedAddonOptions).some(Boolean) ? mergedAddonOptions : void 0;
 }
 function getSetupAddons(addonsToAdd, updatedAddons) {
 	const setupAddons = new Set(addonsToAdd);
@@ -4536,11 +4749,11 @@ async function addHandlerInternal(input) {
 	else {
 		const promptResult = await Result.tryPromise({
 			try: () => getAddonsToAdd(existingConfig),
-			catch: (e) => {
-				if (UserCancelledError.is(e)) return e;
+			catch: (cause) => {
+				if (UserCancelledError.is(cause)) return cause;
 				return new CLIError({
-					message: e instanceof Error ? e.message : String(e),
-					cause: e
+					message: cause instanceof Error ? cause.message : String(cause),
+					cause
 				});
 			}
 		});
@@ -4587,6 +4800,9 @@ async function addHandlerInternal(input) {
 		...config,
 		addons: updatedAddons
 	};
+	const requirementsResult = await checkLocalRequirements(updatedConfig);
+	if (requirementsResult.isErr()) return Result.err(requirementsResult.error);
+	if (!isSilent()) for (const warning of requirementsResult.value.warnings) log.warn(pc.yellow(warning));
 	if (!isSilent()) log.info(pc.dim("Preparing addon files…"));
 	const vfs = new VirtualFileSystem();
 	for (const pkgPath of ADD_PACKAGE_JSON_PATHS) {
@@ -4639,11 +4855,11 @@ async function addHandlerInternal(input) {
 			...config,
 			addons: getSetupAddons(addonsToAdd, updatedAddons)
 		}),
-		catch: (e) => {
-			if (UserCancelledError.is(e)) return e;
+		catch: (cause) => {
+			if (UserCancelledError.is(cause)) return cause;
 			return new CLIError({
-				message: e instanceof Error ? e.message : String(e),
-				cause: e
+				message: cause instanceof Error ? cause.message : String(cause),
+				cause
 			});
 		}
 	});
@@ -4761,6 +4977,7 @@ const FULLSTACK_FRONTENDS = [
 	"tanstack-start",
 	"nuxt",
 	"svelte",
+	"solid",
 	"astro"
 ];
 async function getBackendFrameworkChoice(backendFramework, frontends, previousValue) {
@@ -5198,8 +5415,8 @@ function validateDatabaseSetup(config, providedFlags) {
 		const validation = setupValidations[dbSetup];
 		if (dbSetup === "planetscale") {
 			if (database !== "postgres" && database !== "mysql") return validationErr(validation.errorMessage);
-		} else if (validation.database && database !== validation.database) return validationErr(validation.errorMessage);
-		if (validation.runtime && runtime !== validation.runtime) return validationErr(validation.errorMessage);
+		} else if ("database" in validation && validation.database && database !== validation.database) return validationErr(validation.errorMessage);
+		if ("runtime" in validation && validation.runtime && runtime !== validation.runtime) return validationErr(validation.errorMessage);
 		if (dbSetup === "d1") {
 			const isWorkersTarget = hasResolvedWorkersD1Target(config);
 			const isSelfCloudflareTarget = hasResolvedSelfCloudflareD1Target(config);
@@ -5307,7 +5524,11 @@ function validateFullConfig(config, providedFlags, options) {
 		yield* validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
 		yield* validateDockerServerDeploy(config.serverDeploy, config.backend, config.runtime);
 		yield* validateVercelServerDeploy(config.serverDeploy, config.backend, config.runtime);
+		yield* validatePrismaServerDeploy(config.serverDeploy, config.backend, config.runtime);
+		yield* validatePrismaWebDeploy(config.webDeploy, config.frontend);
+		yield* validateCloudflareWebDeployKnownIssues(config);
 		yield* validateDockerWebDeployDesktopAddons(config.webDeploy, config.addons, config.frontend, config.backend, config.auth);
+		yield* validatePrismaWebDeployDesktopAddons(config.webDeploy, config.addons, config.frontend);
 		yield* validateSelfBackendCompatibility(providedFlags, options, config);
 		yield* validateWorkersCompatibility(providedFlags, options, config);
 		if (config.runtime === "workers" && config.serverDeploy === "none") yield* validationErr("Cloudflare Workers runtime requires a server deployment. Please choose 'cloudflare' for --server-deploy.");
@@ -5464,9 +5685,13 @@ function getDeploymentDisplay$1(deployment) {
 		label: "Docker",
 		hint: "Self-host with a Dockerfile and docker-compose.yml"
 	};
+	if (deployment === "prisma") return {
+		label: "Prisma",
+		hint: "Deploy with Prisma using Alchemy"
+	};
 	if (deployment === "vercel") return {
-		label: "Vercel",
-		hint: "Deploy to Vercel with Services"
+		label: "Vercel (experimental)",
+		hint: "Deploy to Vercel with Services; not fully tested"
 	};
 	return {
 		label: deployment,
@@ -5479,6 +5704,7 @@ async function getServerDeploymentChoice(deployment, runtime, backend, _webDeplo
 	if (runtime === "workers") return "cloudflare";
 	if (runtime !== "bun" && runtime !== "node") return "none";
 	const options = [
+		"prisma",
 		"docker",
 		"vercel",
 		"none"
@@ -5515,21 +5741,33 @@ function getDeploymentDisplay(deployment) {
 		label: "Docker",
 		hint: "Self-host with a Dockerfile and docker-compose.yml"
 	};
+	if (deployment === "prisma") return {
+		label: "Prisma",
+		hint: "Deploy with Prisma using Alchemy"
+	};
 	if (deployment === "vercel") return {
-		label: "Vercel",
-		hint: "Deploy to Vercel with Services"
+		label: "Vercel (experimental)",
+		hint: "Deploy to Vercel with Services; not fully tested"
 	};
 	return {
 		label: deployment,
 		hint: `Add ${deployment} deployment`
 	};
 }
-async function getDeploymentChoice(deployment, _runtime, backend, frontend = [], dbSetup, previousValue) {
+async function getDeploymentChoice(deployment, _runtime, backend, frontend = [], dbSetup, database, orm, addons = [], previousValue) {
 	if (deployment !== void 0) return deployment;
 	if (!hasWebFrontend(frontend)) return "none";
 	if (backend === "self" && dbSetup === "d1") return "cloudflare";
+	const supportsPrismaCompute = supportsPrismaWebDeploy(frontend);
 	const options = [
-		"cloudflare",
+		...validateCloudflareWebDeployKnownIssues({
+			webDeploy: "cloudflare",
+			frontend,
+			dbSetup,
+			database,
+			orm
+		}).isOk() ? ["cloudflare"] : [],
+		...supportsPrismaCompute ? ["prisma"] : [],
 		"docker",
 		"vercel",
 		"none"
@@ -5587,7 +5825,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath, option
 		payments: ({ results, previousAnswer }) => getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend, previousAnswer),
 		addons: ({ results, previousAnswer }) => getAddonsChoice(flags.addons, results.frontend, results.auth, results.backend, results.runtime, previousAnswer),
 		examples: ({ results, previousAnswer }) => getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api, previousAnswer),
-		webDeploy: ({ results, previousAnswer }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend, results.dbSetup, previousAnswer),
+		webDeploy: ({ results, previousAnswer }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend, results.dbSetup, results.database, results.orm, results.addons, previousAnswer),
 		serverDeploy: ({ results, previousAnswer }) => getServerDeploymentChoice(flags.serverDeploy, results.runtime, results.backend, results.webDeploy, previousAnswer),
 		git: ({ previousAnswer }) => getGitChoice(flags.git, previousAnswer),
 		packageManager: ({ previousAnswer }) => getPackageManagerChoice(flags.packageManager, previousAnswer),
@@ -5661,6 +5899,11 @@ async function gatherConfig(flags, projectName, projectDir, relativePath, option
 	};
 }
 //#endregion
+//#region src/utils/fs-error.ts
+function isMissingPathError(cause) {
+	return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+//#endregion
 //#region src/prompts/project-name.ts
 function isPathWithinCwd$1(targetPath) {
 	const resolved = path.resolve(targetPath);
@@ -5690,7 +5933,7 @@ async function getProjectName(initialName) {
 		try {
 			stats = await fs.lstat(defaultPath);
 		} catch (error) {
-			if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") break;
+			if (isMissingPathError(error)) break;
 			throw error;
 		}
 		if (stats.isDirectory() && (await fs.readdir(defaultPath)).length === 0) break;
@@ -5744,16 +5987,33 @@ async function sendConvexEvent(payload) {
 		catch: () => void 0
 	});
 }
+function buildAnalyticsEvent(config) {
+	return types_exports.AnalyticsEventSchema.parse({
+		database: config.database,
+		orm: config.orm,
+		backend: config.backend,
+		runtime: config.runtime,
+		frontend: config.frontend,
+		addons: config.addons,
+		examples: config.examples,
+		auth: config.auth,
+		payments: config.payments,
+		git: config.git,
+		packageManager: config.packageManager,
+		install: config.install,
+		dbSetup: config.dbSetup,
+		api: config.api,
+		webDeploy: config.webDeploy,
+		serverDeploy: config.serverDeploy,
+		cli_version: getLatestCLIVersion(),
+		node_version: process.version,
+		platform: process.platform
+	});
+}
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
-	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath, ...safeConfig } = config;
 	await Result.tryPromise({
-		try: () => sendConvexEvent({
-			...safeConfig,
-			cli_version: getLatestCLIVersion(),
-			node_version: typeof process !== "undefined" ? process.version : "",
-			platform: typeof process !== "undefined" ? process.platform : ""
-		}),
+		try: () => sendConvexEvent(buildAnalyticsEvent(config)),
 		catch: () => void 0
 	});
 }
@@ -5895,7 +6155,7 @@ async function validateSafeProjectDirectoryPath(finalPathInput) {
 				try {
 					stats = await fs.lstat(candidatePath);
 				} catch (error) {
-					if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") break;
+					if (isMissingPathError(error)) break;
 					throw error;
 				}
 				if (stats.isSymbolicLink()) throw new CLIError({ message: `Project path "${finalPathInput}" passes through symbolic link "${path.relative(cwd, candidatePath)}". Choose a real directory within the current working directory.` });
@@ -5919,7 +6179,7 @@ async function inspectProjectPath(targetPath) {
 			try {
 				stats = await fs.lstat(targetPath);
 			} catch (error) {
-				if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return "missing";
+				if (isMissingPathError(error)) return "missing";
 				throw error;
 			}
 			if (stats.isSymbolicLink()) return "symbolic-link";
@@ -6248,9 +6508,10 @@ async function setupCloudflareD1(config) {
 			const targetApp = backend === "self" ? "apps/web" : "apps/server";
 			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 				key: "DATABASE_URL",
-				value: `file:${path.join(projectDir, targetApp, "local.db")}`,
+				value: "file:./local.db",
 				condition: true
 			}]);
+			await fs.ensureFile(path.join(projectDir, "packages/db/local.db"));
 			await addPackageDependency({
 				dependencies: ["@prisma/adapter-d1"],
 				projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
@@ -6336,7 +6597,7 @@ function mergeResolvedDbSetupOptions(dbSetup, dbSetupOptions, cliOptions = {}) {
 	if (!dbSetupOptions && !resolvedMode) return;
 	return {
 		...dbSetupOptions,
-		...resolvedMode ? { mode: resolvedMode } : {}
+		mode: resolvedMode
 	};
 }
 //#endregion
@@ -7510,6 +7771,7 @@ async function setupDatabase(config, cliInput) {
 	}
 	const dbPackageDir = path.join(projectDir, "packages/db");
 	if (!await fs.pathExists(dbPackageDir)) return;
+	if (usesAlchemyManagedDatabase(config)) return;
 	async function runSetup(setupFn) {
 		const result = await setupFn();
 		if (result.isErr()) {
@@ -7653,7 +7915,7 @@ async function displayPostInstallInstructions(config) {
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
 	const clerkInstructions = config.auth === "clerk" ? getClerkInstructions(frontend || [], backend, api) : "";
 	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend);
-	const hasWeb = frontend?.some((f) => types_exports.desktopWebFrontends.includes(f));
+	const hasWeb = frontend?.some((f) => types_exports.webFrontends.includes(f));
 	const hasNative = frontend?.includes("native-bare") || frontend?.includes("native-uniwind") || frontend?.includes("native-unistyles");
 	const hasReactRouter = frontend?.includes("react-router");
 	const hasSvelte = frontend?.includes("svelte");
@@ -7667,6 +7929,13 @@ async function displayPostInstallInstructions(config) {
 	let stepCounter = 2;
 	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
 	if (database === "sqlite" && dbSetup !== "d1") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (optional - starts local SQLite database)")}\n`;
+	const hasAlchemyD1 = dbSetup === "d1" && (serverDeploy === "cloudflare" || isBackendSelf && webDeploy === "cloudflare");
+	const hasWranglerLocalD1 = (0, types_exports.getLocalD1Owner)(config) === "wrangler";
+	if (hasAlchemyD1 && orm !== "none") {
+		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:generate\n`;
+		if (orm === "prisma") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:migrate\n`;
+		if (hasWranglerLocalD1) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:migrate:local\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`;
@@ -7674,10 +7943,7 @@ async function displayPostInstallInstructions(config) {
 	} 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`;
-			output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
-		}
+		if (runtime === "workers") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
 	}
 	const hasStandaloneBackend = backend !== "none";
 	if (hasWeb || hasStandaloneBackend || addons?.includes("starlight") || addons?.includes("fumadocs")) {
@@ -7776,27 +8042,22 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 	const notes = [];
 	const commands = [];
 	const isD1Alchemy = dbSetup === "d1" && (serverDeploy === "cloudflare" || backend === "self" && webDeploy === "cloudflare");
+	const isAlchemyManagedDatabase = (0, types_exports.usesAlchemyManagedDatabase)({
+		backend,
+		dbSetup,
+		webDeploy,
+		serverDeploy
+	});
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
 		if (dockerStatus.message) notes.push(dockerStatus.message);
 	}
-	if (isD1Alchemy) {
-		if (orm === "drizzle") commands.push({
-			label: "Generate migrations",
-			command: `${runCmd} db:generate`
-		});
-		else if (orm === "prisma") {
-			commands.push({
-				label: "Generate client",
-				command: `${runCmd} db:generate`
-			});
-			commands.push({
-				label: "Apply migrations",
-				command: `${runCmd} db:migrate`
-			});
-		}
+	if (isAlchemyManagedDatabase) {
+		const provider = dbSetup === "prisma-postgres" ? "Prisma Postgres" : dbSetup === "planetscale" ? "PlanetScale" : "Neon";
+		notes.push(`${pc.cyan("INFO:")} Alchemy provisions ${provider}, injects its connection credentials, and applies checked-in migrations during deploy.`);
+		if (dbSetup === "planetscale") notes.push(`${pc.yellow("NOTE:")} The generated PlanetScale database uses the PS_DEV size, which may incur usage charges.`);
 	}
-	if (dbSetup === "planetscale") {
+	if (dbSetup === "planetscale" && !isAlchemyManagedDatabase) {
 		if (database === "mysql" && orm === "drizzle") notes.push(`${pc.yellow("NOTE:")} Enable foreign key constraints in PlanetScale database settings`);
 		if (database === "mysql" && orm === "prisma") notes.push(`${pc.yellow("NOTE:")} How to handle Prisma migrations with PlanetScale:\n   https://github.com/prisma/prisma/issues/7292`);
 	}
@@ -7807,7 +8068,11 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 			label: "Start database",
 			command: `${runCmd} db:start`
 		});
-		if (!isD1Alchemy) {
+		if (isAlchemyManagedDatabase) commands.push({
+			label: "Generate client",
+			command: `${runCmd} db:generate`
+		});
+		else if (!isD1Alchemy) {
 			commands.push({
 				label: "Generate client",
 				command: `${runCmd} db:generate`
@@ -7817,7 +8082,7 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 				command: `${runCmd} db:push`
 			});
 		}
-		if (!isD1Alchemy) commands.push({
+		if (!isD1Alchemy && !isAlchemyManagedDatabase) commands.push({
 			label: "Open studio",
 			command: `${runCmd} db:studio`
 		});
@@ -7826,11 +8091,15 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 			label: "Start database",
 			command: `${runCmd} db:start`
 		});
-		if (!isD1Alchemy) commands.push({
+		if (isAlchemyManagedDatabase) commands.push({
+			label: "Generate migrations",
+			command: `${runCmd} db:generate`
+		});
+		else if (!isD1Alchemy) commands.push({
 			label: "Apply schema",
 			command: `${runCmd} db:push`
 		});
-		if (!isD1Alchemy) commands.push({
+		if (!isD1Alchemy && !isAlchemyManagedDatabase) commands.push({
 			label: "Open studio",
 			command: `${runCmd} db:studio`
 		});
@@ -7944,19 +8213,20 @@ function getPolarInstructions(backend, packageManager) {
 function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
 	const isBackendSelf = backend === "self";
-	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare" && !isBackendSelf) {
-		const cfDeploy = serverDeploy === "vercel" ? "deploy:web" : "deploy";
-		instructions.push(`${pc.bold("Deploy web with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} ${cfDeploy}`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
-	} else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) {
-		const cfDeploy = webDeploy === "vercel" ? "deploy:server" : "deploy";
-		instructions.push(`${pc.bold("Deploy server with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} ${cfDeploy}`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
-	} else if (webDeploy === "cloudflare" && (serverDeploy === "cloudflare" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	const hasAlchemyWeb = (0, types_exports.isAlchemyDeployTarget)(webDeploy);
+	const hasAlchemyServer = (0, types_exports.isAlchemyDeployTarget)(serverDeploy);
+	const alchemyExec = runCmd === "npm run" ? "npx" : runCmd === "pnpm run" ? "pnpm exec" : "bunx";
+	if (hasAlchemyWeb || hasAlchemyServer) {
+		const targetParts = [...hasAlchemyWeb ? [`web on ${webDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : [], ...hasAlchemyServer && !isBackendSelf ? [`server on ${serverDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : []];
+		const deployScript = webDeploy === "vercel" ? "deploy:server" : serverDeploy === "vercel" ? "deploy:web" : "deploy";
+		instructions.push(`${pc.bold(`Deploy with Alchemy (${targetParts.join(" + ")}):`)}\n${pc.cyan("•")} Configure provider login: ${`cd packages/infra && ${alchemyExec} alchemy login --configure`}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} ${deployScript}`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	}
 	if (webDeploy === "docker" || serverDeploy === "docker") {
 		const dockerTargets = webDeploy === "docker" && serverDeploy === "docker" ? "web + server" : webDeploy === "docker" ? "web" : "server";
 		instructions.push(`${pc.bold(`Deploy ${dockerTargets} with Docker Compose:`)}\n${pc.cyan("•")} Start: ${`${runCmd} docker:up`}\n${pc.cyan("•")} Logs: ${`${runCmd} docker:logs`}\n${pc.cyan("•")} Stop: ${`${runCmd} docker:down`}\n${pc.cyan("•")} Config: docker-compose.yml`);
 	}
 	if (webDeploy === "vercel" || serverDeploy === "vercel") {
-		const mixedWithCloudflare = webDeploy === "cloudflare" || serverDeploy === "cloudflare";
+		const mixedWithCloudflare = hasAlchemyWeb || hasAlchemyServer;
 		const vercelSetupScript = "deploy:setup";
 		const vercelEnvScript = "env:production";
 		const vercelDeployScript = mixedWithCloudflare ? webDeploy === "vercel" ? "deploy:web:prod" : "deploy:server:prod" : "deploy:prod";
@@ -7971,7 +8241,7 @@ function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend)
 * Creates a new project with the given configuration.
 * Returns a Result with the project directory path on success, or an error on failure.
 */
-async function createProject(options, cliInput = {}) {
+async function createProject(options, cliInput) {
 	return Result.gen(async function* () {
 		const projectDir = options.projectDir;
 		const isConvex = options.backend === "convex";
@@ -7997,7 +8267,7 @@ async function createProject(options, cliInput = {}) {
 			message: e.message,
 			cause: e
 		}))));
-		yield* Result.await(setPackageManagerVersion(projectDir, options.packageManager));
+		yield* Result.await(setPackageManagerVersion(projectDir, options.packageManager, cliInput.packageManagerVersion));
 		if (!isConvex && options.database !== "none") yield* Result.await(Result.tryPromise({
 			try: () => setupDatabase(options, cliInput),
 			catch: (e) => new ProjectCreationError({
@@ -8028,21 +8298,13 @@ async function createProject(options, cliInput = {}) {
 		return Result.ok(projectDir);
 	});
 }
-async function setPackageManagerVersion(projectDir, packageManager) {
+async function setPackageManagerVersion(projectDir, packageManager, version) {
 	const pkgJsonPath = path.join(projectDir, "package.json");
 	if (!await fs.pathExists(pkgJsonPath)) return Result.ok(void 0);
-	const versionResult = await Result.tryPromise({
-		try: async () => {
-			const { stdout } = await $({ cwd: os.tmpdir() })`${packageManager} -v`;
-			return stdout.trim();
-		},
-		catch: () => null
-	});
 	return Result.tryPromise({
 		try: async () => {
 			const pkgJson = await fs.readJson(pkgJsonPath);
-			if (versionResult.isOk() && versionResult.value) pkgJson.packageManager = `${packageManager}@${versionResult.value}`;
-			else delete pkgJson.packageManager;
+			pkgJson.packageManager = `${packageManager}@${version}`;
 			await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 		},
 		catch: (e) => new ProjectCreationError({
@@ -8134,11 +8396,11 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			currentPathInput = defaultName;
 		} else currentPathInput = yield* Result.await(Result.tryPromise({
 			try: async () => getProjectName(input.projectName),
-			catch: (e) => {
-				if (e instanceof UserCancelledError) return e;
+			catch: (cause) => {
+				if (cause instanceof UserCancelledError) return cause;
 				return new CLIError({
-					message: e instanceof Error ? e.message : String(e),
-					cause: e
+					message: cause instanceof Error ? cause.message : String(cause),
+					cause
 				});
 			}
 		}));
@@ -8163,8 +8425,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 				const templateName = input.template.toUpperCase();
 				const templateDescription = getTemplateDescription(input.template);
 				if (!isSilent()) log.info(`${pc.dim("Template")} ${pc.bold(pc.cyan(templateName))}\n${pc.dim(templateDescription)}`);
-				const userOverrides = {};
-				for (const [key, value] of Object.entries(originalInput)) if (value !== void 0) userOverrides[key] = value;
+				const userOverrides = Object.fromEntries(Object.entries(originalInput).filter(([, value]) => value !== void 0));
 				cliInput = {
 					...templateConfig,
 					...userOverrides,
@@ -8206,11 +8467,11 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			if (!isSilent() && !isTemplateSetup && Object.keys(otherFlags).length > 0) log.info(pc.dim("Command-line options applied."));
 			config = yield* Result.await(Result.tryPromise({
 				try: async () => gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput, { skipCompatibilityChecks: cliInput.yolo }),
-				catch: (e) => {
-					if (e instanceof UserCancelledError) return e;
+				catch: (cause) => {
+					if (cause instanceof UserCancelledError) return cause;
 					return new CLIError({
-						message: e instanceof Error ? e.message : String(e),
-						cause: e
+						message: cause instanceof Error ? cause.message : String(cause),
+						cause
 					});
 				}
 			}));
@@ -8230,13 +8491,15 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 				cause: resolvedConfigValidationResult.error
 			});
 		}
+		const localRequirements = yield* Result.await(checkLocalRequirements(config));
+		if (!isSilent()) for (const warning of localRequirements.warnings) log.warn(pc.yellow(warning));
 		if (!input.dryRun) yield* Result.await(Result.tryPromise({
 			try: async () => setupProjectDirectory(finalPathInput, shouldClearDirectory),
-			catch: (e) => {
-				if (e instanceof UserCancelledError) return e;
+			catch: (cause) => {
+				if (cause instanceof UserCancelledError) return cause;
 				return new CLIError({
-					message: e instanceof Error ? e.message : String(e),
-					cause: e
+					message: cause instanceof Error ? cause.message : String(cause),
+					cause
 				});
 			}
 		}));
@@ -8266,7 +8529,8 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		}
 		yield* Result.await(createProject(config, {
 			manualDb: cliInput.manualDb ?? input.manualDb,
-			dbSetupOptions: effectiveDbSetupOptions
+			dbSetupOptions: effectiveDbSetupOptions,
+			packageManagerVersion: localRequirements.packageManagerVersion
 		}));
 		await trackProjectCreation(config, input.disableAnalytics);
 		const historyResult = await addToHistory(config, reproducibleCommand);
@@ -8322,12 +8586,12 @@ async function handleDirectoryConflictResult(currentPathInput, strategy) {
 	if (strategy) return handleDirectoryConflictProgrammatically(currentPathInput, strategy);
 	return Result.tryPromise({
 		try: async () => handleDirectoryConflict(currentPathInput),
-		catch: (e) => {
-			if (e instanceof UserCancelledError) return e;
-			if (e instanceof CLIError) return e;
+		catch: (cause) => {
+			if (cause instanceof UserCancelledError) return cause;
+			if (cause instanceof CLIError) return cause;
 			return new CLIError({
-				message: e instanceof Error ? e.message : String(e),
-				cause: e
+				message: cause instanceof Error ? cause.message : String(cause),
+				cause
 			});
 		}
 	});
@@ -8532,10 +8796,10 @@ function formatInputValidationError(label, error) {
 * ```
 */
 async function create(projectName, options) {
-	const rawInput = options === void 0 || typeof options === "object" && options !== null ? {
+	const rawInput = {
 		...options,
 		projectName
-	} : options;
+	};
 	const parsedInput = types_exports.CreateInputSchema.safeParse(rawInput);
 	if (!parsedInput.success) return Result.err(new CLIError({
 		message: formatInputValidationError("create", parsedInput.error),
@@ -8554,14 +8818,14 @@ async function create(projectName, options) {
 			if (result.isErr()) throw result.error;
 			return result.value;
 		},
-		catch: (e) => {
-			if (UserCancelledError.is(e)) return e;
-			if (CLIError.is(e)) return e;
-			if (DirectoryConflictError.is(e)) return e;
-			if (ProjectCreationError.is(e)) return e;
+		catch: (cause) => {
+			if (UserCancelledError.is(cause)) return cause;
+			if (CLIError.is(cause)) return cause;
+			if (DirectoryConflictError.is(cause)) return cause;
+			if (ProjectCreationError.is(cause)) return cause;
 			return new CLIError({
-				message: e instanceof Error ? e.message : String(e),
-				cause: e
+				message: cause instanceof Error ? cause.message : String(cause),
+				cause
 			});
 		}
 	});
@@ -8629,21 +8893,7 @@ async function createVirtual(options) {
 		webDeploy: virtualOptions.webDeploy || "none",
 		serverDeploy: virtualOptions.serverDeploy || "none"
 	};
-	const validationResult = validateConfigCompatibility(config, /* @__PURE__ */ new Set([
-		"database",
-		"orm",
-		"backend",
-		"runtime",
-		"frontend",
-		"addons",
-		"examples",
-		"auth",
-		"dbSetup",
-		"payments",
-		"api",
-		"webDeploy",
-		"serverDeploy"
-	]), config);
+	const validationResult = validateResolvedConfigCompatibility(config);
 	if (validationResult.isErr()) return Result.err(new GeneratorError({
 		message: validationResult.error.message,
 		phase: "validation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-t-stack",
-  "version": "3.38.2",
+  "version": "3.39.2",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -69,8 +69,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-t-stack/template-generator": "^3.38.2",
-    "@better-t-stack/types": "^3.38.2",
+    "@better-t-stack/template-generator": "^3.39.2",
+    "@better-t-stack/types": "^3.39.2",
     "@clack/core": "^1.4.3",
     "@clack/prompts": "^1.7.0",
     "@modelcontextprotocol/sdk": "1.30.0",
@@ -83,8 +83,9 @@
     "gradient-string": "^3.0.0",
     "handlebars": "^4.7.9",
     "jsonc-parser": "^3.3.1",
-    "oxfmt": "^0.61.0",
+    "oxfmt": "^0.63.0",
     "picocolors": "^1.1.1",
+    "semver": "^7.8.5",
     "tinyglobby": "^0.2.17",
     "trpc-cli": "^0.16.0",
     "ts-morph": "^28.0.0",
@@ -95,8 +96,12 @@
     "@types/bun": "^1.3.14",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^26.1.2",
+    "@types/semver": "^7.8.0",
     "publint": "^0.3.22",
     "tsdown": "^0.22.14",
     "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   }
 }