create-better-fullstack 2.0.1 → 2.0.2

package/dist/install-dependencies-D6-GO3BZ.mjs

@@ -0,0 +1,1139 @@
+#!/usr/bin/env node
+import { f as types_exports, m as DEFAULT_CONFIG } from "./bts-config-Bg1Qea9Y.mjs";
+import { a as CLIError, c as exitWithError, d as isFirstPrompt, f as isSilent, h as setLastPromptShownUI, m as setIsFirstPrompt$1, s as exitCancelled } from "./addons-setup-HSghQS7c.mjs";
+import { log, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import fs from "fs-extra";
+import path from "node:path";
+import { allowedApisForFrontends, getAIFrontendCompatibilityIssue, getApiFrontendCompatibilityIssue, getCompatibleAddons, getCompatibleCSSFrameworks, getCompatibleUILibraries, getUnsupportedWebDeployFrontend, hasDockerComposeCompatibleFrontend, hasWebStyling, isBackendUtilsCompatibleBackend, isExampleAIAllowed, isExampleChatSdkAllowed, isFrontendAllowedWithBackend, isWebFrontend, requiresChatSdkVercelAIForSelection, splitFrontends, validateAddonCompatibility } from "@better-fullstack/types";
+import gradient from "gradient-string";
+import consola from "consola";
+import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
+import { $ } from "execa";
+
+//#region src/utils/render-title.ts
+const TITLE_TEXT = `
+ ██████╗ ███████╗████████╗████████╗███████╗██████╗
+ ██╔══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔════╝██╔══██╗
+ ██████╔╝█████╗     ██║      ██║   █████╗  ██████╔╝
+ ██╔══██╗██╔══╝     ██║      ██║   ██╔══╝  ██╔══██╗
+ ██████╔╝███████╗   ██║      ██║   ███████╗██║  ██║
+ ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+ ███████╗██╗   ██╗██╗     ██╗     ███████╗████████╗ █████╗  ██████╗██╗  ██╗
+ ██╔════╝██║   ██║██║     ██║     ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
+ █████╗  ██║   ██║██║     ██║     ███████╗   ██║   ███████║██║     █████╔╝
+ ██╔══╝  ██║   ██║██║     ██║     ╚════██║   ██║   ██╔══██║██║     ██╔═██╗
+ ██║     ╚██████╔╝███████╗███████╗███████║   ██║   ██║  ██║╚██████╗██║  ██╗
+ ╚═╝      ╚═════╝ ╚══════╝╚══════╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
+ `;
+const monochromeTheme = {
+	white: "#FFFFFF",
+	lightGray: "#E5E5E5",
+	gray: "#A3A3A3",
+	darkGray: "#737373"
+};
+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(monochromeTheme)).multiline(`Better Fullstack`));
+	else console.log(gradient(Object.values(monochromeTheme)).multiline(TITLE_TEXT));
+};
+
+//#endregion
+//#region src/utils/error-formatter.ts
+function getCategoryTitle(category) {
+	return {
+		incompatibility: "Incompatible Options",
+		"invalid-selection": "Invalid Selection",
+		"missing-requirement": "Missing Requirement",
+		constraint: "Constraint Violation"
+	}[category];
+}
+function displayStructuredError(error) {
+	if (isSilent()) throw new CLIError(error.message);
+	const lines = [];
+	lines.push(pc.bold(pc.red(getCategoryTitle(error.category))));
+	lines.push("");
+	lines.push(error.message);
+	if (error.provided && Object.keys(error.provided).length > 0) {
+		lines.push("");
+		lines.push(pc.dim("You provided:"));
+		for (const [key, value] of Object.entries(error.provided)) {
+			const displayValue = Array.isArray(value) ? value.join(", ") : value;
+			lines.push(`  ${pc.cyan("--" + key)} ${displayValue}`);
+		}
+	}
+	if (error.suggestions.length > 0) {
+		lines.push("");
+		lines.push(pc.dim("Suggestions:"));
+		for (const suggestion of error.suggestions) lines.push(`  ${pc.green("•")} ${suggestion}`);
+	}
+	consola.box({
+		title: pc.red("Error"),
+		message: lines.join("\n"),
+		style: { borderColor: "red" }
+	});
+	process.exit(1);
+}
+function incompatibilityError(opts) {
+	return displayStructuredError({
+		category: "incompatibility",
+		...opts
+	});
+}
+function invalidSelectionError(opts) {
+	return displayStructuredError({
+		category: "invalid-selection",
+		...opts
+	});
+}
+function missingRequirementError(opts) {
+	return displayStructuredError({
+		category: "missing-requirement",
+		...opts
+	});
+}
+function constraintError(opts) {
+	return displayStructuredError({
+		category: "constraint",
+		...opts
+	});
+}
+
+//#endregion
+//#region src/utils/compatibility-rules.ts
+function isWebFrontend$1(value) {
+	return isWebFrontend(value);
+}
+function splitFrontends$1(values = []) {
+	return splitFrontends(values);
+}
+function ensureSingleWebAndNative(frontends) {
+	const { web, native } = splitFrontends$1(frontends);
+	if (web.length > 1) invalidSelectionError({
+		message: "Only one web framework can be selected per project.",
+		provided: { frontend: web },
+		suggestions: ["Keep one web framework and remove the others", "Use separate projects for multiple web frameworks"]
+	});
+	if (native.length > 1) invalidSelectionError({
+		message: "Only one native framework can be selected per project.",
+		provided: { frontend: native },
+		suggestions: ["Keep one native framework and remove the others", "Choose: native-bare, native-uniwind, or native-unistyles"]
+	});
+}
+const FULLSTACK_FRONTENDS = [
+	"next",
+	"vinext",
+	"tanstack-start",
+	"astro",
+	"nuxt",
+	"svelte",
+	"solid-start"
+];
+function validateSelfBackendCompatibility(providedFlags, options, config) {
+	const backend = config.backend || options.backend;
+	const frontends = config.frontend || options.frontend || [];
+	if (backend === "self") {
+		const { web, native } = splitFrontends$1(frontends);
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS.includes(web[0]))) exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, or --frontend solid-start.");
+		if (native.length > 1) exitWithError("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
+	}
+	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS.includes(f));
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") exitWithError("Backend 'self' (fullstack) only supports Next.js, Vinext, TanStack Start, Astro, Nuxt, SvelteKit, or SolidStart frontends. Please use --frontend next, --frontend vinext, --frontend tanstack-start, --frontend astro, --frontend nuxt, --frontend svelte, --frontend solid-start, or choose a different backend.");
+}
+const WORKERS_COMPATIBLE_BACKENDS = [
+	"hono",
+	"nitro",
+	"fets"
+];
+function validateWorkersCompatibility(providedFlags, options, config) {
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend)) incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently supported only with compatible backends (Hono, Nitro, or Fets).",
+		provided: {
+			runtime: "workers",
+			backend: config.backend
+		},
+		suggestions: [
+			"Use --backend hono",
+			"Use --backend nitro",
+			"Use --backend fets",
+			"Choose a different runtime (node, bun)"
+		]
+	});
+	if (providedFlags.has("backend") && config.backend && !WORKERS_COMPATIBLE_BACKENDS.includes(config.backend) && config.runtime === "workers") incompatibilityError({
+		message: `In Better-Fullstack, backend '${config.backend}' is currently not available with Cloudflare Workers runtime.`,
+		provided: {
+			backend: config.backend,
+			runtime: "workers"
+		},
+		suggestions: ["Use --backend hono, --backend nitro, or --backend fets", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.database === "mongodb") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with MongoDB.",
+		provided: {
+			runtime: "workers",
+			database: "mongodb"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.dbSetup === "docker") incompatibilityError({
+		message: "In Better-Fullstack, Cloudflare Workers runtime is currently not available with Docker database setup.",
+		provided: {
+			runtime: "workers",
+			"db-setup": "docker"
+		},
+		suggestions: ["Use --db-setup d1 for SQLite", "Choose a different runtime (node, bun)"]
+	});
+	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") incompatibilityError({
+		message: "In Better-Fullstack, MongoDB is currently not available with Cloudflare Workers runtime.",
+		provided: {
+			database: "mongodb",
+			runtime: "workers"
+		},
+		suggestions: ["Use a different database (postgres, sqlite, mysql)", "Choose a different runtime (node, bun)"]
+	});
+}
+function validateApiFrontendCompatibility(api, frontends = [], astroIntegration) {
+	const issue = getApiFrontendCompatibilityIssue(api, frontends, astroIntegration);
+	if (!issue) return;
+	incompatibilityError({
+		message: issue.message,
+		provided: issue.provided ?? {},
+		suggestions: issue.suggestions ?? []
+	});
+}
+function isFrontendAllowedWithBackend$1(frontend, backend, auth) {
+	return isFrontendAllowedWithBackend(frontend, backend, auth);
+}
+function allowedApisForFrontends$1(frontends = [], astroIntegration) {
+	return allowedApisForFrontends(frontends, astroIntegration);
+}
+function isExampleAIAllowed$1(backend, frontends = []) {
+	return isExampleAIAllowed(backend, frontends);
+}
+function isExampleChatSdkAllowed$1(backend, frontends = [], runtime) {
+	return isExampleChatSdkAllowed(backend, frontends, runtime);
+}
+function requiresChatSdkVercelAI(backend, frontends = [], runtime) {
+	return requiresChatSdkVercelAIForSelection(backend, frontends, runtime);
+}
+function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
+	if (webDeploy && webDeploy !== "none" && !hasWebFrontendFlag) exitWithError("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
+}
+function validateWebDeployFrontendTemplates(webDeploy, frontends = []) {
+	const blocked = getUnsupportedWebDeployFrontend(webDeploy, frontends);
+	if (blocked) exitWithError(`${webDeploy === "render" ? "Render" : "Netlify"} deployment is not yet wired up for the '${blocked}' frontend. Choose a different web deploy target or frontend.`);
+}
+function validateServerDeployRequiresBackend(serverDeploy, backend, hasGraphBackend = false) {
+	if (serverDeploy && serverDeploy !== "none" && !hasGraphBackend && (!backend || backend === "none")) exitWithError("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
+}
+function validateAddonCompatibility$1(addon, frontend, _auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	const baseCompatibility = validateAddonCompatibility(addon, frontend, _auth);
+	if (!baseCompatibility.isCompatible) return baseCompatibility;
+	if (addon === "backend-utils") {
+		if (ecosystem !== void 0 && ecosystem !== "typescript") return {
+			isCompatible: false,
+			reason: "Backend Utils requires a TypeScript server stack"
+		};
+		if (backend !== void 0 && !isBackendUtilsCompatibleBackend(backend)) return {
+			isCompatible: false,
+			reason: "Backend Utils requires a Hono, Express, Fastify, Elysia, feTS, or NestJS backend"
+		};
+	}
+	if (addon === "docker-compose") {
+		if (backend === "convex") return {
+			isCompatible: false,
+			reason: "docker-compose is not compatible with Convex backend (managed service)"
+		};
+		if (runtime === "workers") return {
+			isCompatible: false,
+			reason: "docker-compose is not compatible with Cloudflare Workers runtime"
+		};
+		if (ecosystem === "typescript" && !hasDockerComposeCompatibleFrontend(frontend)) return {
+			isCompatible: false,
+			reason: "Docker Compose currently supports Next.js, Vinext, TanStack Router, React Router, React Vite, Solid, or Astro"
+		};
+		if (ecosystem === "typescript" && backend === "self" && !frontend.includes("next") && !frontend.includes("vinext")) return {
+			isCompatible: false,
+			reason: "Docker Compose self-backend support currently requires Next.js or Vinext"
+		};
+		if (ecosystem === "rust" && rustFrontend && rustFrontend !== "none") return {
+			isCompatible: false,
+			reason: "Docker Compose for Rust currently supports server-only projects"
+		};
+		if (ecosystem === "java" && javaWebFramework && javaWebFramework !== "spring-boot") return {
+			isCompatible: false,
+			reason: "Docker Compose for Java currently requires Spring Boot"
+		};
+		if (ecosystem === "python" && database && database !== "none" && database !== "sqlite" && database !== "postgres") return {
+			isCompatible: false,
+			reason: "Docker Compose for Python ORM projects currently supports SQLite defaults or Postgres"
+		};
+	}
+	return { isCompatible: true };
+}
+function getCompatibleAddons$1(allAddons, frontend, existingAddons = [], auth, backend, runtime) {
+	return getCompatibleAddons(allAddons, frontend, existingAddons, auth).filter((addon) => {
+		const { isCompatible } = validateAddonCompatibility$1(addon, frontend, auth, backend, runtime);
+		return isCompatible;
+	});
+}
+function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database) {
+	for (const addon of addons) {
+		if (addon === "none") continue;
+		const { isCompatible, reason } = validateAddonCompatibility$1(addon, frontends, auth, backend, runtime, ecosystem, rustFrontend, javaWebFramework, database);
+		if (!isCompatible) exitWithError(`Incompatible addon/frontend combination: ${reason}`);
+	}
+}
+function validatePaymentsCompatibility(payments, auth, _backend, frontends = []) {
+	if (!payments || payments === "none") return;
+	if (payments === "dodo" && frontends.includes("react-vite")) exitWithError("Dodo Payments are not yet supported for React + Vite projects.");
+	if (payments === "polar") {
+		if (!auth || auth === "none" || auth !== "better-auth" && auth !== "better-auth-organizations") exitWithError("Polar payments requires Better Auth. Please use '--auth better-auth' or choose a different payments provider.");
+		const { web } = splitFrontends$1(frontends);
+		if (web.length === 0 && frontends.length > 0) exitWithError("Polar payments requires a web frontend or no frontend. Please select a web frontend or choose a different payments provider.");
+	}
+}
+function validateExamplesCompatibility(examples, backend, frontend, runtime, ai) {
+	const examplesArr = examples ?? [];
+	if (examplesArr.length === 0 || examplesArr.includes("none")) return;
+	if (examplesArr.includes("tanstack-showcase")) {
+		const showcaseFrontends = ["tanstack-router", "tanstack-start"];
+		if (!(frontend ?? []).some((f) => showcaseFrontends.includes(f))) exitWithError("The 'tanstack-showcase' example requires TanStack Router or TanStack Start frontend.");
+	}
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) exitWithError("The 'ai' example is not compatible with the Solid frontend.");
+	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid-start")) exitWithError("The 'ai' example is not compatible with the SolidStart frontend.");
+	if (examplesArr.includes("ai") && backend === "convex") {
+		const frontendArr = frontend ?? [];
+		const includesNuxt = frontendArr.includes("nuxt");
+		const includesSvelte = frontendArr.includes("svelte");
+		if (includesNuxt || includesSvelte) exitWithError("The 'ai' example with Convex backend only supports React-based frontends (Next.js, TanStack Router, TanStack Start, React Router, React + Vite). Svelte and Nuxt are not supported with Convex AI.");
+	}
+	if (examplesArr.includes("chat-sdk")) {
+		const frontendArr = frontend ?? [];
+		if (frontendArr.includes("react-vite")) exitWithError("The 'chat-sdk' example is not yet supported for React + Vite projects.");
+		if (!isExampleChatSdkAllowed$1(backend, frontendArr, runtime)) {
+			if (backend === "none") exitWithError("The 'chat-sdk' example requires a backend.");
+			if (backend === "convex") exitWithError("The 'chat-sdk' example is not supported with the Convex backend in v1. Use self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime.");
+			if (backend === "self") exitWithError("The 'chat-sdk' example with self backend only supports Next.js, TanStack Start, or Nuxt frontends in v1.");
+			if (backend === "hono" && runtime !== "node") exitWithError("The 'chat-sdk' example with Hono requires '--runtime node' in v1 (Bun/Workers not supported yet).");
+			exitWithError("The 'chat-sdk' example is only supported with self backend (Next.js, TanStack Start, Nuxt) or Hono with Node runtime in v1.");
+		}
+		if (requiresChatSdkVercelAI(backend, frontendArr, runtime) && ai && ai !== "vercel-ai") exitWithError("The 'chat-sdk' example requires '--ai vercel-ai' for the selected stack in v1 (Nuxt Discord and Hono GitHub profiles).");
+	}
+}
+/**
+* Validates that TanStack AI is only used with compatible frontends (React or Solid).
+* Server-side @tanstack/ai core works anywhere, but client adapters only exist for React and Solid.
+*/
+function validateAIFrontendCompatibility(ai, frontends = []) {
+	const issue = getAIFrontendCompatibilityIssue(ai, frontends);
+	if (!issue) return;
+	exitWithError(issue.message);
+}
+/**
+* Validates that a UI library is compatible with the selected frontend(s)
+*/
+function validateUILibraryFrontendCompatibility(uiLibrary, frontends = [], astroIntegration) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	const { web } = splitFrontends$1(frontends);
+	if (web.length === 0) return;
+	const compatible = getCompatibleUILibraries(frontends, astroIntegration);
+	if (!compatible.includes(uiLibrary)) {
+		const isAstroNonReact = web.includes("astro") && astroIntegration !== "react";
+		const supportsAstroReact = getCompatibleUILibraries(["astro"], "react").includes(uiLibrary);
+		if (isAstroNonReact && supportsAstroReact) {
+			incompatibilityError({
+				message: `UI library '${uiLibrary}' requires React.`,
+				provided: {
+					"ui-library": uiLibrary,
+					"astro-integration": astroIntegration || "none"
+				},
+				suggestions: ["Use --astro-integration react", "Choose a different UI library (daisyui, ark-ui)"]
+			});
+			return;
+		}
+		incompatibilityError({
+			message: `UI library '${uiLibrary}' is not compatible with the selected frontend.`,
+			provided: {
+				"ui-library": uiLibrary,
+				frontend: frontends
+			},
+			suggestions: [`Supported choices for this stack: ${compatible.join(", ")}`, "Choose a different UI library"]
+		});
+	}
+}
+/**
+* Validates that a UI library is compatible with the selected CSS framework
+*/
+function validateUILibraryCSSFrameworkCompatibility(uiLibrary, cssFramework) {
+	if (!uiLibrary || uiLibrary === "none") return;
+	if (!cssFramework) return;
+	const supported = getCompatibleCSSFrameworks(uiLibrary);
+	if (!supported.includes(cssFramework)) exitWithError(`UI library '${uiLibrary}' is not compatible with '${cssFramework}' CSS framework. Supported CSS frameworks: ${supported.join(", ")}`);
+}
+/**
+* Gets list of UI libraries compatible with the selected frontend(s)
+*/
+function getCompatibleUILibraries$1(frontends = [], astroIntegration) {
+	return getCompatibleUILibraries(frontends, astroIntegration);
+}
+/**
+* Gets list of CSS frameworks compatible with the selected UI library
+*/
+function getCompatibleCSSFrameworks$1(uiLibrary) {
+	return getCompatibleCSSFrameworks(uiLibrary);
+}
+/**
+* Checks if a frontend has web styling (excludes native-only frontends)
+*/
+function hasWebStyling$1(frontends = []) {
+	return hasWebStyling(frontends);
+}
+
+//#endregion
+//#region src/utils/navigation.ts
+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) {
+	let label;
+	let hint;
+	switch (addon) {
+		case "turborepo":
+			label = "Turborepo";
+			hint = "High-performance build system";
+			break;
+		case "pwa":
+			label = "PWA";
+			hint = "Make your app installable and work offline";
+			break;
+		case "tauri":
+			label = "Tauri";
+			hint = "Build native desktop apps from your web frontend";
+			break;
+		case "biome":
+			label = "Biome";
+			hint = "Format, lint, and more";
+			break;
+		case "oxlint":
+			label = "Oxlint";
+			hint = "Oxlint + Oxfmt (linting & formatting)";
+			break;
+		case "ultracite":
+			label = "Ultracite";
+			hint = "Zero-config Biome preset with AI integration";
+			break;
+		case "ruler":
+			label = "Ruler";
+			hint = "Centralize your AI rules";
+			break;
+		case "mcp":
+			label = "MCP";
+			hint = "Install MCP server recommendations for your stack";
+			break;
+		case "skills":
+			label = "Skills";
+			hint = "Install curated AI coding skills for your stack";
+			break;
+		case "lefthook":
+			label = "Lefthook";
+			hint = "Fast and powerful Git hooks manager";
+			break;
+		case "husky":
+			label = "Husky";
+			hint = "Modern native Git hooks made easy";
+			break;
+		case "starlight":
+			label = "Starlight";
+			hint = "Build stellar docs with astro";
+			break;
+		case "fumadocs":
+			label = "Fumadocs";
+			hint = "Build excellent documentation site";
+			break;
+		case "opentui":
+			label = "OpenTUI";
+			hint = "Build terminal user interfaces";
+			break;
+		case "wxt":
+			label = "WXT";
+			hint = "Build browser extensions";
+			break;
+		case "msw":
+			label = "MSW";
+			hint = "Mock Service Worker for API mocking";
+			break;
+		case "storybook":
+			label = "Storybook";
+			hint = "Component development and testing workshop";
+			break;
+		case "swr":
+			label = "SWR";
+			hint = "React Hooks for data fetching and caching";
+			break;
+		case "tanstack-query":
+			label = "TanStack Query";
+			hint = "Powerful async state management & data fetching";
+			break;
+		case "tanstack-table":
+			label = "TanStack Table";
+			hint = "Headless table with sorting, filtering & pagination";
+			break;
+		case "tanstack-virtual":
+			label = "TanStack Virtual";
+			hint = "Virtualize large lists & grids for 60fps performance";
+			break;
+		case "tanstack-db":
+			label = "TanStack DB";
+			hint = "Reactive client-first data store with sync backends (Beta)";
+			break;
+		case "tanstack-pacer":
+			label = "TanStack Pacer";
+			hint = "Debounce, throttle, rate-limit & queue utilities (Beta)";
+			break;
+		case "backend-utils":
+			label = "Backend Utils";
+			hint = "asyncHandler, ApiResponse & global error handler for your server";
+			break;
+		case "docker-compose":
+			label = "Docker Compose";
+			hint = "Containerize your app for deployment";
+			break;
+		default:
+			label = addon;
+			hint = `Add ${addon}`;
+	}
+	return {
+		label,
+		hint
+	};
+}
+const ADDON_GROUPS = {
+	Tooling: [
+		"turborepo",
+		"biome",
+		"oxlint",
+		"ultracite",
+		"husky",
+		"lefthook"
+	],
+	Documentation: ["starlight", "fumadocs"],
+	Extensions: [
+		"pwa",
+		"tauri",
+		"opentui",
+		"wxt",
+		"ruler",
+		"docker-compose"
+	],
+	Integrations: [
+		"msw",
+		"storybook",
+		"backend-utils"
+	],
+	"AI Agents": ["mcp", "skills"],
+	"Data Fetching": ["swr"],
+	TanStack: [
+		"tanstack-query",
+		"tanstack-table",
+		"tanstack-virtual",
+		"tanstack-db",
+		"tanstack-pacer"
+	]
+};
+function createGroupedAddonOptions() {
+	return Object.fromEntries(Object.keys(ADDON_GROUPS).map((group$1) => [group$1, []]));
+}
+function getAddonGroup(addon) {
+	return Object.entries(ADDON_GROUPS).find(([, addons]) => addons.includes(addon))?.[0];
+}
+function validateAddonCompatibilityForPrompt(addon, frontends, auth, backend, runtime) {
+	return validateAddonCompatibility$1(addon, frontends, auth, backend, runtime);
+}
+function getCompatibleAddonsForPrompt(allAddons, frontends, existingAddons = [], auth, backend, runtime) {
+	return getCompatibleAddons$1(allAddons, frontends, existingAddons, auth, backend, runtime);
+}
+async function getAddonsChoice(addons, frontends, auth, backend, runtime) {
+	if (addons !== void 0) return addons;
+	const allAddons = types_exports.AddonsSchema.options.filter((addon) => addon !== "none");
+	const groupedOptions = createGroupedAddonOptions();
+	const frontendsArray = frontends || [];
+	for (const addon of allAddons) {
+		const { isCompatible } = validateAddonCompatibilityForPrompt(addon, frontendsArray, auth, backend, runtime);
+		if (!isCompatible) continue;
+		const { label, hint } = getAddonDisplay(addon);
+		const option = {
+			value: addon,
+			label,
+			hint
+		};
+		const group$1 = getAddonGroup(addon);
+		if (group$1) groupedOptions[group$1].push(option);
+	}
+	Object.keys(groupedOptions).forEach((group$1) => {
+		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
+		else {
+			const groupOrder = ADDON_GROUPS[group$1] || [];
+			groupedOptions[group$1].sort((a, b) => {
+				return groupOrder.indexOf(a.value) - groupOrder.indexOf(b.value);
+			});
+		}
+	});
+	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
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getAddonsToAdd(frontend, existingAddons = [], auth, backend, runtime) {
+	const groupedOptions = createGroupedAddonOptions();
+	const frontendArray = frontend || [];
+	const compatibleAddons = getCompatibleAddonsForPrompt(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, existingAddons, auth, backend, runtime);
+	for (const addon of compatibleAddons) {
+		const { label, hint } = getAddonDisplay(addon);
+		const option = {
+			value: addon,
+			label,
+			hint
+		};
+		const group$1 = getAddonGroup(addon);
+		if (group$1) groupedOptions[group$1].push(option);
+	}
+	Object.keys(groupedOptions).forEach((group$1) => {
+		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
+		else {
+			const groupOrder = ADDON_GROUPS[group$1] || [];
+			groupedOptions[group$1].sort((a, b) => {
+				return groupOrder.indexOf(a.value) - groupOrder.indexOf(b.value);
+			});
+		}
+	});
+	if (Object.keys(groupedOptions).length === 0) return [];
+	const response = await navigableGroupMultiselect({
+		message: "Select addons to add",
+		options: groupedOptions,
+		required: false
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+
+//#endregion
+//#region src/utils/dependency-version-channel.ts
+const VERSION_CACHE = /* @__PURE__ */ new Map();
+const PRERELEASE_TAG_PRIORITY = [
+	"beta",
+	"next",
+	"rc",
+	"canary",
+	"alpha"
+];
+const REGISTRY_FETCH_TIMEOUT_MS = 1e4;
+const REGISTRY_CONCURRENCY = 10;
+function mapWithConcurrency(items, fn, concurrency) {
+	const results = Array.from({ length: items.length });
+	let index = 0;
+	async function worker() {
+		while (index < items.length) {
+			const i = index++;
+			results[i] = await fn(items[i], i);
+		}
+	}
+	return Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker())).then(() => results);
+}
+function parseVersion(value) {
+	const normalized = value.replace(/^[^\d]*/, "");
+	const dashIdx = normalized.indexOf("-");
+	const base = dashIdx === -1 ? normalized : normalized.slice(0, dashIdx);
+	const prerelease = dashIdx === -1 ? "" : normalized.slice(dashIdx + 1);
+	const [major = "0", minor = "0", patch = "0"] = base.split(".");
+	return {
+		major: Number(major) || 0,
+		minor: Number(minor) || 0,
+		patch: Number(patch) || 0,
+		prerelease: prerelease ? prerelease.split(/[.-]/).map((part) => /^\d+$/.test(part) ? Number(part) : part) : []
+	};
+}
+function compareVersions(a, b) {
+	const left = parseVersion(a);
+	const right = parseVersion(b);
+	if (left.major !== right.major) return left.major - right.major;
+	if (left.minor !== right.minor) return left.minor - right.minor;
+	if (left.patch !== right.patch) return left.patch - right.patch;
+	if (left.prerelease.length === 0 && right.prerelease.length === 0) return 0;
+	if (left.prerelease.length === 0) return 1;
+	if (right.prerelease.length === 0) return -1;
+	const maxLength = Math.max(left.prerelease.length, right.prerelease.length);
+	for (let index = 0; index < maxLength; index++) {
+		const leftPart = left.prerelease[index];
+		const rightPart = right.prerelease[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		if (leftPart === rightPart) continue;
+		if (typeof leftPart === "number" && typeof rightPart === "number") return leftPart - rightPart;
+		if (typeof leftPart === "number") return -1;
+		if (typeof rightPart === "number") return 1;
+		return leftPart.localeCompare(rightPart);
+	}
+	return 0;
+}
+function isPrerelease(version) {
+	return /-(alpha|beta|rc|next|canary)/i.test(version);
+}
+function getVersionPrefix(version) {
+	return version.match(/^[^\d]*/)?.[0] ?? "";
+}
+function applyVersionPrefix(currentVersion, resolvedVersion) {
+	return `${getVersionPrefix(currentVersion)}${resolvedVersion}`;
+}
+function isRegistrySemverSpec(version) {
+	return /^[~^]?\d/.test(version);
+}
+async function fetchPackageInfo(packageName) {
+	const cached = VERSION_CACHE.get(packageName);
+	if (cached) return cached;
+	const encodedName = encodeURIComponent(packageName).replace("%40", "@");
+	const response = await fetch(`https://registry.npmjs.org/${encodedName}`, {
+		headers: { Accept: "application/vnd.npm.install-v1+json" },
+		signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error(`Package ${packageName} not found (${response.status})`);
+	const raw = await response.json();
+	const data = {
+		"dist-tags": raw["dist-tags"],
+		versions: raw["versions"]
+	};
+	VERSION_CACHE.set(packageName, data);
+	return data;
+}
+function selectRegistryVersionForChannel(packageInfo, channel) {
+	const tags = packageInfo["dist-tags"] ?? {};
+	if (channel === "latest") return tags.latest ?? null;
+	for (const tag of PRERELEASE_TAG_PRIORITY) if (tags[tag]) return tags[tag];
+	const prereleases = Object.keys(packageInfo.versions ?? {}).filter(isPrerelease);
+	if (prereleases.length > 0) return prereleases.sort((left, right) => compareVersions(right, left))[0] ?? null;
+	return tags.latest ?? null;
+}
+async function resolveRegistryVersion(packageName, channel) {
+	const version = selectRegistryVersionForChannel(await fetchPackageInfo(packageName), channel);
+	if (!version) throw new Error(`No ${channel} version available for ${packageName}`);
+	return version;
+}
+async function collectPackageJsonPaths(projectDir) {
+	const results = [];
+	async function walk(currentDir) {
+		const entries = await fs.readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".turbo") continue;
+			const fullPath = path.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				await walk(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name === "package.json") results.push(fullPath);
+		}
+	}
+	await walk(projectDir);
+	return results.sort();
+}
+async function applyDependencyVersionChannel(projectDir, channel) {
+	if (channel === "stable") return;
+	const packageJsonPaths = await collectPackageJsonPaths(projectDir);
+	if (packageJsonPaths.length === 0) return;
+	const packageNames = /* @__PURE__ */ new Set();
+	for (const packageJsonPath of packageJsonPaths) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		for (const [depName, depVersion] of Object.entries(packageJson.dependencies ?? {})) if (typeof depVersion === "string" && isRegistrySemverSpec(depVersion)) packageNames.add(depName);
+		for (const [depName, depVersion] of Object.entries(packageJson.devDependencies ?? {})) if (typeof depVersion === "string" && isRegistrySemverSpec(depVersion)) packageNames.add(depName);
+	}
+	if (packageNames.size === 0) return;
+	const resolvedVersions = /* @__PURE__ */ new Map();
+	await mapWithConcurrency([...packageNames], async (packageName) => {
+		try {
+			const resolvedVersion = await resolveRegistryVersion(packageName, channel);
+			resolvedVersions.set(packageName, resolvedVersion);
+		} catch (error) {
+			log.warn(`Failed to resolve ${channel} version for ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}, REGISTRY_CONCURRENCY);
+	if (resolvedVersions.size === 0) return;
+	for (const packageJsonPath of packageJsonPaths) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		let changed = false;
+		for (const sectionName of ["dependencies", "devDependencies"]) {
+			const section = packageJson[sectionName];
+			if (!section) continue;
+			for (const [packageName, currentVersion] of Object.entries(section)) {
+				if (!isRegistrySemverSpec(currentVersion)) continue;
+				const resolvedVersion = resolvedVersions.get(packageName);
+				if (!resolvedVersion) continue;
+				const nextVersion = applyVersionPrefix(currentVersion, resolvedVersion);
+				if (nextVersion !== currentVersion) {
+					section[packageName] = nextVersion;
+					changed = true;
+				}
+			}
+		}
+		if (changed) await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
+
+//#endregion
+//#region src/helpers/core/install-dependencies.ts
+function getInstallEnvironment(packageManager) {
+	if (packageManager === "yarn") return {
+		YARN_ENABLE_HARDENED_MODE: "0",
+		YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
+	};
+}
+function getInstallArgs(packageManager) {
+	if (packageManager === "pnpm") return ["install", "--dangerously-allow-all-builds"];
+	return ["install"];
+}
+async function installDependencies({ projectDir, packageManager }) {
+	const s = spinner();
+	try {
+		s.start(`Running ${packageManager} install...`);
+		const installArgs = getInstallArgs(packageManager);
+		await $({
+			cwd: projectDir,
+			env: {
+				...process.env,
+				...getInstallEnvironment(packageManager)
+			},
+			stderr: "inherit"
+		})`${packageManager} ${installArgs}`;
+		s.stop("Dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("Failed to install dependencies"));
+		if (error instanceof Error) consola.error(pc.red(`Installation error: ${error.message}`));
+	}
+}
+async function runCargoBuild({ projectDir }) {
+	const s = spinner();
+	try {
+		s.start("Running cargo build...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`cargo build`;
+		s.stop("Cargo build completed");
+	} catch (error) {
+		s.stop(pc.red("Cargo build failed"));
+		if (error instanceof Error) consola.error(pc.red(`Cargo build error: ${error.message}`));
+	}
+}
+async function runUvSync({ projectDir }) {
+	const s = spinner();
+	try {
+		s.start("Running uv sync...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`uv sync`;
+		s.stop("Python dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("uv sync failed"));
+		if (error instanceof Error) consola.error(pc.red(`uv sync error: ${error.message}`));
+	}
+}
+async function runGoModTidy({ projectDir }) {
+	const s = spinner();
+	try {
+		s.start("Running go mod tidy...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`go mod tidy`;
+		s.stop("Go dependencies installed successfully");
+	} catch (error) {
+		s.stop(pc.red("go mod tidy failed"));
+		if (error instanceof Error) consola.error(pc.red(`go mod tidy error: ${error.message}`));
+	}
+}
+async function runMavenTests({ projectDir }) {
+	const s = spinner();
+	const mvnw = process.platform === "win32" ? "mvnw.cmd" : "./mvnw";
+	try {
+		s.start("Running Maven tests...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`${mvnw} test`;
+		s.stop("Maven tests completed");
+	} catch (error) {
+		s.stop(pc.red("Maven tests failed"));
+		if (error instanceof Error) consola.error(pc.red(`Maven test error: ${error.message}`));
+	}
+}
+async function runGradleTests({ projectDir }) {
+	const s = spinner();
+	const gradlew = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+	try {
+		s.start("Running Gradle tests...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`${gradlew} test`;
+		s.stop("Gradle tests completed");
+	} catch (error) {
+		s.stop(pc.red("Gradle tests failed"));
+		if (error instanceof Error) consola.error(pc.red(`Gradle test error: ${error.message}`));
+	}
+}
+async function runMixCompile({ projectDir }) {
+	const s = spinner();
+	try {
+		s.start("Running mix deps.get and mix compile...");
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`mix deps.get`;
+		await $({
+			cwd: projectDir,
+			stderr: "inherit"
+		})`mix compile`;
+		s.stop("Elixir dependencies installed and project compiled");
+	} catch (error) {
+		s.stop(pc.red("mix compile failed"));
+		if (error instanceof Error) consola.error(pc.red(`Mix error: ${error.message}`));
+	}
+}
+
+//#endregion
+export { validateAddonsAgainstFrontends as A, validateWorkersCompatibility as B, isExampleAIAllowed$1 as C, requiresChatSdkVercelAI as D, isWebFrontend$1 as E, validateServerDeployRequiresBackend as F, incompatibilityError as H, validateUILibraryCSSFrameworkCompatibility as I, validateUILibraryFrontendCompatibility as L, validateExamplesCompatibility as M, validatePaymentsCompatibility as N, splitFrontends$1 as O, validateSelfBackendCompatibility as P, validateWebDeployFrontendTemplates as R, hasWebStyling$1 as S, isFrontendAllowedWithBackend$1 as T, missingRequirementError as U, constraintError as V, renderTitle as W, isGoBack as _, runMavenTests as a, getCompatibleCSSFrameworks$1 as b, applyDependencyVersionChannel as c, isCancel$1 as d, navigableConfirm as f, GO_BACK_SYMBOL as g, setIsFirstPrompt as h, runGradleTests as i, validateApiFrontendCompatibility as j, validateAIFrontendCompatibility as k, getAddonsChoice as l, navigableSelect as m, runCargoBuild as n, runMixCompile as o, navigableMultiselect as p, runGoModTidy as r, runUvSync as s, installDependencies as t, getAddonsToAdd as u, allowedApisForFrontends$1 as v, isExampleChatSdkAllowed$1 as w, getCompatibleUILibraries$1 as x, ensureSingleWebAndNative as y, validateWebDeployRequiresWebFrontend as z };