create-better-t-stack 3.12.7 → 3.13.0

package/dist/{src-DNjxspj9.mjs → src-DyVk_RBS.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as __reExport } from "./chunk-Dt3mZKp0.mjs";
-import { autocompleteMultiselect, cancel, confirm, group, groupMultiselect, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import { autocompleteMultiselect, cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
 import { createCli } from "trpc-cli";
@@ -9,6 +9,8 @@ import consola, { consola as consola$1 } from "consola";
 import fs from "fs-extra";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
+import { AsyncLocalStorage } from "node:async_hooks";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
@@ -215,18 +217,30 @@ const WEB_FRAMEWORKS = [
 
 //#endregion
 //#region src/utils/errors.ts
+var UserCancelledError = class extends Error {
+	constructor(message = "Operation cancelled") {
+		super(message);
+		this.name = "UserCancelledError";
+	}
+};
+var CLIError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CLIError";
+	}
+};
 function exitWithError(message) {
 	consola.error(pc.red(message));
-	throw new Error(message);
+	throw new CLIError(message);
 }
 function exitCancelled(message = "Operation cancelled") {
 	cancel(pc.red(message));
-	throw new Error(message);
+	throw new UserCancelledError(message);
 }
 function handleError(error, fallbackMessage) {
 	const message = error instanceof Error ? error.message : fallbackMessage || String(error);
 	consola.error(pc.red(message));
-	throw new Error(message);
+	throw error instanceof Error ? error : new Error(message);
 }
 
 //#endregion
@@ -362,6 +376,295 @@ function validateExamplesCompatibility(examples, backend, database, frontend, ap
 	}
 }
 
+//#endregion
+//#region src/utils/context.ts
+const cliStorage = new AsyncLocalStorage();
+function defaultContext() {
+	return {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: false,
+		verbose: false
+	};
+}
+function getContext() {
+	const ctx = cliStorage.getStore();
+	if (!ctx) return defaultContext();
+	return ctx;
+}
+function tryGetContext() {
+	return cliStorage.getStore();
+}
+function isSilent() {
+	return getContext().silent;
+}
+function isFirstPrompt() {
+	return getContext().navigation.isFirstPrompt;
+}
+function didLastPromptShowUI() {
+	return getContext().navigation.lastPromptShownUI;
+}
+function setIsFirstPrompt$1(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.isFirstPrompt = value;
+}
+function setLastPromptShownUI(value) {
+	const ctx = tryGetContext();
+	if (ctx) ctx.navigation.lastPromptShownUI = value;
+}
+async function runWithContextAsync(options, fn) {
+	const ctx = {
+		navigation: {
+			isFirstPrompt: false,
+			lastPromptShownUI: false
+		},
+		silent: options.silent ?? false,
+		verbose: options.verbose ?? false,
+		projectDir: options.projectDir,
+		projectName: options.projectName,
+		packageManager: options.packageManager
+	};
+	return cliStorage.run(ctx, fn);
+}
+
+//#endregion
+//#region src/utils/navigation.ts
+/**
+* Navigation symbols and utilities for prompt navigation
+*/
+const GO_BACK_SYMBOL = Symbol("clack:goBack");
+function isGoBack(value) {
+	return value === GO_BACK_SYMBOL;
+}
+
+//#endregion
+//#region src/prompts/navigable.ts
+/**
+* Navigable prompt wrappers using @clack/core
+* These prompts return GO_BACK_SYMBOL when 'b' is pressed (instead of canceling)
+*/
+const unicode = process.platform !== "win32";
+const S_STEP_ACTIVE = unicode ? "◆" : "*";
+const S_STEP_CANCEL = unicode ? "■" : "x";
+const S_STEP_ERROR = unicode ? "▲" : "x";
+const S_STEP_SUBMIT = unicode ? "◇" : "o";
+const S_BAR = unicode ? "│" : "|";
+const S_BAR_END = unicode ? "└" : "—";
+const S_RADIO_ACTIVE = unicode ? "●" : ">";
+const S_RADIO_INACTIVE = unicode ? "○" : " ";
+const S_CHECKBOX_ACTIVE = unicode ? "◻" : "[•]";
+const S_CHECKBOX_SELECTED = unicode ? "◼" : "[+]";
+const S_CHECKBOX_INACTIVE = unicode ? "◻" : "[ ]";
+function symbol(state) {
+	switch (state) {
+		case "initial":
+		case "active": return pc.cyan(S_STEP_ACTIVE);
+		case "cancel": return pc.red(S_STEP_CANCEL);
+		case "error": return pc.yellow(S_STEP_ERROR);
+		case "submit": return pc.green(S_STEP_SUBMIT);
+	}
+}
+const KEYBOARD_HINT = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("enter")} confirm • ${pc.gray("b")} back • ${pc.gray("ctrl+c")} cancel`);
+const KEYBOARD_HINT_FIRST = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("enter")} confirm • ${pc.gray("ctrl+c")} cancel`);
+const KEYBOARD_HINT_MULTI = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("space")} select • ${pc.gray("enter")} confirm • ${pc.gray("b")} back • ${pc.gray("ctrl+c")} cancel`);
+const KEYBOARD_HINT_MULTI_FIRST = pc.dim(`${pc.gray("↑/↓")} navigate • ${pc.gray("space")} select • ${pc.gray("enter")} confirm • ${pc.gray("ctrl+c")} cancel`);
+const setIsFirstPrompt = setIsFirstPrompt$1;
+function getHint() {
+	return isFirstPrompt() ? KEYBOARD_HINT_FIRST : KEYBOARD_HINT;
+}
+function getMultiHint() {
+	return isFirstPrompt() ? KEYBOARD_HINT_MULTI_FIRST : KEYBOARD_HINT_MULTI;
+}
+async function runWithNavigation(prompt) {
+	let goBack = false;
+	prompt.on("key", (char) => {
+		if (char === "b" && !isFirstPrompt()) {
+			goBack = true;
+			prompt.state = "cancel";
+		}
+	});
+	setLastPromptShownUI(true);
+	const result = await prompt.prompt();
+	return goBack ? GO_BACK_SYMBOL : result;
+}
+async function navigableSelect(opts) {
+	const opt = (option, state) => {
+		const label = option.label ?? String(option.value);
+		switch (state) {
+			case "disabled": return `${pc.gray(S_RADIO_INACTIVE)} ${pc.gray(label)}${option.hint ? ` ${pc.dim(`(${option.hint ?? "disabled"})`)}` : ""}`;
+			case "selected": return `${pc.dim(label)}`;
+			case "active": return `${pc.green(S_RADIO_ACTIVE)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+			case "cancelled": return `${pc.strikethrough(pc.dim(label))}`;
+			default: return `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(label)}`;
+		}
+	};
+	return runWithNavigation(new SelectPrompt({
+		options: opts.options,
+		initialValue: opts.initialValue,
+		render() {
+			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+			switch (this.state) {
+				case "submit": return `${title}${pc.gray(S_BAR)}  ${opt(this.options[this.cursor], "selected")}`;
+				case "cancel": return `${title}${pc.gray(S_BAR)}  ${opt(this.options[this.cursor], "cancelled")}\n${pc.gray(S_BAR)}`;
+				default: {
+					const optionsText = this.options.map((option, i) => opt(option, option.disabled ? "disabled" : i === this.cursor ? "active" : "inactive")).join(`\n${pc.cyan(S_BAR)}  `);
+					const hint = `\n${pc.gray(S_BAR)}  ${getHint()}`;
+					return `${title}${pc.cyan(S_BAR)}  ${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+				}
+			}
+		}
+	}));
+}
+async function navigableMultiselect(opts) {
+	const required = opts.required ?? true;
+	const opt = (option, state) => {
+		const label = option.label ?? String(option.value);
+		if (state === "disabled") return `${pc.gray(S_CHECKBOX_INACTIVE)} ${pc.strikethrough(pc.gray(label))}${option.hint ? ` ${pc.dim(`(${option.hint ?? "disabled"})`)}` : ""}`;
+		if (state === "active") return `${pc.cyan(S_CHECKBOX_ACTIVE)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		if (state === "selected") return `${pc.green(S_CHECKBOX_SELECTED)} ${pc.dim(label)}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		if (state === "cancelled") return `${pc.strikethrough(pc.dim(label))}`;
+		if (state === "active-selected") return `${pc.green(S_CHECKBOX_SELECTED)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		if (state === "submitted") return `${pc.dim(label)}`;
+		return `${pc.dim(S_CHECKBOX_INACTIVE)} ${pc.dim(label)}`;
+	};
+	return runWithNavigation(new MultiSelectPrompt({
+		options: opts.options,
+		initialValues: opts.initialValues,
+		required,
+		validate(selected) {
+			if (required && (selected === void 0 || selected.length === 0)) return `Please select at least one option.\n${pc.reset(pc.dim(`Press ${pc.gray(pc.bgWhite(pc.inverse(" space ")))} to select, ${pc.gray(pc.bgWhite(pc.inverse(" enter ")))} to submit`))}`;
+		},
+		render() {
+			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+			const value = this.value ?? [];
+			const styleOption = (option, active) => {
+				if (option.disabled) return opt(option, "disabled");
+				const selected = value.includes(option.value);
+				if (active && selected) return opt(option, "active-selected");
+				if (selected) return opt(option, "selected");
+				return opt(option, active ? "active" : "inactive");
+			};
+			switch (this.state) {
+				case "submit": {
+					const submitText = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "submitted")).join(pc.dim(", ")) || pc.dim("none");
+					return `${title}${pc.gray(S_BAR)}  ${submitText}`;
+				}
+				case "cancel": {
+					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", "));
+					return `${title}${pc.gray(S_BAR)}  ${label}\n${pc.gray(S_BAR)}`;
+				}
+				case "error": {
+					const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${pc.yellow(S_BAR_END)}  ${pc.yellow(ln)}` : `   ${ln}`).join("\n");
+					const optionsText = this.options.map((option, i) => styleOption(option, i === this.cursor)).join(`\n${pc.yellow(S_BAR)}  `);
+					return `${title}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
+				}
+				default: {
+					const optionsText = this.options.map((option, i) => styleOption(option, i === this.cursor)).join(`\n${pc.cyan(S_BAR)}  `);
+					const hint = `\n${pc.gray(S_BAR)}  ${getMultiHint()}`;
+					return `${title}${pc.cyan(S_BAR)}  ${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+				}
+			}
+		}
+	}));
+}
+async function navigableConfirm(opts) {
+	const active = opts.active ?? "Yes";
+	const inactive = opts.inactive ?? "No";
+	return runWithNavigation(new ConfirmPrompt({
+		active,
+		inactive,
+		initialValue: opts.initialValue ?? true,
+		render() {
+			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+			const value = this.value ? active : inactive;
+			switch (this.state) {
+				case "submit": return `${title}${pc.gray(S_BAR)}  ${pc.dim(value)}`;
+				case "cancel": return `${title}${pc.gray(S_BAR)}  ${pc.strikethrough(pc.dim(value))}\n${pc.gray(S_BAR)}`;
+				default: {
+					const hint = `\n${pc.gray(S_BAR)}  ${getHint()}`;
+					return `${title}${pc.cyan(S_BAR)}  ${this.value ? `${pc.green(S_RADIO_ACTIVE)} ${active}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(active)}`} ${pc.dim("/")} ${!this.value ? `${pc.green(S_RADIO_ACTIVE)} ${inactive}` : `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(inactive)}`}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+				}
+			}
+		}
+	}));
+}
+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 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} ` : "";
+		if (state === "active") return `${pc.dim(prefix)}${pc.cyan(S_CHECKBOX_ACTIVE)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		if (state === "group-active") return `${prefix}${pc.cyan(S_CHECKBOX_ACTIVE)} ${pc.dim(label)}`;
+		if (state === "group-active-selected") return `${prefix}${pc.green(S_CHECKBOX_SELECTED)} ${pc.dim(label)}`;
+		if (state === "selected") {
+			const selectedCheckbox = isItem ? pc.green(S_CHECKBOX_SELECTED) : "";
+			return `${pc.dim(prefix)}${selectedCheckbox} ${pc.dim(label)}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		}
+		if (state === "cancelled") return `${pc.strikethrough(pc.dim(label))}`;
+		if (state === "active-selected") return `${pc.dim(prefix)}${pc.green(S_CHECKBOX_SELECTED)} ${label}${option.hint ? ` ${pc.dim(`(${option.hint})`)}` : ""}`;
+		if (state === "submitted") return `${pc.dim(label)}`;
+		const unselectedCheckbox = isItem ? pc.dim(S_CHECKBOX_INACTIVE) : "";
+		return `${pc.dim(prefix)}${unselectedCheckbox} ${pc.dim(label)}`;
+	};
+	return runWithNavigation(new GroupMultiSelectPrompt({
+		options: opts.options,
+		initialValues: opts.initialValues,
+		required,
+		selectableGroups: true,
+		validate(selected) {
+			if (required && (selected === void 0 || selected.length === 0)) return `Please select at least one option.\n${pc.reset(pc.dim(`Press ${pc.gray(pc.bgWhite(pc.inverse(" space ")))} to select, ${pc.gray(pc.bgWhite(pc.inverse(" enter ")))} to submit`))}`;
+		},
+		render() {
+			const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+			const value = this.value ?? [];
+			switch (this.state) {
+				case "submit": {
+					const selectedOptions = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "submitted"));
+					const optionsText = selectedOptions.length === 0 ? "" : `  ${selectedOptions.join(pc.dim(", "))}`;
+					return `${title}${pc.gray(S_BAR)}${optionsText}`;
+				}
+				case "cancel": {
+					const label = this.options.filter(({ value: optionValue }) => value.includes(optionValue)).map((option) => opt(option, "cancelled")).join(pc.dim(", "));
+					return `${title}${pc.gray(S_BAR)}  ${label.trim() ? `${label}\n${pc.gray(S_BAR)}` : ""}`;
+				}
+				case "error": {
+					const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${pc.yellow(S_BAR_END)}  ${pc.yellow(ln)}` : `   ${ln}`).join("\n");
+					const optionsText = this.options.map((option, i, options) => {
+						const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
+						const active = i === this.cursor;
+						if (!active && typeof option.group === "string" && this.options[this.cursor].value === option.group) return opt(option, selected ? "group-active-selected" : "group-active", options);
+						if (active && selected) return opt(option, "active-selected", options);
+						if (selected) return opt(option, "selected", options);
+						return opt(option, active ? "active" : "inactive", options);
+					}).join(`\n${pc.yellow(S_BAR)}  `);
+					return `${title}${pc.yellow(S_BAR)}  ${optionsText}\n${footer}\n`;
+				}
+				default: {
+					const optionsText = this.options.map((option, i, options) => {
+						const selected = value.includes(option.value) || option.group === true && this.isGroupSelected(`${option.value}`);
+						const active = i === this.cursor;
+						const groupActive = !active && typeof option.group === "string" && this.options[this.cursor].value === option.group;
+						let optionText = "";
+						if (groupActive) optionText = opt(option, selected ? "group-active-selected" : "group-active", options);
+						else if (active && selected) optionText = opt(option, "active-selected", options);
+						else if (selected) optionText = opt(option, "selected", options);
+						else optionText = opt(option, active ? "active" : "inactive", options);
+						return `${i !== 0 && !optionText.startsWith("\n") ? "  " : ""}${optionText}`;
+					}).join(`\n${pc.cyan(S_BAR)}`);
+					const optionsPrefix = optionsText.startsWith("\n") ? "" : "  ";
+					const hint = `\n${pc.gray(S_BAR)}  ${getMultiHint()}`;
+					return `${title}${pc.cyan(S_BAR)}${optionsPrefix}${optionsText}\n${pc.cyan(S_BAR_END)}${hint}\n`;
+				}
+			}
+		}
+	}));
+}
+
 //#endregion
 //#region src/prompts/addons.ts
 function getAddonDisplay(addon) {
@@ -473,14 +776,13 @@ async function getAddonsChoice(addons, frontends, auth) {
 			});
 		}
 	});
-	const response = await groupMultiselect({
+	const response = await navigableGroupMultiselect({
 		message: "Select addons",
 		options: groupedOptions,
 		initialValues: DEFAULT_CONFIG.addons.filter((addonValue) => Object.values(groupedOptions).some((options) => options.some((opt) => opt.value === addonValue))),
-		required: false,
-		selectableGroups: false
+		required: false
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 async function getAddonsToAdd(frontend, existingAddons = [], auth) {
@@ -512,13 +814,12 @@ async function getAddonsToAdd(frontend, existingAddons = [], auth) {
 		}
 	});
 	if (Object.keys(groupedOptions).length === 0) return [];
-	const response = await groupMultiselect({
+	const response = await navigableGroupMultiselect({
 		message: "Select addons to add",
 		options: groupedOptions,
-		required: false,
-		selectableGroups: false
+		required: false
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -541,12 +842,12 @@ async function getApiChoice(Api, frontend, backend) {
 		label: "None",
 		hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
 	});
-	const apiType = await select({
+	const apiType = await navigableSelect({
 		message: "Select API type",
 		options: apiOptions,
 		initialValue: apiOptions[0].value
 	});
-	if (isCancel(apiType)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(apiType)) return exitCancelled("Operation cancelled");
 	return apiType;
 }
 
@@ -590,15 +891,15 @@ async function getAuthChoice(auth, backend, frontend) {
 			label: "None",
 			hint: "No auth"
 		});
-		const response$1 = await select({
+		const response$1 = await navigableSelect({
 			message: "Select authentication provider",
 			options,
 			initialValue: "none"
 		});
-		if (isCancel(response$1)) return exitCancelled("Operation cancelled");
+		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
 		return response$1;
 	}
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select authentication provider",
 		options: [{
 			value: "better-auth",
@@ -610,7 +911,7 @@ async function getAuthChoice(auth, backend, frontend) {
 		}],
 		initialValue: DEFAULT_CONFIG.auth
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -654,12 +955,12 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 		label: "None",
 		hint: "No backend server"
 	});
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select backend",
 		options: backendOptions,
 		initialValue: hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -695,12 +996,12 @@ async function getDatabaseChoice(database, backend, runtime) {
 		label: "MongoDB",
 		hint: "open-source NoSQL database that stores data in JSON-like documents called BSON"
 	});
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select database",
 		options: databaseOptions,
 		initialValue: DEFAULT_CONFIG.database
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -795,12 +1096,12 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 		}
 	];
 	else return "none";
-	const response = await select({
+	const response = await navigableSelect({
 		message: `Select ${databaseType} setup option`,
 		options,
 		initialValue: "none"
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -822,13 +1123,13 @@ async function getExamplesChoice(examples, database, frontends, backend, api) {
 		hint: "A simple AI chat interface using AI SDK"
 	});
 	if (options.length === 0) return [];
-	response = await multiselect({
+	response = await navigableMultiselect({
 		message: "Include examples",
 		options,
 		required: false,
 		initialValues: DEFAULT_CONFIG.examples?.filter((ex) => options.some((o) => o.value === ex))
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -836,104 +1137,124 @@ async function getExamplesChoice(examples, database, frontends, backend, api) {
 //#region src/prompts/frontend.ts
 async function getFrontendChoice(frontendOptions, backend, auth) {
 	if (frontendOptions !== void 0) return frontendOptions;
-	const frontendTypes = await multiselect({
-		message: "Select project type",
-		options: [{
-			value: "web",
-			label: "Web",
-			hint: "React, Vue or Svelte Web Application"
-		}, {
-			value: "native",
-			label: "Native",
-			hint: "Create a React Native/Expo app"
-		}],
-		required: false,
-		initialValues: ["web"]
-	});
-	if (isCancel(frontendTypes)) return exitCancelled("Operation cancelled");
-	const result = [];
-	if (frontendTypes.includes("web")) {
-		const webFramework = await select({
-			message: "Choose web",
-			options: [
-				{
-					value: "tanstack-router",
-					label: "TanStack Router",
-					hint: "Modern and scalable routing for React Applications"
-				},
-				{
-					value: "react-router",
-					label: "React Router",
-					hint: "A user‑obsessed, standards‑focused, multi‑strategy router"
-				},
-				{
-					value: "next",
-					label: "Next.js",
-					hint: "The React Framework for the Web"
-				},
-				{
-					value: "nuxt",
-					label: "Nuxt",
-					hint: "The Progressive Web Framework for Vue.js"
-				},
-				{
-					value: "svelte",
-					label: "Svelte",
-					hint: "web development for the rest of us"
-				},
-				{
-					value: "solid",
-					label: "Solid",
-					hint: "Simple and performant reactivity for building user interfaces"
-				},
-				{
-					value: "tanstack-start",
-					label: "TanStack Start",
-					hint: "SSR, Server Functions, API Routes and more with TanStack Router"
-				}
-			].filter((option) => isFrontendAllowedWithBackend(option.value, backend, auth)),
-			initialValue: DEFAULT_CONFIG.frontend[0]
-		});
-		if (isCancel(webFramework)) return exitCancelled("Operation cancelled");
-		result.push(webFramework);
-	}
-	if (frontendTypes.includes("native")) {
-		const nativeFramework = await select({
-			message: "Choose native",
-			options: [
-				{
-					value: "native-bare",
-					label: "Bare",
-					hint: "Bare Expo without styling library"
-				},
-				{
-					value: "native-uniwind",
-					label: "Uniwind",
-					hint: "Fastest Tailwind bindings for React Native with HeroUI Native"
-				},
-				{
-					value: "native-unistyles",
-					label: "Unistyles",
-					hint: "Consistent styling for React Native"
-				}
-			],
-			initialValue: "native-bare"
+	while (true) {
+		const wasFirstPrompt = isFirstPrompt();
+		const frontendTypes = await navigableMultiselect({
+			message: "Select project type",
+			options: [{
+				value: "web",
+				label: "Web",
+				hint: "React, Vue or Svelte Web Application"
+			}, {
+				value: "native",
+				label: "Native",
+				hint: "Create a React Native/Expo app"
+			}],
+			required: false,
+			initialValues: ["web"]
 		});
-		if (isCancel(nativeFramework)) return exitCancelled("Operation cancelled");
-		result.push(nativeFramework);
+		if (isGoBack(frontendTypes)) return GO_BACK_SYMBOL;
+		if (isCancel$1(frontendTypes)) return exitCancelled("Operation cancelled");
+		setIsFirstPrompt(false);
+		const result = [];
+		let shouldRestart = false;
+		if (frontendTypes.includes("web")) {
+			const webFramework = await navigableSelect({
+				message: "Choose web",
+				options: [
+					{
+						value: "tanstack-router",
+						label: "TanStack Router",
+						hint: "Modern and scalable routing for React Applications"
+					},
+					{
+						value: "react-router",
+						label: "React Router",
+						hint: "A user‑obsessed, standards‑focused, multi‑strategy router"
+					},
+					{
+						value: "next",
+						label: "Next.js",
+						hint: "The React Framework for the Web"
+					},
+					{
+						value: "nuxt",
+						label: "Nuxt",
+						hint: "The Progressive Web Framework for Vue.js"
+					},
+					{
+						value: "svelte",
+						label: "Svelte",
+						hint: "web development for the rest of us"
+					},
+					{
+						value: "solid",
+						label: "Solid",
+						hint: "Simple and performant reactivity for building user interfaces"
+					},
+					{
+						value: "tanstack-start",
+						label: "TanStack Start",
+						hint: "SSR, Server Functions, API Routes and more with TanStack Router"
+					}
+				].filter((option) => isFrontendAllowedWithBackend(option.value, backend, auth)),
+				initialValue: DEFAULT_CONFIG.frontend[0]
+			});
+			if (isGoBack(webFramework)) shouldRestart = true;
+			else if (isCancel$1(webFramework)) return exitCancelled("Operation cancelled");
+			else result.push(webFramework);
+		}
+		if (shouldRestart) {
+			setIsFirstPrompt(wasFirstPrompt);
+			continue;
+		}
+		if (frontendTypes.includes("native")) {
+			const nativeFramework = await navigableSelect({
+				message: "Choose native",
+				options: [
+					{
+						value: "native-bare",
+						label: "Bare",
+						hint: "Bare Expo without styling library"
+					},
+					{
+						value: "native-uniwind",
+						label: "Uniwind",
+						hint: "Fastest Tailwind bindings for React Native with HeroUI Native"
+					},
+					{
+						value: "native-unistyles",
+						label: "Unistyles",
+						hint: "Consistent styling for React Native"
+					}
+				],
+				initialValue: "native-bare"
+			});
+			if (isGoBack(nativeFramework)) if (frontendTypes.includes("web")) shouldRestart = true;
+			else {
+				setIsFirstPrompt(wasFirstPrompt);
+				continue;
+			}
+			else if (isCancel$1(nativeFramework)) return exitCancelled("Operation cancelled");
+			else result.push(nativeFramework);
+		}
+		if (shouldRestart) {
+			setIsFirstPrompt(wasFirstPrompt);
+			continue;
+		}
+		return result;
 	}
-	return result;
 }
 
 //#endregion
 //#region src/prompts/git.ts
 async function getGitChoice(git) {
 	if (git !== void 0) return git;
-	const response = await confirm({
+	const response = await navigableConfirm({
 		message: "Initialize git repository?",
 		initialValue: DEFAULT_CONFIG.git
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -941,14 +1262,71 @@ async function getGitChoice(git) {
 //#region src/prompts/install.ts
 async function getinstallChoice(install) {
 	if (install !== void 0) return install;
-	const response = await confirm({
+	const response = await navigableConfirm({
 		message: "Install dependencies?",
 		initialValue: DEFAULT_CONFIG.install
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
+//#endregion
+//#region src/prompts/navigable-group.ts
+/**
+* Navigable group - a group of prompts that allows going back
+*/
+/**
+* Define a group of prompts that supports going back to previous prompts.
+* Returns a result object with all the values, or handles cancel/go-back navigation.
+*/
+async function navigableGroup(prompts, opts) {
+	const results = {};
+	const promptNames = Object.keys(prompts);
+	let currentIndex = 0;
+	let goingBack = false;
+	while (currentIndex < promptNames.length) {
+		const name = promptNames[currentIndex];
+		const prompt = prompts[name];
+		setIsFirstPrompt$1(currentIndex === 0);
+		setLastPromptShownUI(false);
+		const result = await prompt({ results })?.catch((e) => {
+			throw e;
+		});
+		if (isGoBack(result)) {
+			goingBack = true;
+			if (currentIndex > 0) {
+				const prevName = promptNames[currentIndex - 1];
+				delete results[prevName];
+				currentIndex--;
+				continue;
+			}
+			goingBack = false;
+			continue;
+		}
+		if (isCancel$1(result)) {
+			if (typeof opts?.onCancel === "function") {
+				results[name] = "canceled";
+				opts.onCancel({ results });
+			}
+			setIsFirstPrompt$1(false);
+			return results;
+		}
+		if (goingBack && !didLastPromptShowUI()) {
+			if (currentIndex > 0) {
+				const prevName = promptNames[currentIndex - 1];
+				delete results[prevName];
+				currentIndex--;
+				continue;
+			}
+		}
+		goingBack = false;
+		results[name] = result;
+		currentIndex++;
+	}
+	setIsFirstPrompt$1(false);
+	return results;
+}
+
 //#endregion
 //#region src/prompts/orm.ts
 const ormOptions = {
@@ -972,12 +1350,12 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
 	if (backend === "convex") return "none";
 	if (!hasDatabase) return "none";
 	if (orm !== void 0) return orm;
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select ORM",
 		options: database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma],
 		initialValue: database === "mongodb" ? "prisma" : runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -985,13 +1363,13 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
 //#region src/prompts/package-manager.ts
 async function getPackageManagerChoice(packageManager) {
 	if (packageManager !== void 0) return packageManager;
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Choose package manager",
 		options: [
 			{
 				value: "npm",
 				label: "npm",
-				hint: "Node Package Manager"
+				hint: "not recommended"
 			},
 			{
 				value: "pnpm",
@@ -1006,7 +1384,7 @@ async function getPackageManagerChoice(packageManager) {
 		],
 		initialValue: getUserPkgManager()
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -1016,7 +1394,7 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 	if (payments !== void 0) return payments;
 	if (backend === "none") return "none";
 	if (!(auth === "better-auth" && backend !== "convex" && (frontends?.length === 0 || splitFrontends(frontends).web.length > 0))) return "none";
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select payments provider",
 		options: [{
 			value: "polar",
@@ -1029,7 +1407,7 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 		}],
 		initialValue: DEFAULT_CONFIG.payments
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -1052,12 +1430,12 @@ async function getRuntimeChoice(runtime, backend) {
 		label: "Cloudflare Workers",
 		hint: "Edge runtime on Cloudflare's global network"
 	});
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select runtime",
 		options: runtimeOptions,
 		initialValue: DEFAULT_CONFIG.runtime
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -1095,12 +1473,12 @@ async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	}
 	if (existingDeployment && existingDeployment !== "none") return "none";
 	if (options.length === 0) return "none";
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select server deployment",
 		options,
 		initialValue: DEFAULT_CONFIG.serverDeploy
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
@@ -1122,7 +1500,7 @@ function getDeploymentDisplay(deployment) {
 async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []) {
 	if (deployment !== void 0) return deployment;
 	if (!hasWebFrontend(frontend)) return "none";
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select web deployment",
 		options: ["cloudflare", "none"].map((deploy) => {
 			const { label, hint } = getDeploymentDisplay(deploy);
@@ -1134,7 +1512,7 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 		}),
 		initialValue: DEFAULT_CONFIG.webDeploy
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 async function getDeploymentToAdd(frontend, existingDeployment) {
@@ -1155,19 +1533,19 @@ async function getDeploymentToAdd(frontend, existingDeployment) {
 		hint: "Skip deployment setup"
 	});
 	if (options.length === 0) return "none";
-	const response = await select({
+	const response = await navigableSelect({
 		message: "Select web deployment",
 		options,
 		initialValue: DEFAULT_CONFIG.webDeploy
 	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
 
 //#endregion
 //#region src/prompts/config-prompts.ts
 async function gatherConfig(flags, projectName, projectDir, relativePath) {
-	const result = await group({
+	const result = await navigableGroup({
 		frontend: () => getFrontendChoice(flags.frontend, flags.backend, flags.auth),
 		backend: ({ results }) => getBackendFrameworkChoice(flags.backend, results.frontend),
 		runtime: ({ results }) => getRuntimeChoice(flags.runtime, results.backend),
@@ -1383,14 +1761,14 @@ function generateReproducibleCommand(config) {
 
 //#endregion
 //#region src/utils/project-directory.ts
-async function handleDirectoryConflict(currentPathInput, silent = false) {
+async function handleDirectoryConflict(currentPathInput) {
 	while (true) {
 		const resolvedPath = path.resolve(process.cwd(), currentPathInput);
 		if (!(await fs.pathExists(resolvedPath) && (await fs.readdir(resolvedPath)).length > 0)) return {
 			finalPathInput: currentPathInput,
 			shouldClearDirectory: false
 		};
-		if (silent) throw new Error(`Directory "${currentPathInput}" already exists and is not empty. In silent mode, please provide a different project name or clear the directory manually.`);
+		if (isSilent()) throw new Error(`Directory "${currentPathInput}" already exists and is not empty. In silent mode, please provide a different project name or clear the directory manually.`);
 		log.warn(`Directory "${pc.yellow(currentPathInput)}" already exists and is not empty.`);
 		const action = await select({
 			message: "What would you like to do?",
@@ -1497,11 +1875,7 @@ const catppuccinTheme = {
 const renderTitle = () => {
 	const terminalWidth = process.stdout.columns || 80;
 	const titleLines = TITLE_TEXT.split("\n");
-	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(catppuccinTheme)).multiline(`
-    ╔══════════════════╗
-    ║  Better T Stack  ║
-    ╚══════════════════╝
-    `));
+	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(catppuccinTheme)).multiline(`Better T Stack`));
 	else console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
 };
 
@@ -6799,7 +7173,6 @@ async function updateConvexPackageJson(projectDir, options) {
 //#endregion
 //#region src/helpers/core/create-project.ts
 async function createProject(options, cliInput = {}) {
-	const { silent = false } = cliInput;
 	const projectDir = options.projectDir;
 	const isConvex = options.backend === "convex";
 	const isSelfBackend = options.backend === "self";
@@ -6835,23 +7208,23 @@ async function createProject(options, cliInput = {}) {
 		await setupCatalogs(projectDir, options);
 		await createReadme(projectDir, options);
 		await writeBtsConfig(options);
-		if (!silent) log.success("Project template successfully scaffolded!");
+		if (!isSilent()) log.success("Project template successfully scaffolded!");
 		if (options.install) await installDependencies({
 			projectDir,
 			packageManager: options.packageManager
 		});
 		await initializeGit(projectDir, options.git);
-		if (!silent) await displayPostInstallInstructions({
+		if (!isSilent()) await displayPostInstallInstructions({
 			...options,
 			depsInstalled: options.install
 		});
 		return projectDir;
 	} catch (error) {
 		if (error instanceof Error) {
-			if (!silent) console.error(error.stack);
+			if (!isSilent()) console.error(error.stack);
 			exitWithError(`Error during project creation: ${error.message}`);
 		} else {
-			if (!silent) console.error(error);
+			if (!isSilent()) console.error(error);
 			exitWithError(`An unexpected error occurred: ${String(error)}`);
 		}
 	}
@@ -6861,139 +7234,169 @@ async function createProject(options, cliInput = {}) {
 //#region src/helpers/core/command-handlers.ts
 async function createProjectHandler(input, options = {}) {
 	const { silent = false } = options;
-	const startTime = Date.now();
-	const timeScaffolded = (/* @__PURE__ */ new Date()).toISOString();
-	if (!silent && input.renderTitle !== false) renderTitle();
-	if (!silent) intro(pc.magenta("Creating a new Better-T-Stack project"));
-	if (!silent && input.yolo) consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
-	let currentPathInput;
-	if (input.yes && input.projectName) currentPathInput = input.projectName;
-	else if (input.yes) {
-		const defaultConfig = getDefaultConfig();
-		let defaultName = defaultConfig.relativePath;
-		let counter = 1;
-		while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
-			defaultName = `${defaultConfig.projectName}-${counter}`;
-			counter++;
-		}
-		currentPathInput = defaultName;
-	} else currentPathInput = await getProjectName(input.projectName);
-	let finalPathInput;
-	let shouldClearDirectory;
-	try {
-		if (input.directoryConflict) {
-			const result = await handleDirectoryConflictProgrammatically(currentPathInput, input.directoryConflict);
-			finalPathInput = result.finalPathInput;
-			shouldClearDirectory = result.shouldClearDirectory;
-		} else {
-			const result = await handleDirectoryConflict(currentPathInput);
-			finalPathInput = result.finalPathInput;
-			shouldClearDirectory = result.shouldClearDirectory;
-		}
-	} catch (error) {
-		return {
-			success: false,
-			projectConfig: {
-				projectName: "",
-				projectDir: "",
-				relativePath: "",
-				database: "none",
-				orm: "none",
-				backend: "none",
-				runtime: "none",
-				frontend: [],
-				addons: [],
-				examples: [],
-				auth: "none",
-				payments: "none",
-				git: false,
-				packageManager: "npm",
-				install: false,
-				dbSetup: "none",
-				api: "none",
-				webDeploy: "none",
-				serverDeploy: "none"
-			},
-			reproducibleCommand: "",
-			timeScaffolded,
-			elapsedTimeMs: Date.now() - startTime,
-			projectDirectory: "",
-			relativePath: "",
-			error: error instanceof Error ? error.message : String(error)
-		};
-	}
-	const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(finalPathInput, shouldClearDirectory);
-	const originalInput = {
-		...input,
-		projectDirectory: input.projectName
-	};
-	const providedFlags = getProvidedFlags(originalInput);
-	let cliInput = originalInput;
-	if (input.template && input.template !== "none") {
-		const templateConfig = getTemplateConfig(input.template);
-		if (templateConfig) {
-			const templateName = input.template.toUpperCase();
-			const templateDescription = getTemplateDescription(input.template);
-			if (!silent) {
-				log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
-				log.message(pc.dim(`   ${templateDescription}`));
+	return runWithContextAsync({ silent }, async () => {
+		const startTime = Date.now();
+		const timeScaffolded = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			if (!isSilent() && input.renderTitle !== false) renderTitle();
+			if (!isSilent()) intro(pc.magenta("Creating a new Better-T-Stack project"));
+			if (!isSilent() && input.yolo) consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
+			let currentPathInput;
+			if (input.yes && input.projectName) currentPathInput = input.projectName;
+			else if (input.yes) {
+				const defaultConfig = getDefaultConfig();
+				let defaultName = defaultConfig.relativePath;
+				let counter = 1;
+				while (await fs.pathExists(path.resolve(process.cwd(), defaultName)) && (await fs.readdir(path.resolve(process.cwd(), defaultName))).length > 0) {
+					defaultName = `${defaultConfig.projectName}-${counter}`;
+					counter++;
+				}
+				currentPathInput = defaultName;
+			} else currentPathInput = await getProjectName(input.projectName);
+			let finalPathInput;
+			let shouldClearDirectory;
+			try {
+				if (input.directoryConflict) {
+					const result = await handleDirectoryConflictProgrammatically(currentPathInput, input.directoryConflict);
+					finalPathInput = result.finalPathInput;
+					shouldClearDirectory = result.shouldClearDirectory;
+				} else {
+					const result = await handleDirectoryConflict(currentPathInput);
+					finalPathInput = result.finalPathInput;
+					shouldClearDirectory = result.shouldClearDirectory;
+				}
+			} catch (error) {
+				if (error instanceof UserCancelledError || error instanceof CLIError) throw error;
+				return {
+					success: false,
+					projectConfig: {
+						projectName: "",
+						projectDir: "",
+						relativePath: "",
+						database: "none",
+						orm: "none",
+						backend: "none",
+						runtime: "none",
+						frontend: [],
+						addons: [],
+						examples: [],
+						auth: "none",
+						payments: "none",
+						git: false,
+						packageManager: "npm",
+						install: false,
+						dbSetup: "none",
+						api: "none",
+						webDeploy: "none",
+						serverDeploy: "none"
+					},
+					reproducibleCommand: "",
+					timeScaffolded,
+					elapsedTimeMs: Date.now() - startTime,
+					projectDirectory: "",
+					relativePath: "",
+					error: error instanceof Error ? error.message : String(error)
+				};
 			}
-			const userOverrides = {};
-			for (const [key, value] of Object.entries(originalInput)) if (value !== void 0) userOverrides[key] = value;
-			cliInput = {
-				...templateConfig,
-				...userOverrides,
-				template: input.template,
-				projectDirectory: originalInput.projectDirectory
+			const { finalResolvedPath, finalBaseName } = await setupProjectDirectory(finalPathInput, shouldClearDirectory);
+			const originalInput = {
+				...input,
+				projectDirectory: input.projectName
 			};
+			const providedFlags = getProvidedFlags(originalInput);
+			let cliInput = originalInput;
+			if (input.template && input.template !== "none") {
+				const templateConfig = getTemplateConfig(input.template);
+				if (templateConfig) {
+					const templateName = input.template.toUpperCase();
+					const templateDescription = getTemplateDescription(input.template);
+					if (!isSilent()) {
+						log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
+						log.message(pc.dim(`   ${templateDescription}`));
+					}
+					const userOverrides = {};
+					for (const [key, value] of Object.entries(originalInput)) if (value !== void 0) userOverrides[key] = value;
+					cliInput = {
+						...templateConfig,
+						...userOverrides,
+						template: input.template,
+						projectDirectory: originalInput.projectDirectory
+					};
+				}
+			}
+			let config;
+			if (cliInput.yes) {
+				const flagConfig = processProvidedFlagsWithoutValidation(cliInput, finalBaseName);
+				config = {
+					...getDefaultConfig(),
+					...flagConfig,
+					projectName: finalBaseName,
+					projectDir: finalResolvedPath,
+					relativePath: finalPathInput
+				};
+				validateConfigCompatibility(config, providedFlags, cliInput);
+				if (!isSilent()) {
+					log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
+					log.message(displayConfig(config));
+				}
+			} else {
+				const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
+				const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
+				if (!isSilent() && Object.keys(otherFlags).length > 0) {
+					log.info(pc.yellow("Using these pre-selected options:"));
+					log.message(displayConfig(otherFlags));
+					log.message("");
+				}
+				config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
+			}
+			await createProject(config, { manualDb: cliInput.manualDb ?? input.manualDb });
+			const reproducibleCommand = generateReproducibleCommand(config);
+			if (!isSilent()) log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
+			await trackProjectCreation(config, input.disableAnalytics);
+			const elapsedTimeMs = Date.now() - startTime;
+			if (!isSilent()) {
+				const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(2);
+				outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+			}
+			return {
+				success: true,
+				projectConfig: config,
+				reproducibleCommand,
+				timeScaffolded,
+				elapsedTimeMs,
+				projectDirectory: config.projectDir,
+				relativePath: config.relativePath
+			};
+		} catch (error) {
+			if (error instanceof UserCancelledError) {
+				if (isSilent()) return {
+					success: false,
+					error: error.message,
+					projectConfig: {},
+					reproducibleCommand: "",
+					timeScaffolded,
+					elapsedTimeMs: Date.now() - startTime,
+					projectDirectory: "",
+					relativePath: ""
+				};
+				return;
+			}
+			if (error instanceof CLIError) {
+				if (isSilent()) return {
+					success: false,
+					error: error.message,
+					projectConfig: {},
+					reproducibleCommand: "",
+					timeScaffolded,
+					elapsedTimeMs: Date.now() - startTime,
+					projectDirectory: "",
+					relativePath: ""
+				};
+				throw error;
+			}
+			throw error;
 		}
-	}
-	let config;
-	if (cliInput.yes) {
-		const flagConfig = processProvidedFlagsWithoutValidation(cliInput, finalBaseName);
-		config = {
-			...getDefaultConfig(),
-			...flagConfig,
-			projectName: finalBaseName,
-			projectDir: finalResolvedPath,
-			relativePath: finalPathInput
-		};
-		validateConfigCompatibility(config, providedFlags, cliInput);
-		if (!silent) {
-			log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
-			log.message(displayConfig(config));
-		}
-	} else {
-		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
-		const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
-		if (!silent && Object.keys(otherFlags).length > 0) {
-			log.info(pc.yellow("Using these pre-selected options:"));
-			log.message(displayConfig(otherFlags));
-			log.message("");
-		}
-		config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
-	}
-	await createProject(config, {
-		manualDb: cliInput.manualDb ?? input.manualDb,
-		silent
 	});
-	const reproducibleCommand = generateReproducibleCommand(config);
-	if (!silent) log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
-	await trackProjectCreation(config, input.disableAnalytics);
-	const elapsedTimeMs = Date.now() - startTime;
-	if (!silent) {
-		const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(2);
-		outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
-	}
-	return {
-		success: true,
-		projectConfig: config,
-		reproducibleCommand,
-		timeScaffolded,
-		elapsedTimeMs,
-		projectDirectory: config.projectDir,
-		relativePath: config.relativePath
-	};
 }
 async function handleDirectoryConflictProgrammatically(currentPathInput, strategy) {
 	const currentPath = path.resolve(process.cwd(), currentPathInput);
@@ -7088,6 +7491,8 @@ async function addAddonsHandler(input) {
 		else log.info(`Run ${pc.bold(`${packageManager} install`)} to install dependencies`);
 		outro("Add command completed successfully!");
 	} catch (error) {
+		if (error instanceof UserCancelledError) return;
+		if (error instanceof CLIError) throw error;
 		handleError(error, "Failed to add addons or deployment");
 	}
 }