create-better-fullstack 1.6.0 → 1.6.2

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { t as __reExport } from "./chunk-CCII7kTE.mjs";
-import { a as DEFAULT_CONFIG, c as getDefaultConfig, i as getLatestCLIVersion, l as getUserPkgManager, n as updateBtsConfig, o as DEFAULT_UI_LIBRARY_BY_FRONTEND, r as writeBtsConfig, t as readBtsConfig } from "./bts-config-snHxP_EH.mjs";
-import { _ as setLastPromptShownUI, a as getPackageExecutionArgs, c as UserCancelledError, d as handleError, f as didLastPromptShowUI, g as setIsFirstPrompt$1, h as runWithContextAsync, l as exitCancelled, m as isSilent, o as addPackageDependency, p as isFirstPrompt, s as CLIError, t as setupAddons, u as exitWithError } from "./addons-setup--oB72n29.mjs";
+import { a as DEFAULT_CONFIG, c as getDefaultConfig, i as getLatestCLIVersion, l as getUserPkgManager, n as updateBtsConfig, o as DEFAULT_UI_LIBRARY_BY_FRONTEND, r as writeBtsConfig, t as readBtsConfig } from "./bts-config-B_rZ4_sj.mjs";
+import { _ as setIsFirstPrompt$1, a as canPromptInteractively, c as CLIError, d as exitWithError, f as handleError, g as runWithContextAsync, h as isSilent, l as UserCancelledError, m as isFirstPrompt, o as getPackageExecutionArgs, p as didLastPromptShowUI, s as addPackageDependency, t as setupAddons, u as exitCancelled, v as setLastPromptShownUI } from "./addons-setup-DQa6TRrx.mjs";
 import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
@@ -10,11 +10,11 @@ import z from "zod";
 import envPaths from "env-paths";
 import fs from "fs-extra";
 import path from "node:path";
+import { allowedApisForFrontends, getCompatibleAddons, getCompatibleCSSFrameworks, getCompatibleUILibraries, getLocalWebDevPort, hasWebStyling, isExampleAIAllowed, isExampleChatSdkAllowed, isFrontendAllowedWithBackend, isWebFrontend, requiresChatSdkVercelAIForSelection, splitFrontends, validateAddonCompatibility } from "@better-fullstack/types";
 import { ECOSYSTEM_GROUPS, EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, checkAllVersions, generateCliReport, generateVirtualProject, generateVirtualProject as generateVirtualProject$1, listEcosystems, processAddonTemplates, processAddonsDeps, validatePreflightConfig } from "@better-fullstack/template-generator";
 import gradient from "gradient-string";
 import path$1 from "path";
 import { writeTreeToFilesystem } from "@better-fullstack/template-generator/fs-writer";
-import { allowedApisForFrontends, getCompatibleAddons, getCompatibleCSSFrameworks, getCompatibleUILibraries, getLocalWebDevPort, hasWebStyling, isExampleAIAllowed, isExampleChatSdkAllowed, isFrontendAllowedWithBackend, isWebFrontend, requiresChatSdkVercelAIForSelection, splitFrontends, validateAddonCompatibility } from "@better-fullstack/types";
 import consola, { consola as consola$1 } from "consola";
 import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
 import { $, execa } from "execa";
@@ -354,6 +354,100 @@ var types_exports = {};
 import * as import__better_fullstack_types from "@better-fullstack/types";
 __reExport(types_exports, import__better_fullstack_types);
 
+//#endregion
+//#region src/create-command-input.ts
+const CreateCommandOptionsSchema = z.object({
+	template: types_exports.TemplateSchema.optional().describe("Use a predefined template"),
+	yes: z.boolean().optional().default(false).describe("Use default configuration"),
+	yolo: z.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
+	verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
+	dryRun: z.boolean().optional().default(false).describe("Preview generated file tree without writing to disk"),
+	ecosystem: types_exports.EcosystemSchema.optional().describe("Language ecosystem (typescript, rust, python, go, or java)"),
+	database: types_exports.DatabaseSchema.optional(),
+	orm: types_exports.ORMSchema.optional(),
+	auth: types_exports.AuthSchema.optional(),
+	payments: types_exports.PaymentsSchema.optional(),
+	email: types_exports.EmailSchema.optional(),
+	fileUpload: types_exports.FileUploadSchema.optional(),
+	effect: types_exports.EffectSchema.optional(),
+	stateManagement: types_exports.StateManagementSchema.optional(),
+	validation: types_exports.ValidationSchema.optional(),
+	forms: types_exports.FormsSchema.optional(),
+	testing: types_exports.TestingSchema.optional(),
+	ai: types_exports.AISchema.optional(),
+	realtime: types_exports.RealtimeSchema.optional(),
+	jobQueue: types_exports.JobQueueSchema.optional(),
+	animation: types_exports.AnimationSchema.optional(),
+	logging: types_exports.LoggingSchema.optional(),
+	observability: types_exports.ObservabilitySchema.optional(),
+	featureFlags: types_exports.FeatureFlagsSchema.optional().describe("Feature flags provider"),
+	analytics: types_exports.AnalyticsSchema.optional().describe("Privacy-focused analytics"),
+	cms: types_exports.CMSSchema.optional().describe("Headless CMS solution"),
+	caching: types_exports.CachingSchema.optional().describe("Caching solution"),
+	i18n: types_exports.I18nSchema.optional().describe("Internationalization (i18n) library"),
+	search: types_exports.SearchSchema.optional().describe("Search engine solution"),
+	fileStorage: types_exports.FileStorageSchema.optional().describe("File storage solution (S3, R2)"),
+	frontend: z.array(types_exports.FrontendSchema).optional(),
+	astroIntegration: types_exports.AstroIntegrationSchema.optional().describe("Astro UI framework integration (react, vue, svelte, solid)"),
+	addons: z.array(types_exports.AddonsSchema).optional(),
+	examples: z.array(types_exports.ExamplesSchema).optional(),
+	git: z.boolean().optional(),
+	packageManager: types_exports.PackageManagerSchema.optional(),
+	install: z.boolean().optional(),
+	versionChannel: types_exports.VersionChannelSchema.optional().describe("Dependency version channel (stable, latest, beta)"),
+	dbSetup: types_exports.DatabaseSetupSchema.optional(),
+	backend: types_exports.BackendSchema.optional(),
+	runtime: types_exports.RuntimeSchema.optional(),
+	api: types_exports.APISchema.optional(),
+	cssFramework: types_exports.CSSFrameworkSchema.optional(),
+	uiLibrary: types_exports.UILibrarySchema.optional(),
+	shadcnBase: types_exports.ShadcnBaseSchema.optional().describe("shadcn/ui headless library (radix, base)"),
+	shadcnStyle: types_exports.ShadcnStyleSchema.optional().describe("shadcn/ui visual style (vega, nova, maia, lyra, mira)"),
+	shadcnIconLibrary: types_exports.ShadcnIconLibrarySchema.optional().describe("shadcn/ui icon library (lucide, tabler, hugeicons, phosphor, remixicon)"),
+	shadcnColorTheme: types_exports.ShadcnColorThemeSchema.optional().describe("shadcn/ui color theme (neutral, blue, violet, etc.)"),
+	shadcnBaseColor: types_exports.ShadcnBaseColorSchema.optional().describe("shadcn/ui base neutral color (neutral, stone, zinc, gray)"),
+	shadcnFont: types_exports.ShadcnFontSchema.optional().describe("shadcn/ui font (inter, geist, figtree, etc.)"),
+	shadcnRadius: types_exports.ShadcnRadiusSchema.optional().describe("shadcn/ui border radius (default, none, small, medium, large)"),
+	webDeploy: types_exports.WebDeploySchema.optional(),
+	serverDeploy: types_exports.ServerDeploySchema.optional(),
+	directoryConflict: types_exports.DirectoryConflictSchema.optional(),
+	renderTitle: z.boolean().optional(),
+	disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
+	manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup"),
+	rustWebFramework: types_exports.RustWebFrameworkSchema.optional().describe("Rust web framework (axum, actix-web)"),
+	rustFrontend: types_exports.RustFrontendSchema.optional().describe("Rust WASM frontend (leptos, dioxus)"),
+	rustOrm: types_exports.RustOrmSchema.optional().describe("Rust ORM/database (sea-orm, sqlx)"),
+	rustApi: types_exports.RustApiSchema.optional().describe("Rust API layer (tonic, async-graphql)"),
+	rustCli: types_exports.RustCliSchema.optional().describe("Rust CLI tools (clap, ratatui)"),
+	rustLibraries: z.array(types_exports.RustLibrariesSchema).optional().describe("Rust core libraries"),
+	rustLogging: types_exports.RustLoggingSchema.optional().describe("Rust logging (tracing, env-logger)"),
+	rustErrorHandling: types_exports.RustErrorHandlingSchema.optional().describe("Rust error handling (anyhow-thiserror, eyre)"),
+	rustCaching: types_exports.RustCachingSchema.optional().describe("Rust caching (moka, redis)"),
+	rustAuth: types_exports.RustAuthSchema.optional().describe("Rust auth (oauth2)"),
+	pythonWebFramework: types_exports.PythonWebFrameworkSchema.optional().describe("Python web framework (fastapi, django)"),
+	pythonOrm: types_exports.PythonOrmSchema.optional().describe("Python ORM/database (sqlalchemy, sqlmodel)"),
+	pythonValidation: types_exports.PythonValidationSchema.optional().describe("Python validation (pydantic)"),
+	pythonAi: z.array(types_exports.PythonAiSchema).optional().describe("Python AI/ML frameworks"),
+	pythonAuth: types_exports.PythonAuthSchema.optional().describe("Python auth library (authlib, jwt)"),
+	pythonTaskQueue: types_exports.PythonTaskQueueSchema.optional().describe("Python task queue (celery)"),
+	pythonGraphql: types_exports.PythonGraphqlSchema.optional().describe("Python GraphQL framework (strawberry)"),
+	pythonQuality: types_exports.PythonQualitySchema.optional().describe("Python code quality (ruff)"),
+	goWebFramework: types_exports.GoWebFrameworkSchema.optional().describe("Go web framework (gin, echo, fiber)"),
+	goOrm: types_exports.GoOrmSchema.optional().describe("Go ORM/database (gorm, sqlc)"),
+	goApi: types_exports.GoApiSchema.optional().describe("Go API layer (grpc-go)"),
+	goCli: types_exports.GoCliSchema.optional().describe("Go CLI tools (cobra, bubbletea)"),
+	goLogging: types_exports.GoLoggingSchema.optional().describe("Go logging (zap, zerolog, slog)"),
+	goAuth: types_exports.GoAuthSchema.optional().describe("Go auth (casbin, jwt)"),
+	javaWebFramework: types_exports.JavaWebFrameworkSchema.optional().describe("Java web framework (spring-boot, none)"),
+	javaBuildTool: types_exports.JavaBuildToolSchema.optional().describe("Java build tool (maven, gradle, none)"),
+	javaOrm: types_exports.JavaOrmSchema.optional().describe("Java ORM/database (spring-data-jpa)"),
+	javaAuth: types_exports.JavaAuthSchema.optional().describe("Java auth (spring-security)"),
+	javaLibraries: z.array(types_exports.JavaLibrariesSchema).optional().describe("Java application libraries"),
+	javaTestingLibraries: z.array(types_exports.JavaTestingLibrariesSchema).optional().describe("Java testing libraries"),
+	aiDocs: z.array(types_exports.AiDocsSchema).optional().describe("AI documentation files (claude-md, agents-md, cursorrules)")
+});
+const CreateCommandInputSchema = z.tuple([types_exports.ProjectNameSchema.optional(), CreateCommandOptionsSchema]);
+
 //#endregion
 //#region src/utils/error-formatter.ts
 function getCategoryTitle(category) {
@@ -1341,12 +1435,23 @@ async function applyDependencyVersionChannel(projectDir, channel) {
 
 //#endregion
 //#region src/helpers/core/install-dependencies.ts
+function getInstallEnvironment(packageManager) {
+	if (packageManager !== "yarn") return;
+	return {
+		YARN_ENABLE_HARDENED_MODE: "0",
+		YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
+	};
+}
 async function installDependencies({ projectDir, packageManager }) {
 	const s = spinner();
 	try {
 		s.start(`Running ${packageManager} install...`);
 		await $({
 			cwd: projectDir,
+			env: {
+				...process.env,
+				...getInstallEnvironment(packageManager)
+			},
 			stderr: "inherit"
 		})`${packageManager} install`;
 		s.stop("Dependencies installed successfully");
@@ -1397,6 +1502,36 @@ async function runGoModTidy({ projectDir }) {
 		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}`));
+	}
+}
 
 //#endregion
 //#region src/helpers/core/add-handler.ts
@@ -1535,70 +1670,104 @@ async function collectPackageJsonPaths(projectDir) {
 	return results;
 }
 
+//#endregion
+//#region src/prompts/prompt-contract.ts
+function createStaticSinglePromptResolution(options, initialValue, selectedValue) {
+	return selectedValue !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: selectedValue
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue
+	};
+}
+function createStaticMultiPromptResolution(options, initialValue, selectedValue) {
+	return selectedValue !== void 0 ? {
+		shouldPrompt: false,
+		mode: "multiple",
+		options,
+		autoValue: selectedValue
+	} : {
+		shouldPrompt: true,
+		mode: "multiple",
+		options,
+		initialValue
+	};
+}
+
 //#endregion
 //#region src/prompts/ai.ts
+const AI_PROMPT_OPTIONS = [
+	{
+		value: "vercel-ai",
+		label: "Vercel AI SDK",
+		hint: "The AI Toolkit for TypeScript - supports OpenAI, Anthropic, Google, etc."
+	},
+	{
+		value: "mastra",
+		label: "Mastra",
+		hint: "TypeScript-native AI agent framework with workflows"
+	},
+	{
+		value: "voltagent",
+		label: "VoltAgent",
+		hint: "AI Agent framework with memory, workflows, and observability"
+	},
+	{
+		value: "langgraph",
+		label: "LangGraph.js",
+		hint: "Graph-based agent orchestration with stateful workflows"
+	},
+	{
+		value: "openai-agents",
+		label: "OpenAI Agents SDK",
+		hint: "Official multi-agent framework with handoffs and guardrails"
+	},
+	{
+		value: "google-adk",
+		label: "Google ADK",
+		hint: "Code-first agent development kit for building AI agents"
+	},
+	{
+		value: "modelfusion",
+		label: "ModelFusion",
+		hint: "Type-safe AI library for multi-provider text generation"
+	},
+	{
+		value: "langchain",
+		label: "LangChain",
+		hint: "Build context-aware reasoning applications"
+	},
+	{
+		value: "llamaindex",
+		label: "LlamaIndex",
+		hint: "Data framework for LLM applications"
+	},
+	{
+		value: "tanstack-ai",
+		label: "TanStack AI",
+		hint: "Unified LLM interface for AI-powered apps (Alpha)"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No AI SDK"
+	}
+];
+function resolveAIPrompt(ai) {
+	return createStaticSinglePromptResolution(AI_PROMPT_OPTIONS, "none", ai);
+}
 async function getAIChoice(ai) {
-	if (ai !== void 0) return ai;
+	const resolution = resolveAIPrompt(ai);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select AI SDK",
-		options: [
-			{
-				value: "vercel-ai",
-				label: "Vercel AI SDK",
-				hint: "The AI Toolkit for TypeScript - supports OpenAI, Anthropic, Google, etc."
-			},
-			{
-				value: "mastra",
-				label: "Mastra",
-				hint: "TypeScript-native AI agent framework with workflows"
-			},
-			{
-				value: "voltagent",
-				label: "VoltAgent",
-				hint: "AI Agent framework with memory, workflows, and observability"
-			},
-			{
-				value: "langgraph",
-				label: "LangGraph.js",
-				hint: "Graph-based agent orchestration with stateful workflows"
-			},
-			{
-				value: "openai-agents",
-				label: "OpenAI Agents SDK",
-				hint: "Official multi-agent framework with handoffs and guardrails"
-			},
-			{
-				value: "google-adk",
-				label: "Google ADK",
-				hint: "Code-first agent development kit for building AI agents"
-			},
-			{
-				value: "modelfusion",
-				label: "ModelFusion",
-				hint: "Type-safe AI library for multi-provider text generation"
-			},
-			{
-				value: "langchain",
-				label: "LangChain",
-				hint: "Build context-aware reasoning applications"
-			},
-			{
-				value: "llamaindex",
-				label: "LlamaIndex",
-				hint: "Data framework for LLM applications"
-			},
-			{
-				value: "tanstack-ai",
-				label: "TanStack AI",
-				hint: "Unified LLM interface for AI-powered apps (Alpha)"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No AI SDK"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1642,10 +1811,20 @@ async function getAiDocsChoice(aiDocs) {
 
 //#endregion
 //#region src/prompts/animation.ts
-async function getAnimationChoice(animation, frontends) {
-	if (animation !== void 0) return animation;
-	const { web } = splitFrontends$1(frontends);
-	if (web.length === 0) return "none";
+function resolveAnimationPrompt(context = {}) {
+	if (context.animation !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.animation
+	};
+	const { web } = splitFrontends$1(context.frontends);
+	if (web.length === 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
 	const isReact = web.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -1684,10 +1863,23 @@ async function getAnimationChoice(animation, frontends) {
 		label: "None",
 		hint: "Skip animation library setup"
 	});
-	const response = await navigableSelect({
-		message: "Select animation library",
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options,
 		initialValue: "none"
+	};
+}
+async function getAnimationChoice(animation, frontends) {
+	const resolution = resolveAnimationPrompt({
+		animation,
+		frontends
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select animation library",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1695,47 +1887,72 @@ async function getAnimationChoice(animation, frontends) {
 
 //#endregion
 //#region src/prompts/api.ts
-async function getApiChoice(Api, frontend, backend, astroIntegration) {
-	if (backend === "convex" || backend === "none") return "none";
-	const allowed = allowedApisForFrontends$1(frontend ?? [], astroIntegration);
-	if (Api) return allowed.includes(Api) ? Api : allowed[0];
-	const apiOptionMap = {
-		trpc: {
-			value: "trpc",
-			label: "tRPC",
-			hint: "End-to-end typesafe APIs made easy"
-		},
-		orpc: {
-			value: "orpc",
-			label: "oRPC",
-			hint: "End-to-end type-safe APIs that adhere to OpenAPI standards"
-		},
-		"ts-rest": {
-			value: "ts-rest",
-			label: "ts-rest",
-			hint: "RPC-like client, contract, and server implementation for REST APIs"
-		},
-		garph: {
-			value: "garph",
-			label: "Garph",
-			hint: "Fullstack GraphQL framework with end-to-end type safety"
-		},
-		"graphql-yoga": {
-			value: "graphql-yoga",
-			label: "GraphQL Yoga",
-			hint: "Batteries-included GraphQL server with Pothos schema builder"
-		},
-		none: {
-			value: "none",
-			label: "None",
-			hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
-		}
+const API_PROMPT_OPTION_MAP = {
+	trpc: {
+		value: "trpc",
+		label: "tRPC",
+		hint: "End-to-end typesafe APIs made easy"
+	},
+	orpc: {
+		value: "orpc",
+		label: "oRPC",
+		hint: "End-to-end type-safe APIs that adhere to OpenAPI standards"
+	},
+	"ts-rest": {
+		value: "ts-rest",
+		label: "ts-rest",
+		hint: "RPC-like client, contract, and server implementation for REST APIs"
+	},
+	garph: {
+		value: "garph",
+		label: "Garph",
+		hint: "Fullstack GraphQL framework with end-to-end type safety"
+	},
+	"graphql-yoga": {
+		value: "graphql-yoga",
+		label: "GraphQL Yoga",
+		hint: "Batteries-included GraphQL server with Pothos schema builder"
+	},
+	none: {
+		value: "none",
+		label: "None",
+		hint: "No API layer (e.g. for full-stack frameworks like Next.js with Route Handlers)"
+	}
+};
+function resolveApiPrompt(context = {}) {
+	if (context.backend === "convex" || context.backend === "none") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	const allowedOptions = allowedApisForFrontends$1(context.frontend ?? [], context.astroIntegration);
+	const options = allowedOptions.map((value) => API_PROMPT_OPTION_MAP[value]);
+	if (context.api !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: allowedOptions.includes(context.api) ? context.api : allowedOptions[0] ?? "none"
 	};
-	const apiOptions = allowed.map((a) => apiOptionMap[a]);
+	return {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue: allowedOptions[0] ?? "none"
+	};
+}
+async function getApiChoice(api, frontend, backend, astroIntegration) {
+	const resolution = resolveApiPrompt({
+		api,
+		frontend,
+		backend,
+		astroIntegration
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const apiType = await navigableSelect({
 		message: "Select API type",
-		options: apiOptions,
-		initialValue: apiOptions[0].value
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(apiType)) return exitCancelled("Operation cancelled");
 	return apiType;
@@ -1743,38 +1960,43 @@ async function getApiChoice(Api, frontend, backend, astroIntegration) {
 
 //#endregion
 //#region src/prompts/astro-integration.ts
+const ASTRO_INTEGRATION_PROMPT_OPTIONS = [
+	{
+		value: "react",
+		label: "React",
+		hint: "Full React component support (required for tRPC)"
+	},
+	{
+		value: "vue",
+		label: "Vue",
+		hint: "Vue 3 component support"
+	},
+	{
+		value: "svelte",
+		label: "Svelte",
+		hint: "Svelte component support"
+	},
+	{
+		value: "solid",
+		label: "Solid",
+		hint: "SolidJS component support"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Astro components only (no client-side JS framework)"
+	}
+];
+function resolveAstroIntegrationPrompt(astroIntegration) {
+	return createStaticSinglePromptResolution(ASTRO_INTEGRATION_PROMPT_OPTIONS, "react", astroIntegration);
+}
 async function getAstroIntegrationChoice(astroIntegration) {
-	if (astroIntegration !== void 0) return astroIntegration;
+	const resolution = resolveAstroIntegrationPrompt(astroIntegration);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Choose Astro UI framework integration",
-		options: [
-			{
-				value: "react",
-				label: "React",
-				hint: "Full React component support (required for tRPC)"
-			},
-			{
-				value: "vue",
-				label: "Vue",
-				hint: "Vue 3 component support"
-			},
-			{
-				value: "svelte",
-				label: "Svelte",
-				hint: "Svelte component support"
-			},
-			{
-				value: "solid",
-				label: "Solid",
-				hint: "SolidJS component support"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Astro components only (no client-side JS framework)"
-			}
-		],
-		initialValue: "react"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1782,8 +2004,7 @@ async function getAstroIntegrationChoice(astroIntegration) {
 
 //#endregion
 //#region src/prompts/auth.ts
-async function getAuthChoice(auth, backend, frontend, ecosystem = "typescript") {
-	if (auth !== void 0) return auth;
+function resolveAuthPrompt(context = {}) {
 	const authOptionOrder = [
 		{ value: "better-auth" },
 		{ value: "go-better-auth" },
@@ -1795,23 +2016,49 @@ async function getAuthChoice(auth, backend, frontend, ecosystem = "typescript")
 		{ value: "none" }
 	];
 	const supportedOptions = (0, types_exports.getSupportedCapabilityOptions)("auth", {
-		ecosystem,
-		backend,
-		frontend
+		ecosystem: context.ecosystem ?? "typescript",
+		backend: context.backend,
+		frontend: context.frontend
 	});
 	const options = authOptionOrder.flatMap(({ value }) => {
 		const option = supportedOptions.find((candidate) => candidate.id === value);
-		return option ? [option] : [];
-	});
-	if (options.length === 1 && options[0]?.id === "none") return "none";
-	const response = await navigableSelect({
-		message: "Select authentication provider",
-		options: options.map((option) => ({
+		return option ? [{
 			value: option.id,
 			label: option.label,
 			hint: option.promptHint
-		})),
-		initialValue: options.some((option) => option.id === DEFAULT_CONFIG.auth) ? DEFAULT_CONFIG.auth : options.find((option) => option.id !== "none")?.id ?? "none"
+		}] : [];
+	});
+	if (context.auth !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: context.auth
+	};
+	if (options.length === 1 && options[0]?.value === "none") return {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: "none"
+	};
+	return {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue: options.some((option) => option.value === DEFAULT_CONFIG.auth) ? DEFAULT_CONFIG.auth : options.find((option) => option.value !== "none")?.value ?? "none"
+	};
+}
+async function getAuthChoice(auth, backend, frontend, ecosystem = "typescript") {
+	const resolution = resolveAuthPrompt({
+		auth,
+		backend,
+		frontend,
+		ecosystem
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select authentication provider",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1827,67 +2074,108 @@ const FULLSTACK_FRONTENDS = [
 	"svelte",
 	"solid-start"
 ];
-async function getBackendFrameworkChoice(backendFramework, frontends) {
-	if (backendFramework !== void 0) return backendFramework;
-	const hasIncompatibleFrontend = frontends?.some((f) => f === "solid" || f === "solid-start");
-	const hasFullstackFrontend = frontends?.some((f) => FULLSTACK_FRONTENDS.includes(f));
-	const backendOptions = [];
-	if (hasFullstackFrontend) backendOptions.push({
+const BACKEND_PROMPT_OPTIONS = [
+	{
 		value: "self",
 		label: "Self (Fullstack)",
 		hint: "Use frontend's built-in api routes"
-	});
-	backendOptions.push({
+	},
+	{
 		value: "hono",
 		label: "Hono",
 		hint: "Lightweight, ultrafast web framework"
-	}, {
+	},
+	{
 		value: "express",
 		label: "Express",
 		hint: "Fast, unopinionated, minimalist web framework for Node.js"
-	}, {
+	},
+	{
 		value: "fastify",
 		label: "Fastify",
 		hint: "Fast, low-overhead web framework for Node.js"
-	}, {
+	},
+	{
 		value: "elysia",
 		label: "Elysia",
 		hint: "Ergonomic web framework for building backend servers"
-	}, {
+	},
+	{
 		value: "fets",
 		label: "feTS",
 		hint: "TypeScript HTTP Framework with e2e type-safety"
-	}, {
+	},
+	{
 		value: "nestjs",
 		label: "NestJS",
 		hint: "Progressive Node.js framework for scalable applications"
-	}, {
+	},
+	{
 		value: "adonisjs",
 		label: "AdonisJS",
 		hint: "Full-featured MVC framework for Node.js"
-	}, {
+	},
+	{
 		value: "nitro",
 		label: "Nitro",
 		hint: "Universal server framework from UnJS"
-	}, {
+	},
+	{
 		value: "encore",
 		label: "Encore",
 		hint: "Backend development platform with built-in infrastructure"
-	});
-	if (!hasIncompatibleFrontend) backendOptions.push({
+	},
+	{
 		value: "convex",
 		label: "Convex",
 		hint: "Reactive backend-as-a-service platform"
-	});
-	backendOptions.push({
+	},
+	{
 		value: "none",
 		label: "None",
 		hint: "No backend server"
+	}
+];
+function resolveBackendPrompt(context = {}) {
+	const hasIncompatibleFrontend = context.frontends?.some((frontend) => frontend === "solid" || frontend === "solid-start");
+	const hasFullstackFrontend = context.frontends?.some((frontend) => FULLSTACK_FRONTENDS.includes(frontend));
+	const availableValues = new Set([
+		...hasFullstackFrontend ? ["self"] : [],
+		"hono",
+		"express",
+		"fastify",
+		"elysia",
+		"fets",
+		"nestjs",
+		"adonisjs",
+		"nitro",
+		"encore",
+		...!hasIncompatibleFrontend ? ["convex"] : [],
+		"none"
+	]);
+	const options = BACKEND_PROMPT_OPTIONS.filter((option) => availableValues.has(option.value));
+	return context.backendFramework !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: context.backendFramework
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue: hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend
+	};
+}
+async function getBackendFrameworkChoice(backendFramework, frontends) {
+	const resolution = resolveBackendPrompt({
+		backendFramework,
+		frontends
 	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select backend",
-		options: backendOptions,
-		initialValue: hasFullstackFrontend ? "self" : DEFAULT_CONFIG.backend
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1895,21 +2183,44 @@ async function getBackendFrameworkChoice(backendFramework, frontends) {
 
 //#endregion
 //#region src/prompts/caching.ts
+const CACHING_PROMPT_OPTIONS = [{
+	value: "upstash-redis",
+	label: "Upstash Redis",
+	hint: "Serverless Redis with REST API for edge and serverless"
+}, {
+	value: "none",
+	label: "None",
+	hint: "Skip caching layer setup"
+}];
+function resolveCachingPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.caching !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: CACHING_PROMPT_OPTIONS,
+		autoValue: context.caching
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: CACHING_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getCachingChoice(caching, backend) {
-	if (caching !== void 0) return caching;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveCachingPrompt({
+		caching,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select caching solution",
-		options: [{
-			value: "upstash-redis",
-			label: "Upstash Redis",
-			hint: "Serverless Redis with REST API for edge and serverless"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "Skip caching layer setup"
-		}],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1917,39 +2228,62 @@ async function getCachingChoice(caching, backend) {
 
 //#endregion
 //#region src/prompts/cms.ts
+const CMS_PROMPT_OPTIONS = [
+	{
+		value: "payload",
+		label: "Payload",
+		hint: "TypeScript-first headless CMS with Next.js integration"
+	},
+	{
+		value: "sanity",
+		label: "Sanity",
+		hint: "Real-time collaborative CMS with schema-as-code"
+	},
+	{
+		value: "strapi",
+		label: "Strapi",
+		hint: "Open-source headless CMS with admin panel"
+	},
+	{
+		value: "tinacms",
+		label: "TinaCMS",
+		hint: "Git-backed headless CMS with visual editing"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip headless CMS setup"
+	}
+];
+function resolveCMSPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.cms !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: CMS_PROMPT_OPTIONS,
+		autoValue: context.cms
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: CMS_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getCMSChoice(cms, backend) {
-	if (cms !== void 0) return cms;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveCMSPrompt({
+		cms,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select headless CMS",
-		options: [
-			{
-				value: "payload",
-				label: "Payload",
-				hint: "TypeScript-first headless CMS with Next.js integration"
-			},
-			{
-				value: "sanity",
-				label: "Sanity",
-				hint: "Real-time collaborative CMS with schema-as-code"
-			},
-			{
-				value: "strapi",
-				label: "Strapi",
-				hint: "Open-source headless CMS with admin panel"
-			},
-			{
-				value: "tinacms",
-				label: "TinaCMS",
-				hint: "Git-backed headless CMS with visual editing"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip headless CMS setup"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1979,17 +2313,39 @@ const CSS_FRAMEWORK_OPTIONS = {
 		hint: "Plain CSS without preprocessors"
 	}
 };
-async function getCSSFrameworkChoice(cssFramework, uiLibrary) {
-	const compatibleFrameworks = getCompatibleCSSFrameworks$1(uiLibrary);
-	if (cssFramework !== void 0) return compatibleFrameworks.includes(cssFramework) ? cssFramework : compatibleFrameworks[0];
-	const selected = await navigableSelect({
-		message: "Select CSS framework",
+function resolveCSSFrameworkPrompt(context = {}) {
+	const compatibleFrameworks = getCompatibleCSSFrameworks$1(context.uiLibrary);
+	if (context.cssFramework !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: compatibleFrameworks.map((fw) => ({
+			value: fw,
+			label: CSS_FRAMEWORK_OPTIONS[fw].label,
+			hint: CSS_FRAMEWORK_OPTIONS[fw].hint
+		})),
+		autoValue: compatibleFrameworks.includes(context.cssFramework) ? context.cssFramework : compatibleFrameworks[0]
+	};
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options: compatibleFrameworks.map((fw) => ({
 			value: fw,
 			label: CSS_FRAMEWORK_OPTIONS[fw].label,
 			hint: CSS_FRAMEWORK_OPTIONS[fw].hint
 		})),
 		initialValue: compatibleFrameworks.includes("tailwind") ? "tailwind" : compatibleFrameworks[0]
+	};
+}
+async function getCSSFrameworkChoice(cssFramework, uiLibrary) {
+	const resolution = resolveCSSFrameworkPrompt({
+		cssFramework,
+		uiLibrary
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const selected = await navigableSelect({
+		message: "Select CSS framework",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(selected)) return exitCancelled("Operation cancelled");
 	return selected;
@@ -1997,9 +2353,19 @@ async function getCSSFrameworkChoice(cssFramework, uiLibrary) {
 
 //#endregion
 //#region src/prompts/database.ts
-async function getDatabaseChoice(database, backend, runtime) {
-	if (backend === "convex" || backend === "none") return "none";
-	if (database !== void 0) return database;
+function resolveDatabasePrompt(context = {}) {
+	if (context.backend === "convex" || context.backend === "none") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	if (context.database !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.database
+	};
 	const databaseOptions = [
 		{
 			value: "none",
@@ -2022,7 +2388,7 @@ async function getDatabaseChoice(database, backend, runtime) {
 			hint: "popular open-source relational database system"
 		}
 	];
-	if (runtime !== "workers") {
+	if (context.runtime !== "workers") {
 		databaseOptions.push({
 			value: "mongodb",
 			label: "MongoDB",
@@ -2039,10 +2405,24 @@ async function getDatabaseChoice(database, backend, runtime) {
 			hint: "in-memory data store for caching, sessions, and real-time features"
 		});
 	}
-	const response = await navigableSelect({
-		message: "Select database",
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options: databaseOptions,
 		initialValue: DEFAULT_CONFIG.database
+	};
+}
+async function getDatabaseChoice(database, backend, runtime) {
+	const resolution = resolveDatabasePrompt({
+		database,
+		backend,
+		runtime
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select database",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2050,18 +2430,33 @@ async function getDatabaseChoice(database, backend, runtime) {
 
 //#endregion
 //#region src/prompts/database-setup.ts
-async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
-	if (backend === "convex") return "none";
-	if (dbSetup !== void 0) return dbSetup;
-	if (databaseType === "none") return "none";
+function resolveDBSetupPrompt(context) {
+	if (context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	if (context.dbSetup !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.dbSetup
+	};
+	if (context.databaseType === "none") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
 	let options = [];
-	if (databaseType === "sqlite") options = [
+	if (context.databaseType === "sqlite") options = [
 		{
 			value: "turso",
 			label: "Turso",
 			hint: "SQLite for Production. Powered by libSQL"
 		},
-		...runtime === "workers" ? [{
+		...context.runtime === "workers" ? [{
 			value: "d1",
 			label: "Cloudflare D1",
 			hint: "Cloudflare's managed, serverless database with SQLite's SQL semantics"
@@ -2072,7 +2467,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
-	else if (databaseType === "postgres") options = [
+	else if (context.databaseType === "postgres") options = [
 		{
 			value: "neon",
 			label: "Neon Postgres",
@@ -2104,7 +2499,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
-	else if (databaseType === "mysql") options = [
+	else if (context.databaseType === "mysql") options = [
 		{
 			value: "planetscale",
 			label: "PlanetScale",
@@ -2121,7 +2516,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
-	else if (databaseType === "mongodb") options = [
+	else if (context.databaseType === "mongodb") options = [
 		{
 			value: "mongodb-atlas",
 			label: "MongoDB Atlas",
@@ -2138,7 +2533,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
-	else if (databaseType === "redis") options = [
+	else if (context.databaseType === "redis") options = [
 		{
 			value: "upstash",
 			label: "Upstash",
@@ -2155,11 +2550,32 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
 			hint: "Manual setup"
 		}
 	];
-	else return "none";
-	const response = await navigableSelect({
-		message: `Select ${databaseType} setup option`,
+	else return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options,
 		initialValue: "none"
+	};
+}
+async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime) {
+	const resolution = resolveDBSetupPrompt({
+		databaseType,
+		dbSetup,
+		orm: _orm,
+		backend,
+		runtime
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: `Select ${databaseType} setup option`,
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2230,60 +2646,82 @@ async function getEffectChoice(effect) {
 
 //#endregion
 //#region src/prompts/email.ts
+const EMAIL_PROMPT_OPTIONS = [
+	{
+		value: "resend",
+		label: "Resend",
+		hint: "Email for developers. Includes React Email components."
+	},
+	{
+		value: "react-email",
+		label: "React Email",
+		hint: "Build emails using React components (no sending service)."
+	},
+	{
+		value: "nodemailer",
+		label: "Nodemailer",
+		hint: "Classic Node.js email sending library."
+	},
+	{
+		value: "postmark",
+		label: "Postmark",
+		hint: "Transactional email service with high deliverability."
+	},
+	{
+		value: "sendgrid",
+		label: "SendGrid",
+		hint: "Email delivery and marketing platform by Twilio."
+	},
+	{
+		value: "aws-ses",
+		label: "AWS SES",
+		hint: "Amazon Simple Email Service for scalable email."
+	},
+	{
+		value: "mailgun",
+		label: "Mailgun",
+		hint: "Email API service for sending and tracking emails."
+	},
+	{
+		value: "plunk",
+		label: "Plunk",
+		hint: "Open-source email platform for developers."
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No email integration"
+	}
+];
+function resolveEmailPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.email !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: EMAIL_PROMPT_OPTIONS,
+		autoValue: context.email
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: EMAIL_PROMPT_OPTIONS,
+		initialValue: DEFAULT_CONFIG.email ?? "none"
+	};
+}
 async function getEmailChoice(email, backend) {
-	if (email !== void 0) return email;
-	if (backend === "none") return "none";
-	if (backend === "convex") return "none";
+	const resolution = resolveEmailPrompt({
+		email,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select email solution",
-		options: [
-			{
-				value: "resend",
-				label: "Resend",
-				hint: "Email for developers. Includes React Email components."
-			},
-			{
-				value: "react-email",
-				label: "React Email",
-				hint: "Build emails using React components (no sending service)."
-			},
-			{
-				value: "nodemailer",
-				label: "Nodemailer",
-				hint: "Classic Node.js email sending library."
-			},
-			{
-				value: "postmark",
-				label: "Postmark",
-				hint: "Transactional email service with high deliverability."
-			},
-			{
-				value: "sendgrid",
-				label: "SendGrid",
-				hint: "Email delivery and marketing platform by Twilio."
-			},
-			{
-				value: "aws-ses",
-				label: "AWS SES",
-				hint: "Amazon Simple Email Service for scalable email."
-			},
-			{
-				value: "mailgun",
-				label: "Mailgun",
-				hint: "Email API service for sending and tracking emails."
-			},
-			{
-				value: "plunk",
-				label: "Plunk",
-				hint: "Open-source email platform for developers."
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No email integration"
-			}
-		],
-		initialValue: DEFAULT_CONFIG.email ?? "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2349,34 +2787,57 @@ async function getFileStorageChoice(fileStorage, backend) {
 
 //#endregion
 //#region src/prompts/file-upload.ts
+const FILE_UPLOAD_PROMPT_OPTIONS = [
+	{
+		value: "uploadthing",
+		label: "UploadThing",
+		hint: "TypeScript-first file uploads with built-in validation"
+	},
+	{
+		value: "filepond",
+		label: "FilePond",
+		hint: "Flexible file upload with image preview and drag & drop"
+	},
+	{
+		value: "uppy",
+		label: "Uppy",
+		hint: "Modular file uploader with resumable uploads and plugins"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip file upload integration"
+	}
+];
+function resolveFileUploadPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.fileUpload !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: FILE_UPLOAD_PROMPT_OPTIONS,
+		autoValue: context.fileUpload
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: FILE_UPLOAD_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getFileUploadChoice(fileUpload, backend) {
-	if (fileUpload !== void 0) return fileUpload;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveFileUploadPrompt({
+		fileUpload,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select file upload solution",
-		options: [
-			{
-				value: "uploadthing",
-				label: "UploadThing",
-				hint: "TypeScript-first file uploads with built-in validation"
-			},
-			{
-				value: "filepond",
-				label: "FilePond",
-				hint: "Flexible file upload with image preview and drag & drop"
-			},
-			{
-				value: "uppy",
-				label: "Uppy",
-				hint: "Modular file uploader with resumable uploads and plugins"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip file upload integration"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2384,10 +2845,20 @@ async function getFileUploadChoice(fileUpload, backend) {
 
 //#endregion
 //#region src/prompts/forms.ts
-async function getFormsChoice(forms, frontends) {
-	if (forms !== void 0) return forms;
-	const { web } = splitFrontends$1(frontends);
-	if (web.length === 0) return "none";
+function resolveFormsPrompt(context = {}) {
+	if (context.forms !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.forms
+	};
+	const { web } = splitFrontends$1(context.frontends);
+	if (web.length === 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
 	const isReact = web.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -2432,10 +2903,23 @@ async function getFormsChoice(forms, frontends) {
 		label: "None",
 		hint: "Build custom form handling"
 	});
+	return {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue: isReact ? "react-hook-form" : options.find((option) => option.value !== "none")?.value ?? "none"
+	};
+}
+async function getFormsChoice(forms, frontends) {
+	const resolution = resolveFormsPrompt({
+		forms,
+		frontends
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select form library",
-		options,
-		initialValue: isReact ? "react-hook-form" : "tanstack-form"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2443,8 +2927,119 @@ async function getFormsChoice(forms, frontends) {
 
 //#endregion
 //#region src/prompts/frontend.ts
+const WEB_FRONTEND_PROMPT_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: "react-vite",
+		label: "React + Vite",
+		hint: "Client-routed React SPA powered by Vite"
+	},
+	{
+		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: "SvelteKit",
+		hint: "Full-stack Svelte framework with SSR and server routes"
+	},
+	{
+		value: "solid",
+		label: "Solid",
+		hint: "Simple and performant reactivity for building user interfaces"
+	},
+	{
+		value: "solid-start",
+		label: "SolidStart",
+		hint: "Full-stack Solid framework with SSR and API routes"
+	},
+	{
+		value: "astro",
+		label: "Astro",
+		hint: "Content-focused with Island Architecture"
+	},
+	{
+		value: "tanstack-start",
+		label: "TanStack Start",
+		hint: "SSR, Server Functions, API Routes and more with TanStack Router"
+	},
+	{
+		value: "qwik",
+		label: "Qwik",
+		hint: "Resumable framework with instant load times"
+	},
+	{
+		value: "angular",
+		label: "Angular",
+		hint: "Enterprise-grade TypeScript framework by Google"
+	},
+	{
+		value: "redwood",
+		label: "RedwoodJS",
+		hint: "Opinionated fullstack (React + GraphQL + Prisma)"
+	},
+	{
+		value: "fresh",
+		label: "Fresh",
+		hint: "Deno-native framework with islands architecture"
+	}
+];
+const NATIVE_FRONTEND_PROMPT_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"
+	}
+];
+function resolveFrontendPrompt(context = {}) {
+	const options = [...WEB_FRONTEND_PROMPT_OPTIONS.filter((option) => isFrontendAllowedWithBackend$1(option.value, context.backend, context.auth)), ...NATIVE_FRONTEND_PROMPT_OPTIONS];
+	return context.frontendOptions !== void 0 ? {
+		shouldPrompt: false,
+		mode: "multiple",
+		options,
+		autoValue: context.frontendOptions
+	} : {
+		shouldPrompt: true,
+		mode: "multiple",
+		options,
+		initialValue: DEFAULT_CONFIG.frontend
+	};
+}
 async function getFrontendChoice(frontendOptions, backend, auth) {
-	if (frontendOptions !== void 0) return frontendOptions;
+	const resolution = resolveFrontendPrompt({
+		frontendOptions,
+		backend,
+		auth
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? [];
+	const allowedValues = new Set(resolution.options.map((option) => option.value));
+	const initialValues = resolution.initialValue ?? DEFAULT_CONFIG.frontend;
+	const initialTypes = [...initialValues.some((value) => WEB_FRONTEND_PROMPT_OPTIONS.some((option) => option.value === value)) ? ["web"] : [], ...initialValues.some((value) => NATIVE_FRONTEND_PROMPT_OPTIONS.some((option) => option.value === value)) ? ["native"] : []];
 	while (true) {
 		const wasFirstPrompt = isFirstPrompt();
 		const frontendTypes = await navigableMultiselect({
@@ -2459,7 +3054,7 @@ async function getFrontendChoice(frontendOptions, backend, auth) {
 				hint: "Create a React Native/Expo app"
 			}],
 			required: false,
-			initialValues: ["web"]
+			initialValues: initialTypes.length > 0 ? [...initialTypes] : ["web"]
 		});
 		if (isGoBack(frontendTypes)) return GO_BACK_SYMBOL;
 		if (isCancel$1(frontendTypes)) return exitCancelled("Operation cancelled");
@@ -2467,81 +3062,12 @@ async function getFrontendChoice(frontendOptions, backend, auth) {
 		const result = [];
 		let shouldRestart = false;
 		if (frontendTypes.includes("web")) {
+			const webOptions = WEB_FRONTEND_PROMPT_OPTIONS.filter((option) => allowedValues.has(option.value));
+			const initialWebValue = initialValues.find((value) => webOptions.some((option) => option.value === value)) ?? webOptions[0]?.value;
 			const webFramework = await navigableSelect({
 				message: "Select web framework",
-				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: "react-vite",
-						label: "React + Vite",
-						hint: "Client-routed React SPA powered by Vite"
-					},
-					{
-						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: "SvelteKit",
-						hint: "Full-stack Svelte framework with SSR and server routes"
-					},
-					{
-						value: "solid",
-						label: "Solid",
-						hint: "Simple and performant reactivity for building user interfaces"
-					},
-					{
-						value: "solid-start",
-						label: "SolidStart",
-						hint: "Full-stack Solid framework with SSR and API routes"
-					},
-					{
-						value: "astro",
-						label: "Astro",
-						hint: "Content-focused with Island Architecture"
-					},
-					{
-						value: "tanstack-start",
-						label: "TanStack Start",
-						hint: "SSR, Server Functions, API Routes and more with TanStack Router"
-					},
-					{
-						value: "qwik",
-						label: "Qwik",
-						hint: "Resumable framework with instant load times"
-					},
-					{
-						value: "angular",
-						label: "Angular",
-						hint: "Enterprise-grade TypeScript framework by Google"
-					},
-					{
-						value: "redwood",
-						label: "RedwoodJS",
-						hint: "Opinionated fullstack (React + GraphQL + Prisma)"
-					},
-					{
-						value: "fresh",
-						label: "Fresh",
-						hint: "Deno-native framework with islands architecture"
-					}
-				].filter((option) => isFrontendAllowedWithBackend$1(option.value, backend, auth)),
-				initialValue: DEFAULT_CONFIG.frontend[0]
+				options: webOptions,
+				...initialWebValue ? { initialValue: initialWebValue } : {}
 			});
 			if (isGoBack(webFramework)) shouldRestart = true;
 			else if (isCancel$1(webFramework)) return exitCancelled("Operation cancelled");
@@ -2552,26 +3078,12 @@ async function getFrontendChoice(frontendOptions, backend, auth) {
 			continue;
 		}
 		if (frontendTypes.includes("native")) {
+			const nativeOptions = NATIVE_FRONTEND_PROMPT_OPTIONS.filter((option) => allowedValues.has(option.value));
+			const initialNativeValue = initialValues.find((value) => nativeOptions.some((option) => option.value === value)) ?? nativeOptions[0]?.value;
 			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"
+				options: nativeOptions,
+				...initialNativeValue ? { initialValue: initialNativeValue } : {}
 			});
 			if (isGoBack(nativeFramework)) if (frontendTypes.includes("web")) shouldRestart = true;
 			else {
@@ -2603,144 +3115,200 @@ async function getGitChoice(git) {
 
 //#endregion
 //#region src/prompts/go-ecosystem.ts
+const GO_WEB_FRAMEWORK_PROMPT_OPTIONS = [
+	{
+		value: "gin",
+		label: "Gin",
+		hint: "High-performance HTTP web framework with martini-like API"
+	},
+	{
+		value: "echo",
+		label: "Echo",
+		hint: "High performance, minimalist Go web framework"
+	},
+	{
+		value: "fiber",
+		label: "Fiber",
+		hint: "Express-inspired web framework built on Fasthttp"
+	},
+	{
+		value: "chi",
+		label: "Chi",
+		hint: "Lightweight, zero-dependency router built on net/http"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No web framework"
+	}
+];
+const GO_ORM_PROMPT_OPTIONS = [
+	{
+		value: "gorm",
+		label: "GORM",
+		hint: "The fantastic ORM library for Golang"
+	},
+	{
+		value: "sqlc",
+		label: "sqlc",
+		hint: "Generate type-safe Go code from SQL"
+	},
+	{
+		value: "ent",
+		label: "Ent",
+		hint: "Code-first ORM by Meta with graph traversal API, 15k+ stars"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No ORM/database layer"
+	}
+];
+const GO_API_PROMPT_OPTIONS = [{
+	value: "grpc-go",
+	label: "gRPC-Go",
+	hint: "The Go implementation of gRPC"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No API layer"
+}];
+const GO_CLI_PROMPT_OPTIONS = [
+	{
+		value: "cobra",
+		label: "Cobra",
+		hint: "Library for creating powerful modern CLI applications"
+	},
+	{
+		value: "bubbletea",
+		label: "Bubble Tea",
+		hint: "Powerful TUI framework based on The Elm Architecture"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No CLI tools"
+	}
+];
+const GO_LOGGING_PROMPT_OPTIONS = [
+	{
+		value: "zap",
+		label: "Zap",
+		hint: "Blazing fast, structured, leveled logging in Go"
+	},
+	{
+		value: "zerolog",
+		label: "Zerolog",
+		hint: "Zero-allocation JSON logger, fastest in benchmarks"
+	},
+	{
+		value: "slog",
+		label: "slog",
+		hint: "Go 1.21+ stdlib structured logging (no external dependency)"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No logging library"
+	}
+];
+const GO_AUTH_PROMPT_OPTIONS = [
+	{
+		value: "casbin",
+		label: "Casbin",
+		hint: "Model-based authorization (ACL, RBAC, ABAC) via config files"
+	},
+	{
+		value: "jwt",
+		label: "golang-jwt",
+		hint: "JWT token creation and validation with HMAC/RSA/ECDSA signing"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No authentication library"
+	}
+];
+function resolveGoWebFrameworkPrompt(goWebFramework) {
+	return createStaticSinglePromptResolution(GO_WEB_FRAMEWORK_PROMPT_OPTIONS, "gin", goWebFramework);
+}
 async function getGoWebFrameworkChoice(goWebFramework) {
-	if (goWebFramework !== void 0) return goWebFramework;
+	const resolution = resolveGoWebFrameworkPrompt(goWebFramework);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Go web framework",
-		options: [
-			{
-				value: "gin",
-				label: "Gin",
-				hint: "High-performance HTTP web framework with martini-like API"
-			},
-			{
-				value: "echo",
-				label: "Echo",
-				hint: "High performance, minimalist Go web framework"
-			},
-			{
-				value: "fiber",
-				label: "Fiber",
-				hint: "Express-inspired web framework built on Fasthttp"
-			},
-			{
-				value: "chi",
-				label: "Chi",
-				hint: "Lightweight, zero-dependency router built on net/http"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No web framework"
-			}
-		],
-		initialValue: "gin"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveGoOrmPrompt(goOrm) {
+	return createStaticSinglePromptResolution(GO_ORM_PROMPT_OPTIONS, "gorm", goOrm);
+}
 async function getGoOrmChoice(goOrm) {
-	if (goOrm !== void 0) return goOrm;
+	const resolution = resolveGoOrmPrompt(goOrm);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Go ORM/database layer",
-		options: [
-			{
-				value: "gorm",
-				label: "GORM",
-				hint: "The fantastic ORM library for Golang"
-			},
-			{
-				value: "sqlc",
-				label: "sqlc",
-				hint: "Generate type-safe Go code from SQL"
-			},
-			{
-				value: "ent",
-				label: "Ent",
-				hint: "Code-first ORM by Meta with graph traversal API, 15k+ stars"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No ORM/database layer"
-			}
-		],
-		initialValue: "gorm"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveGoApiPrompt(goApi) {
+	return createStaticSinglePromptResolution(GO_API_PROMPT_OPTIONS, "none", goApi);
+}
 async function getGoApiChoice(goApi) {
-	if (goApi !== void 0) return goApi;
+	const resolution = resolveGoApiPrompt(goApi);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Go API layer",
-		options: [{
-			value: "grpc-go",
-			label: "gRPC-Go",
-			hint: "The Go implementation of gRPC"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No API layer"
-		}],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveGoCliPrompt(goCli) {
+	return createStaticSinglePromptResolution(GO_CLI_PROMPT_OPTIONS, "none", goCli);
+}
 async function getGoCliChoice(goCli) {
-	if (goCli !== void 0) return goCli;
+	const resolution = resolveGoCliPrompt(goCli);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Go CLI tools",
-		options: [
-			{
-				value: "cobra",
-				label: "Cobra",
-				hint: "Library for creating powerful modern CLI applications"
-			},
-			{
-				value: "bubbletea",
-				label: "Bubble Tea",
-				hint: "Powerful TUI framework based on The Elm Architecture"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No CLI tools"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveGoLoggingPrompt(goLogging) {
+	return createStaticSinglePromptResolution(GO_LOGGING_PROMPT_OPTIONS, "zap", goLogging);
+}
 async function getGoLoggingChoice(goLogging) {
-	if (goLogging !== void 0) return goLogging;
+	const resolution = resolveGoLoggingPrompt(goLogging);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Go logging library",
-		options: [
-			{
-				value: "zap",
-				label: "Zap",
-				hint: "Blazing fast, structured, leveled logging in Go"
-			},
-			{
-				value: "zerolog",
-				label: "Zerolog",
-				hint: "Zero-allocation JSON logger, fastest in benchmarks"
-			},
-			{
-				value: "slog",
-				label: "slog",
-				hint: "Go 1.21+ stdlib structured logging (no external dependency)"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No logging library"
-			}
-		],
-		initialValue: "zap"
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveGoAuthPrompt(goAuth) {
+	return createStaticSinglePromptResolution(GO_AUTH_PROMPT_OPTIONS, "none", goAuth);
+}
+async function getGoAuthChoice(goAuth) {
+	const resolution = resolveGoAuthPrompt(goAuth);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Go authentication library",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2788,7 +3356,7 @@ async function commandExists(command) {
 
 //#endregion
 //#region src/prompts/install.ts
-async function getinstallChoice(install, ecosystem) {
+async function getinstallChoice(install, ecosystem, javaBuildTool) {
 	if (install !== void 0) return install;
 	if (ecosystem === "rust") {
 		if (!await commandExists("cargo")) {
@@ -2826,6 +3394,22 @@ async function getinstallChoice(install, ecosystem) {
 		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
 		return response$1;
 	}
+	if (ecosystem === "java") {
+		if (!await commandExists("java")) {
+			log.warn("Java is not installed. Please install a JDK from https://adoptium.net/ or your preferred vendor.");
+			return false;
+		}
+		if (javaBuildTool === "none") {
+			log.warn("No Java build tool selected. Skipping Java install verification.");
+			return false;
+		}
+		const response$1 = await navigableConfirm({
+			message: `Run ${javaBuildTool === "gradle" ? "./gradlew test" : "./mvnw test"}?`,
+			initialValue: DEFAULT_CONFIG.install
+		});
+		if (isCancel$1(response$1)) return exitCancelled("Operation cancelled");
+		return response$1;
+	}
 	const response = await navigableConfirm({
 		message: "Install dependencies?",
 		initialValue: DEFAULT_CONFIG.install
@@ -2834,41 +3418,298 @@ async function getinstallChoice(install, ecosystem) {
 	return response;
 }
 
+//#endregion
+//#region src/prompts/java-ecosystem.ts
+const JAVA_WEB_FRAMEWORK_PROMPT_OPTIONS = [{
+	value: "spring-boot",
+	label: "Spring Boot",
+	hint: "Production-grade Java framework with embedded server and auto-configuration"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No Java web framework"
+}];
+const JAVA_BUILD_TOOL_PROMPT_OPTIONS = [
+	{
+		value: "maven",
+		label: "Maven",
+		hint: "Convention-based build tool with Maven Wrapper support"
+	},
+	{
+		value: "gradle",
+		label: "Gradle",
+		hint: "Flexible build tool with Gradle Wrapper support"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No Java build tool"
+	}
+];
+const JAVA_ORM_PROMPT_OPTIONS = [{
+	value: "spring-data-jpa",
+	label: "Spring Data JPA",
+	hint: "Repository abstraction built on JPA/Hibernate"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No Java ORM/database layer"
+}];
+const JAVA_AUTH_PROMPT_OPTIONS = [{
+	value: "spring-security",
+	label: "Spring Security",
+	hint: "Authentication and authorization for Spring applications"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No Java authentication library"
+}];
+const JAVA_TESTING_LIBRARY_PROMPT_OPTIONS = [
+	{
+		value: "junit5",
+		label: "JUnit 5",
+		hint: "Modern Java unit testing platform"
+	},
+	{
+		value: "mockito",
+		label: "Mockito",
+		hint: "Mocking framework for isolated unit tests"
+	},
+	{
+		value: "testcontainers",
+		label: "Testcontainers",
+		hint: "Disposable Docker-based integration tests"
+	},
+	{
+		value: "assertj",
+		label: "AssertJ",
+		hint: "Fluent assertions for Java tests"
+	},
+	{
+		value: "rest-assured",
+		label: "REST Assured",
+		hint: "DSL for HTTP API and REST endpoint tests"
+	},
+	{
+		value: "wiremock",
+		label: "WireMock",
+		hint: "HTTP service stubs for integration tests"
+	},
+	{
+		value: "awaitility",
+		label: "Awaitility",
+		hint: "Wait helpers for asynchronous Java tests"
+	},
+	{
+		value: "archunit",
+		label: "ArchUnit",
+		hint: "Architecture rules for Java package boundaries"
+	},
+	{
+		value: "jqwik",
+		label: "jqwik",
+		hint: "Property-based testing on the JUnit Platform"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No extra testing libraries"
+	}
+];
+const JAVA_LIBRARY_PROMPT_OPTIONS = [
+	{
+		value: "spring-actuator",
+		label: "Spring Actuator",
+		hint: "Production health, metrics, and diagnostics endpoints"
+	},
+	{
+		value: "spring-validation",
+		label: "Spring Validation",
+		hint: "Bean validation for request and entity constraints"
+	},
+	{
+		value: "flyway",
+		label: "Flyway",
+		hint: "Versioned SQL database migrations for JPA-backed apps"
+	},
+	{
+		value: "liquibase",
+		label: "Liquibase",
+		hint: "Database change management for JPA-backed apps"
+	},
+	{
+		value: "springdoc-openapi",
+		label: "Springdoc OpenAPI",
+		hint: "OpenAPI and Swagger UI documentation for Spring MVC APIs"
+	},
+	{
+		value: "lombok",
+		label: "Lombok",
+		hint: "Annotation processor for reducing Java boilerplate"
+	},
+	{
+		value: "mapstruct",
+		label: "MapStruct",
+		hint: "Compile-time generated mappers for DTO and entity conversions"
+	},
+	{
+		value: "caffeine",
+		label: "Caffeine",
+		hint: "High-performance in-memory caching through Spring Cache"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No extra Java libraries"
+	}
+];
+function resolveJavaWebFrameworkPrompt(javaWebFramework) {
+	return createStaticSinglePromptResolution(JAVA_WEB_FRAMEWORK_PROMPT_OPTIONS, "spring-boot", javaWebFramework);
+}
+async function getJavaWebFrameworkChoice(javaWebFramework) {
+	const resolution = resolveJavaWebFrameworkPrompt(javaWebFramework);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Java web framework",
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveJavaBuildToolPrompt(javaBuildTool) {
+	return createStaticSinglePromptResolution(JAVA_BUILD_TOOL_PROMPT_OPTIONS, "maven", javaBuildTool);
+}
+async function getJavaBuildToolChoice(javaBuildTool) {
+	const resolution = resolveJavaBuildToolPrompt(javaBuildTool);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Java build tool",
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveJavaOrmPrompt(javaOrm) {
+	return createStaticSinglePromptResolution(JAVA_ORM_PROMPT_OPTIONS, "none", javaOrm);
+}
+async function getJavaOrmChoice(javaOrm) {
+	const resolution = resolveJavaOrmPrompt(javaOrm);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Java ORM/database layer",
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveJavaAuthPrompt(javaAuth) {
+	return createStaticSinglePromptResolution(JAVA_AUTH_PROMPT_OPTIONS, "none", javaAuth);
+}
+async function getJavaAuthChoice(javaAuth) {
+	const resolution = resolveJavaAuthPrompt(javaAuth);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Java authentication library",
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveJavaLibrariesPrompt(javaLibraries) {
+	return createStaticMultiPromptResolution(JAVA_LIBRARY_PROMPT_OPTIONS, [], javaLibraries);
+}
+async function getJavaLibrariesChoice(javaLibraries) {
+	const resolution = resolveJavaLibrariesPrompt(javaLibraries);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? [];
+	const response = await navigableMultiselect({
+		message: "Select Java application libraries",
+		options: resolution.options,
+		required: false,
+		initialValues: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	if (response.includes("none")) return [];
+	return response;
+}
+function resolveJavaTestingLibrariesPrompt(javaTestingLibraries) {
+	return createStaticMultiPromptResolution(JAVA_TESTING_LIBRARY_PROMPT_OPTIONS, ["junit5"], javaTestingLibraries);
+}
+async function getJavaTestingLibrariesChoice(javaTestingLibraries) {
+	const resolution = resolveJavaTestingLibrariesPrompt(javaTestingLibraries);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? [];
+	const response = await navigableMultiselect({
+		message: "Select Java testing libraries",
+		options: resolution.options,
+		required: false,
+		initialValues: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	if (response.includes("none")) return [];
+	return response;
+}
+
 //#endregion
 //#region src/prompts/job-queue.ts
+const JOB_QUEUE_PROMPT_OPTIONS = [
+	{
+		value: "bullmq",
+		label: "BullMQ",
+		hint: "Redis-backed job queue for background tasks and scheduling"
+	},
+	{
+		value: "trigger-dev",
+		label: "Trigger.dev",
+		hint: "Background jobs as code with serverless execution"
+	},
+	{
+		value: "inngest",
+		label: "Inngest",
+		hint: "Event-driven functions with built-in queuing and scheduling"
+	},
+	{
+		value: "temporal",
+		label: "Temporal",
+		hint: "Durable workflow orchestration for reliable distributed systems"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip job queue/background worker setup"
+	}
+];
+function resolveJobQueuePrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.jobQueue !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: JOB_QUEUE_PROMPT_OPTIONS,
+		autoValue: context.jobQueue
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: JOB_QUEUE_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getJobQueueChoice(jobQueue, backend) {
-	if (jobQueue !== void 0) return jobQueue;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveJobQueuePrompt({
+		jobQueue,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select job queue solution",
-		options: [
-			{
-				value: "bullmq",
-				label: "BullMQ",
-				hint: "Redis-backed job queue for background tasks and scheduling"
-			},
-			{
-				value: "trigger-dev",
-				label: "Trigger.dev",
-				hint: "Background jobs as code with serverless execution"
-			},
-			{
-				value: "inngest",
-				label: "Inngest",
-				hint: "Event-driven functions with built-in queuing and scheduling"
-			},
-			{
-				value: "temporal",
-				label: "Temporal",
-				hint: "Durable workflow orchestration for reliable distributed systems"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip job queue/background worker setup"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2876,29 +3717,52 @@ async function getJobQueueChoice(jobQueue, backend) {
 
 //#endregion
 //#region src/prompts/logging.ts
+const LOGGING_PROMPT_OPTIONS = [
+	{
+		value: "pino",
+		label: "Pino",
+		hint: "Fast JSON logger with minimal overhead"
+	},
+	{
+		value: "winston",
+		label: "Winston",
+		hint: "Flexible logging library with multiple transports"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip logging framework setup"
+	}
+];
+function resolveLoggingPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.logging !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: LOGGING_PROMPT_OPTIONS,
+		autoValue: context.logging
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: LOGGING_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getLoggingChoice(logging, backend) {
-	if (logging !== void 0) return logging;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveLoggingPrompt({
+		logging,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select logging framework",
-		options: [
-			{
-				value: "pino",
-				label: "Pino",
-				hint: "Fast JSON logger with minimal overhead"
-			},
-			{
-				value: "winston",
-				label: "Winston",
-				hint: "Flexible logging library with multiple transports"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip logging framework setup"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -2963,34 +3827,57 @@ async function navigableGroup(prompts, opts) {
 
 //#endregion
 //#region src/prompts/observability.ts
+const OBSERVABILITY_PROMPT_OPTIONS = [
+	{
+		value: "opentelemetry",
+		label: "OpenTelemetry",
+		hint: "Observability framework for traces, metrics, and logs"
+	},
+	{
+		value: "sentry",
+		label: "Sentry",
+		hint: "Error tracking and performance monitoring"
+	},
+	{
+		value: "grafana",
+		label: "Grafana",
+		hint: "Prometheus metrics for Grafana dashboards and alerting"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip observability/tracing setup"
+	}
+];
+function resolveObservabilityPrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.observability !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: OBSERVABILITY_PROMPT_OPTIONS,
+		autoValue: context.observability
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: OBSERVABILITY_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getObservabilityChoice(observability, backend) {
-	if (observability !== void 0) return observability;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveObservabilityPrompt({
+		observability,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select observability solution",
-		options: [
-			{
-				value: "opentelemetry",
-				label: "OpenTelemetry",
-				hint: "Observability framework for traces, metrics, and logs"
-			},
-			{
-				value: "sentry",
-				label: "Sentry",
-				hint: "Error tracking and performance monitoring"
-			},
-			{
-				value: "grafana",
-				label: "Grafana",
-				hint: "Prometheus metrics for Grafana dashboards and alerting"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip observability/tracing setup"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3035,15 +3922,29 @@ const ormOptions = {
 		hint: "Mature ORM with wide adoption"
 	}
 };
-async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
-	if (backend === "convex") return "none";
-	if (!hasDatabase) return "none";
-	if (database === "edgedb") return "none";
-	if (database === "redis") return "none";
-	if (orm !== void 0) return orm;
-	const response = await navigableSelect({
-		message: "Select ORM",
-		options: database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [
+function resolveORMPrompt(context) {
+	if (context.backend === "convex" || !context.hasDatabase) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	if (context.database === "edgedb" || context.database === "redis") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	if (context.orm !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.orm
+	};
+	return {
+		shouldPrompt: true,
+		mode: "single",
+		options: context.database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [
 			ormOptions.drizzle,
 			ormOptions.prisma,
 			ormOptions.typeorm,
@@ -3051,7 +3952,22 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
 			ormOptions.mikroorm,
 			ormOptions.sequelize
 		],
-		initialValue: database === "mongodb" ? "prisma" : runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm
+		initialValue: context.database === "mongodb" ? "prisma" : context.runtime === "workers" ? "drizzle" : DEFAULT_CONFIG.orm
+	};
+}
+async function getORMChoice(orm, hasDatabase, database, backend, runtime) {
+	const resolution = resolveORMPrompt({
+		orm,
+		hasDatabase,
+		database,
+		backend,
+		runtime
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select ORM",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3093,10 +4009,20 @@ async function getPackageManagerChoice(packageManager) {
 
 //#endregion
 //#region src/prompts/payments.ts
-async function getPaymentsChoice(payments, auth, backend, frontends) {
-	if (payments !== void 0) return payments;
-	if (backend === "none") return "none";
-	const isPolarCompatible = auth === "better-auth" && (frontends?.length === 0 || splitFrontends$1(frontends).web.length > 0);
+function resolvePaymentsPrompt(context = {}) {
+	if (context.payments !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.payments
+	};
+	if (context.backend === "none") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	const isPolarCompatible = context.auth === "better-auth" && (context.frontends?.length === 0 || splitFrontends$1(context.frontends).web.length > 0);
 	const options = [];
 	if (isPolarCompatible) options.push({
 		value: "polar",
@@ -3124,10 +4050,25 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 		label: "None",
 		hint: "No payments integration"
 	});
-	const response = await navigableSelect({
-		message: "Select payments provider",
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options,
 		initialValue: DEFAULT_CONFIG.payments
+	};
+}
+async function getPaymentsChoice(payments, auth, backend, frontends) {
+	const resolution = resolvePaymentsPrompt({
+		payments,
+		auth,
+		backend,
+		frontends
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select payments provider",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3135,210 +4076,255 @@ async function getPaymentsChoice(payments, auth, backend, frontends) {
 
 //#endregion
 //#region src/prompts/python-ecosystem.ts
+const PYTHON_WEB_FRAMEWORK_PROMPT_OPTIONS = [
+	{
+		value: "fastapi",
+		label: "FastAPI",
+		hint: "Modern, fast (high-performance) web framework for building APIs"
+	},
+	{
+		value: "django",
+		label: "Django",
+		hint: "High-level Python web framework with batteries included"
+	},
+	{
+		value: "flask",
+		label: "Flask",
+		hint: "Lightweight WSGI web framework with minimal boilerplate"
+	},
+	{
+		value: "litestar",
+		label: "Litestar",
+		hint: "High-performance ASGI framework with class-based controllers"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No web framework"
+	}
+];
+const PYTHON_ORM_PROMPT_OPTIONS = [
+	{
+		value: "sqlalchemy",
+		label: "SQLAlchemy",
+		hint: "The SQL toolkit and ORM for Python"
+	},
+	{
+		value: "sqlmodel",
+		label: "SQLModel",
+		hint: "SQL databases in Python with Pydantic and SQLAlchemy"
+	},
+	{
+		value: "tortoise-orm",
+		label: "Tortoise ORM",
+		hint: "Async-first ORM with Django-like API"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No ORM/database layer"
+	}
+];
+const PYTHON_VALIDATION_PROMPT_OPTIONS = [{
+	value: "pydantic",
+	label: "Pydantic",
+	hint: "Data validation using Python type hints"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No validation library"
+}];
+const PYTHON_AI_PROMPT_OPTIONS = [
+	{
+		value: "none",
+		label: "None",
+		hint: "No AI/ML framework"
+	},
+	{
+		value: "langchain",
+		label: "LangChain",
+		hint: "Building applications with LLMs through composability"
+	},
+	{
+		value: "llamaindex",
+		label: "LlamaIndex",
+		hint: "Data framework for LLM applications"
+	},
+	{
+		value: "openai-sdk",
+		label: "OpenAI SDK",
+		hint: "Official OpenAI Python client"
+	},
+	{
+		value: "anthropic-sdk",
+		label: "Anthropic SDK",
+		hint: "Official Anthropic Claude API client"
+	},
+	{
+		value: "langgraph",
+		label: "LangGraph",
+		hint: "Graph-based agent orchestration"
+	},
+	{
+		value: "crewai",
+		label: "CrewAI",
+		hint: "Multi-agent orchestration framework"
+	}
+];
+const PYTHON_AUTH_PROMPT_OPTIONS = [
+	{
+		value: "authlib",
+		label: "Authlib",
+		hint: "Comprehensive auth library — OAuth1/2, OIDC, JWS, JWK, JWT"
+	},
+	{
+		value: "jwt",
+		label: "JWT (python-jose)",
+		hint: "Simple JWT token creation and verification"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No authentication library"
+	}
+];
+const PYTHON_TASK_QUEUE_PROMPT_OPTIONS = [{
+	value: "celery",
+	label: "Celery",
+	hint: "Distributed task queue for Python"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No task queue"
+}];
+const PYTHON_GRAPHQL_PROMPT_OPTIONS = [{
+	value: "strawberry",
+	label: "Strawberry",
+	hint: "Python GraphQL library using dataclasses and type hints"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No GraphQL framework"
+}];
+const PYTHON_QUALITY_PROMPT_OPTIONS = [{
+	value: "ruff",
+	label: "Ruff",
+	hint: "An extremely fast Python linter and formatter"
+}, {
+	value: "none",
+	label: "None",
+	hint: "No code quality tools"
+}];
+function resolvePythonWebFrameworkPrompt(pythonWebFramework) {
+	return createStaticSinglePromptResolution(PYTHON_WEB_FRAMEWORK_PROMPT_OPTIONS, "fastapi", pythonWebFramework);
+}
 async function getPythonWebFrameworkChoice(pythonWebFramework) {
-	if (pythonWebFramework !== void 0) return pythonWebFramework;
+	const resolution = resolvePythonWebFrameworkPrompt(pythonWebFramework);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python web framework",
-		options: [
-			{
-				value: "fastapi",
-				label: "FastAPI",
-				hint: "Modern, fast (high-performance) web framework for building APIs"
-			},
-			{
-				value: "django",
-				label: "Django",
-				hint: "High-level Python web framework with batteries included"
-			},
-			{
-				value: "flask",
-				label: "Flask",
-				hint: "Lightweight WSGI web framework with minimal boilerplate"
-			},
-			{
-				value: "litestar",
-				label: "Litestar",
-				hint: "High-performance ASGI framework with class-based controllers"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No web framework"
-			}
-		],
-		initialValue: "fastapi"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonOrmPrompt(pythonOrm) {
+	return createStaticSinglePromptResolution(PYTHON_ORM_PROMPT_OPTIONS, "sqlalchemy", pythonOrm);
+}
 async function getPythonOrmChoice(pythonOrm) {
-	if (pythonOrm !== void 0) return pythonOrm;
+	const resolution = resolvePythonOrmPrompt(pythonOrm);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python ORM/database layer",
-		options: [
-			{
-				value: "sqlalchemy",
-				label: "SQLAlchemy",
-				hint: "The SQL toolkit and ORM for Python"
-			},
-			{
-				value: "sqlmodel",
-				label: "SQLModel",
-				hint: "SQL databases in Python with Pydantic and SQLAlchemy"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No ORM/database layer"
-			}
-		],
-		initialValue: "sqlalchemy"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonValidationPrompt(pythonValidation) {
+	return createStaticSinglePromptResolution(PYTHON_VALIDATION_PROMPT_OPTIONS, "pydantic", pythonValidation);
+}
 async function getPythonValidationChoice(pythonValidation) {
-	if (pythonValidation !== void 0) return pythonValidation;
+	const resolution = resolvePythonValidationPrompt(pythonValidation);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python validation library",
-		options: [{
-			value: "pydantic",
-			label: "Pydantic",
-			hint: "Data validation using Python type hints"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No validation library"
-		}],
-		initialValue: "pydantic"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonAiPrompt(pythonAi) {
+	return createStaticMultiPromptResolution(PYTHON_AI_PROMPT_OPTIONS, [], pythonAi);
+}
 async function getPythonAiChoice(pythonAi) {
-	if (pythonAi !== void 0) return pythonAi;
+	const resolution = resolvePythonAiPrompt(pythonAi);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? [];
 	const response = await navigableMultiselect({
 		message: "Select Python AI/ML frameworks",
-		options: [
-			{
-				value: "none",
-				label: "None",
-				hint: "No AI/ML framework"
-			},
-			{
-				value: "langchain",
-				label: "LangChain",
-				hint: "Building applications with LLMs through composability"
-			},
-			{
-				value: "llamaindex",
-				label: "LlamaIndex",
-				hint: "Data framework for LLM applications"
-			},
-			{
-				value: "openai-sdk",
-				label: "OpenAI SDK",
-				hint: "Official OpenAI Python client"
-			},
-			{
-				value: "anthropic-sdk",
-				label: "Anthropic SDK",
-				hint: "Official Anthropic Claude API client"
-			},
-			{
-				value: "langgraph",
-				label: "LangGraph",
-				hint: "Graph-based agent orchestration"
-			},
-			{
-				value: "crewai",
-				label: "CrewAI",
-				hint: "Multi-agent orchestration framework"
-			}
-		],
+		options: resolution.options,
 		required: false,
-		initialValues: []
+		initialValues: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	if (response.includes("none")) return [];
 	return response;
 }
+function resolvePythonAuthPrompt(pythonAuth) {
+	return createStaticSinglePromptResolution(PYTHON_AUTH_PROMPT_OPTIONS, "none", pythonAuth);
+}
 async function getPythonAuthChoice(pythonAuth) {
-	if (pythonAuth !== void 0) return pythonAuth;
+	const resolution = resolvePythonAuthPrompt(pythonAuth);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python authentication library",
-		options: [
-			{
-				value: "authlib",
-				label: "Authlib",
-				hint: "Comprehensive auth library — OAuth1/2, OIDC, JWS, JWK, JWT"
-			},
-			{
-				value: "jwt",
-				label: "JWT (python-jose)",
-				hint: "Simple JWT token creation and verification"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No authentication library"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonTaskQueuePrompt(pythonTaskQueue) {
+	return createStaticSinglePromptResolution(PYTHON_TASK_QUEUE_PROMPT_OPTIONS, "none", pythonTaskQueue);
+}
 async function getPythonTaskQueueChoice(pythonTaskQueue) {
-	if (pythonTaskQueue !== void 0) return pythonTaskQueue;
+	const resolution = resolvePythonTaskQueuePrompt(pythonTaskQueue);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python task queue",
-		options: [{
-			value: "celery",
-			label: "Celery",
-			hint: "Distributed task queue for Python"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No task queue"
-		}],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonGraphqlPrompt(pythonGraphql) {
+	return createStaticSinglePromptResolution(PYTHON_GRAPHQL_PROMPT_OPTIONS, "none", pythonGraphql);
+}
 async function getPythonGraphqlChoice(pythonGraphql) {
-	if (pythonGraphql !== void 0) return pythonGraphql;
+	const resolution = resolvePythonGraphqlPrompt(pythonGraphql);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python GraphQL framework",
-		options: [{
-			value: "strawberry",
-			label: "Strawberry",
-			hint: "Python GraphQL library using dataclasses and type hints"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No GraphQL framework"
-		}],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolvePythonQualityPrompt(pythonQuality) {
+	return createStaticSinglePromptResolution(PYTHON_QUALITY_PROMPT_OPTIONS, "ruff", pythonQuality);
+}
 async function getPythonQualityChoice(pythonQuality) {
-	if (pythonQuality !== void 0) return pythonQuality;
+	const resolution = resolvePythonQualityPrompt(pythonQuality);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Python code quality tool",
-		options: [{
-			value: "ruff",
-			label: "Ruff",
-			hint: "An extremely fast Python linter and formatter"
-		}, {
-			value: "none",
-			label: "None",
-			hint: "No code quality tools"
-		}],
-		initialValue: "ruff"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3346,49 +4332,72 @@ async function getPythonQualityChoice(pythonQuality) {
 
 //#endregion
 //#region src/prompts/realtime.ts
+const REALTIME_PROMPT_OPTIONS = [
+	{
+		value: "socket-io",
+		label: "Socket.IO",
+		hint: "Real-time bidirectional communication with fallbacks"
+	},
+	{
+		value: "partykit",
+		label: "PartyKit",
+		hint: "Edge-native multiplayer infrastructure on Cloudflare"
+	},
+	{
+		value: "ably",
+		label: "Ably",
+		hint: "Real-time messaging platform with pub/sub and presence"
+	},
+	{
+		value: "pusher",
+		label: "Pusher",
+		hint: "Real-time communication APIs with channels and events"
+	},
+	{
+		value: "liveblocks",
+		label: "Liveblocks",
+		hint: "Collaboration infrastructure for multiplayer experiences"
+	},
+	{
+		value: "yjs",
+		label: "Y.js",
+		hint: "CRDT library for real-time collaboration with conflict-free sync"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip real-time/WebSocket integration"
+	}
+];
+function resolveRealtimePrompt(context = {}) {
+	if (context.backend === "none" || context.backend === "convex") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	return context.realtime !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options: REALTIME_PROMPT_OPTIONS,
+		autoValue: context.realtime
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options: REALTIME_PROMPT_OPTIONS,
+		initialValue: "none"
+	};
+}
 async function getRealtimeChoice(realtime, backend) {
-	if (realtime !== void 0) return realtime;
-	if (backend === "none" || backend === "convex") return "none";
+	const resolution = resolveRealtimePrompt({
+		realtime,
+		backend
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select real-time solution",
-		options: [
-			{
-				value: "socket-io",
-				label: "Socket.IO",
-				hint: "Real-time bidirectional communication with fallbacks"
-			},
-			{
-				value: "partykit",
-				label: "PartyKit",
-				hint: "Edge-native multiplayer infrastructure on Cloudflare"
-			},
-			{
-				value: "ably",
-				label: "Ably",
-				hint: "Real-time messaging platform with pub/sub and presence"
-			},
-			{
-				value: "pusher",
-				label: "Pusher",
-				hint: "Real-time communication APIs with channels and events"
-			},
-			{
-				value: "liveblocks",
-				label: "Liveblocks",
-				hint: "Collaboration infrastructure for multiplayer experiences"
-			},
-			{
-				value: "yjs",
-				label: "Y.js",
-				hint: "CRDT library for real-time collaboration with conflict-free sync"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip real-time/WebSocket integration"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3396,27 +4405,53 @@ async function getRealtimeChoice(realtime, backend) {
 
 //#endregion
 //#region src/prompts/runtime.ts
-async function getRuntimeChoice(runtime, backend) {
-	if (backend === "convex" || backend === "none" || backend === "self") return "none";
-	if (runtime !== void 0) return runtime;
-	const runtimeOptions = [{
+const RUNTIME_PROMPT_OPTIONS = [
+	{
 		value: "bun",
 		label: "Bun",
 		hint: "Fast all-in-one JavaScript runtime"
-	}, {
+	},
+	{
 		value: "node",
 		label: "Node.js",
 		hint: "Traditional Node.js runtime"
-	}];
-	if (backend === "hono") runtimeOptions.push({
+	},
+	{
 		value: "workers",
 		label: "Cloudflare Workers",
 		hint: "Edge runtime on Cloudflare's global network"
+	}
+];
+function resolveRuntimePrompt(context = {}) {
+	if (context.backend === "convex" || context.backend === "none" || context.backend === "self") return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	const options = RUNTIME_PROMPT_OPTIONS.filter((option) => option.value !== "workers" || context.backend === "hono");
+	return context.runtime !== void 0 ? {
+		shouldPrompt: false,
+		mode: "single",
+		options,
+		autoValue: context.runtime
+	} : {
+		shouldPrompt: true,
+		mode: "single",
+		options,
+		initialValue: DEFAULT_CONFIG.runtime
+	};
+}
+async function getRuntimeChoice(runtime, backend) {
+	const resolution = resolveRuntimePrompt({
+		runtime,
+		backend
 	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select runtime",
-		options: runtimeOptions,
-		initialValue: DEFAULT_CONFIG.runtime
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -3424,261 +4459,324 @@ async function getRuntimeChoice(runtime, backend) {
 
 //#endregion
 //#region src/prompts/rust-ecosystem.ts
+const RUST_WEB_FRAMEWORK_PROMPT_OPTIONS = [
+	{
+		value: "axum",
+		label: "Axum",
+		hint: "Ergonomic and modular web framework from Tokio"
+	},
+	{
+		value: "actix-web",
+		label: "Actix Web",
+		hint: "Powerful, pragmatic, and extremely fast web framework"
+	},
+	{
+		value: "rocket",
+		label: "Rocket",
+		hint: "Convention-over-configuration web framework, 25k+ stars"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No web framework"
+	}
+];
+const RUST_FRONTEND_PROMPT_OPTIONS = [
+	{
+		value: "leptos",
+		label: "Leptos",
+		hint: "Build fast web applications with Rust"
+	},
+	{
+		value: "dioxus",
+		label: "Dioxus",
+		hint: "Fullstack, cross-platform UI library for Rust"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No Rust frontend (API only)"
+	}
+];
+const RUST_ORM_PROMPT_OPTIONS = [
+	{
+		value: "sea-orm",
+		label: "SeaORM",
+		hint: "Async & dynamic ORM for Rust"
+	},
+	{
+		value: "sqlx",
+		label: "SQLx",
+		hint: "Async SQL toolkit with compile-time checked queries"
+	},
+	{
+		value: "diesel",
+		label: "Diesel",
+		hint: "Safe, extensible ORM with compile-time query validation"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No database layer"
+	}
+];
+const RUST_API_PROMPT_OPTIONS = [
+	{
+		value: "tonic",
+		label: "Tonic",
+		hint: "gRPC implementation for Rust"
+	},
+	{
+		value: "async-graphql",
+		label: "async-graphql",
+		hint: "High-performance GraphQL server library"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "REST API only"
+	}
+];
+const RUST_CLI_PROMPT_OPTIONS = [
+	{
+		value: "clap",
+		label: "Clap",
+		hint: "Command Line Argument Parser for Rust"
+	},
+	{
+		value: "ratatui",
+		label: "Ratatui",
+		hint: "Build rich terminal user interfaces"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No CLI tools"
+	}
+];
+const RUST_LIBRARIES_PROMPT_OPTIONS = [
+	{
+		value: "serde",
+		label: "Serde",
+		hint: "Serialization framework for Rust"
+	},
+	{
+		value: "validator",
+		label: "Validator",
+		hint: "Struct validation derive macros"
+	},
+	{
+		value: "jsonwebtoken",
+		label: "jsonwebtoken",
+		hint: "JWT encoding/decoding library"
+	},
+	{
+		value: "argon2",
+		label: "Argon2",
+		hint: "Password hashing library"
+	},
+	{
+		value: "tokio-test",
+		label: "Tokio Test",
+		hint: "Testing utilities for Tokio"
+	},
+	{
+		value: "mockall",
+		label: "Mockall",
+		hint: "Powerful mocking library for Rust"
+	}
+];
+const RUST_LOGGING_PROMPT_OPTIONS = [
+	{
+		value: "tracing",
+		label: "Tracing",
+		hint: "Structured, composable instrumentation framework from Tokio"
+	},
+	{
+		value: "env-logger",
+		label: "env_logger",
+		hint: "Simple logger configured via environment variables"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No logging library"
+	}
+];
+const RUST_ERROR_HANDLING_PROMPT_OPTIONS = [
+	{
+		value: "anyhow-thiserror",
+		label: "anyhow + thiserror",
+		hint: "anyhow for application errors, thiserror for custom error types"
+	},
+	{
+		value: "eyre",
+		label: "eyre + color-eyre",
+		hint: "Customizable error reports with pretty backtraces via color-eyre"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No error handling library (uses standard library only)"
+	}
+];
+const RUST_CACHING_PROMPT_OPTIONS = [
+	{
+		value: "moka",
+		label: "Moka",
+		hint: "High-performance concurrent in-memory cache (Caffeine-inspired)"
+	},
+	{
+		value: "redis",
+		label: "Redis",
+		hint: "Redis client with async support and connection pooling"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "No caching library"
+	}
+];
+function resolveRustWebFrameworkPrompt(rustWebFramework) {
+	return createStaticSinglePromptResolution(RUST_WEB_FRAMEWORK_PROMPT_OPTIONS, "axum", rustWebFramework);
+}
 async function getRustWebFrameworkChoice(rustWebFramework) {
-	if (rustWebFramework !== void 0) return rustWebFramework;
+	const resolution = resolveRustWebFrameworkPrompt(rustWebFramework);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust web framework",
-		options: [
-			{
-				value: "axum",
-				label: "Axum",
-				hint: "Ergonomic and modular web framework from Tokio"
-			},
-			{
-				value: "actix-web",
-				label: "Actix Web",
-				hint: "Powerful, pragmatic, and extremely fast web framework"
-			},
-			{
-				value: "rocket",
-				label: "Rocket",
-				hint: "Convention-over-configuration web framework, 25k+ stars"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No web framework"
-			}
-		],
-		initialValue: "axum"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustFrontendPrompt(rustFrontend) {
+	return createStaticSinglePromptResolution(RUST_FRONTEND_PROMPT_OPTIONS, "none", rustFrontend);
+}
 async function getRustFrontendChoice(rustFrontend) {
-	if (rustFrontend !== void 0) return rustFrontend;
+	const resolution = resolveRustFrontendPrompt(rustFrontend);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust frontend framework",
-		options: [
-			{
-				value: "leptos",
-				label: "Leptos",
-				hint: "Build fast web applications with Rust"
-			},
-			{
-				value: "dioxus",
-				label: "Dioxus",
-				hint: "Fullstack, cross-platform UI library for Rust"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No Rust frontend (API only)"
-			}
-		],
-		initialValue: "none"
-	});
-	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
-	return response;
-}
-async function getRustOrmChoice(rustOrm) {
-	if (rustOrm !== void 0) return rustOrm;
-	const response = await navigableSelect({
-		message: "Select Rust ORM/database layer",
-		options: [
-			{
-				value: "sea-orm",
-				label: "SeaORM",
-				hint: "Async & dynamic ORM for Rust"
-			},
-			{
-				value: "sqlx",
-				label: "SQLx",
-				hint: "Async SQL toolkit with compile-time checked queries"
-			},
-			{
-				value: "diesel",
-				label: "Diesel",
-				hint: "Safe, extensible ORM with compile-time query validation"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No database layer"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustOrmPrompt(rustOrm) {
+	return createStaticSinglePromptResolution(RUST_ORM_PROMPT_OPTIONS, "none", rustOrm);
+}
+async function getRustOrmChoice(rustOrm) {
+	const resolution = resolveRustOrmPrompt(rustOrm);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select Rust ORM/database layer",
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+function resolveRustApiPrompt(rustApi) {
+	return createStaticSinglePromptResolution(RUST_API_PROMPT_OPTIONS, "none", rustApi);
+}
 async function getRustApiChoice(rustApi) {
-	if (rustApi !== void 0) return rustApi;
+	const resolution = resolveRustApiPrompt(rustApi);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust API layer",
-		options: [
-			{
-				value: "tonic",
-				label: "Tonic",
-				hint: "gRPC implementation for Rust"
-			},
-			{
-				value: "async-graphql",
-				label: "async-graphql",
-				hint: "High-performance GraphQL server library"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "REST API only"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustCliPrompt(rustCli) {
+	return createStaticSinglePromptResolution(RUST_CLI_PROMPT_OPTIONS, "none", rustCli);
+}
 async function getRustCliChoice(rustCli) {
-	if (rustCli !== void 0) return rustCli;
+	const resolution = resolveRustCliPrompt(rustCli);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust CLI tools",
-		options: [
-			{
-				value: "clap",
-				label: "Clap",
-				hint: "Command Line Argument Parser for Rust"
-			},
-			{
-				value: "ratatui",
-				label: "Ratatui",
-				hint: "Build rich terminal user interfaces"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No CLI tools"
-			}
-		],
-		initialValue: "none"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustLibrariesPrompt(rustLibraries) {
+	return createStaticMultiPromptResolution(RUST_LIBRARIES_PROMPT_OPTIONS, [], rustLibraries);
+}
 async function getRustLibrariesChoice(rustLibraries) {
-	if (rustLibraries !== void 0) return rustLibraries;
+	const resolution = resolveRustLibrariesPrompt(rustLibraries);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? [];
 	const response = await navigableMultiselect({
 		message: "Select Rust libraries",
-		options: [
-			{
-				value: "serde",
-				label: "Serde",
-				hint: "Serialization framework for Rust"
-			},
-			{
-				value: "validator",
-				label: "Validator",
-				hint: "Struct validation derive macros"
-			},
-			{
-				value: "jsonwebtoken",
-				label: "jsonwebtoken",
-				hint: "JWT encoding/decoding library"
-			},
-			{
-				value: "argon2",
-				label: "Argon2",
-				hint: "Password hashing library"
-			},
-			{
-				value: "tokio-test",
-				label: "Tokio Test",
-				hint: "Testing utilities for Tokio"
-			},
-			{
-				value: "mockall",
-				label: "Mockall",
-				hint: "Powerful mocking library for Rust"
-			}
-		],
+		options: resolution.options,
 		required: false,
-		initialValues: ["serde"]
+		initialValues: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustLoggingPrompt(rustLogging) {
+	return createStaticSinglePromptResolution(RUST_LOGGING_PROMPT_OPTIONS, "tracing", rustLogging);
+}
 async function getRustLoggingChoice(rustLogging) {
-	if (rustLogging !== void 0) return rustLogging;
+	const resolution = resolveRustLoggingPrompt(rustLogging);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust logging library",
-		options: [
-			{
-				value: "tracing",
-				label: "Tracing",
-				hint: "Structured, composable instrumentation framework from Tokio"
-			},
-			{
-				value: "env-logger",
-				label: "env_logger",
-				hint: "Simple logger configured via environment variables"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No logging library"
-			}
-		],
-		initialValue: "tracing"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustErrorHandlingPrompt(rustErrorHandling) {
+	return createStaticSinglePromptResolution(RUST_ERROR_HANDLING_PROMPT_OPTIONS, "anyhow-thiserror", rustErrorHandling);
+}
 async function getRustErrorHandlingChoice(rustErrorHandling) {
-	if (rustErrorHandling !== void 0) return rustErrorHandling;
+	const resolution = resolveRustErrorHandlingPrompt(rustErrorHandling);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust error handling library",
-		options: [
-			{
-				value: "anyhow-thiserror",
-				label: "anyhow + thiserror",
-				hint: "anyhow for application errors, thiserror for custom error types"
-			},
-			{
-				value: "eyre",
-				label: "eyre + color-eyre",
-				hint: "Customizable error reports with pretty backtraces via color-eyre"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No error handling library (uses standard library only)"
-			}
-		],
-		initialValue: "anyhow-thiserror"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
 }
+function resolveRustCachingPrompt(rustCaching) {
+	return createStaticSinglePromptResolution(RUST_CACHING_PROMPT_OPTIONS, "none", rustCaching);
+}
 async function getRustCachingChoice(rustCaching) {
-	if (rustCaching !== void 0) return rustCaching;
+	const resolution = resolveRustCachingPrompt(rustCaching);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select Rust caching library",
-		options: [
-			{
-				value: "moka",
-				label: "Moka",
-				hint: "High-performance concurrent in-memory cache (Caffeine-inspired)"
-			},
-			{
-				value: "redis",
-				label: "Redis",
-				hint: "Redis client with async support and connection pooling"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "No caching library"
-			}
-		],
+		options: resolution.options,
+		initialValue: resolution.initialValue
+	});
+	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
+	return response;
+}
+async function getRustAuthChoice(rustAuth) {
+	if (rustAuth !== void 0) return rustAuth;
+	const response = await navigableSelect({
+		message: "Select Rust authentication library",
+		options: [{
+			value: "oauth2",
+			label: "OAuth2",
+			hint: "OAuth2 client with authorization code, PKCE, and token exchange flows"
+		}, {
+			value: "none",
+			label: "None",
+			hint: "No authentication library"
+		}],
 		initialValue: "none"
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
@@ -4123,10 +5221,20 @@ async function promptShadcnRadius() {
 
 //#endregion
 //#region src/prompts/state-management.ts
-async function getStateManagementChoice(stateManagement, frontends) {
-	if (stateManagement !== void 0) return stateManagement;
-	const { web } = splitFrontends$1(frontends);
-	if (web.length === 0) return "none";
+function resolveStateManagementPrompt(context = {}) {
+	if (context.stateManagement !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: context.stateManagement
+	};
+	const { web } = splitFrontends$1(context.frontends);
+	if (web.length === 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
 	const isReact = web.some((f) => [
 		"tanstack-router",
 		"react-router",
@@ -4180,10 +5288,23 @@ async function getStateManagementChoice(stateManagement, frontends) {
 		label: "None",
 		hint: "Skip state management setup"
 	});
-	const response = await navigableSelect({
-		message: "Select state management",
+	return {
+		shouldPrompt: true,
+		mode: "single",
 		options,
 		initialValue: "none"
+	};
+}
+async function getStateManagementChoice(stateManagement, frontends) {
+	const resolution = resolveStateManagementPrompt({
+		stateManagement,
+		frontends
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
+	const response = await navigableSelect({
+		message: "Select state management",
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -4191,43 +5312,48 @@ async function getStateManagementChoice(stateManagement, frontends) {
 
 //#endregion
 //#region src/prompts/testing.ts
+const TESTING_PROMPT_OPTIONS = [
+	{
+		value: "vitest",
+		label: "Vitest",
+		hint: "Blazing fast Vite-native unit test framework"
+	},
+	{
+		value: "vitest-playwright",
+		label: "Vitest + Playwright",
+		hint: "Both unit and E2E testing for complete coverage"
+	},
+	{
+		value: "playwright",
+		label: "Playwright",
+		hint: "End-to-end testing framework by Microsoft"
+	},
+	{
+		value: "jest",
+		label: "Jest",
+		hint: "Classic testing framework with wide ecosystem"
+	},
+	{
+		value: "cypress",
+		label: "Cypress",
+		hint: "E2E testing with time travel debugging"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Skip testing framework setup"
+	}
+];
+function resolveTestingPrompt(testing) {
+	return createStaticSinglePromptResolution(TESTING_PROMPT_OPTIONS, "vitest", testing);
+}
 async function getTestingChoice(testing) {
-	if (testing !== void 0) return testing;
+	const resolution = resolveTestingPrompt(testing);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select testing framework",
-		options: [
-			{
-				value: "vitest",
-				label: "Vitest",
-				hint: "Blazing fast Vite-native unit test framework"
-			},
-			{
-				value: "vitest-playwright",
-				label: "Vitest + Playwright",
-				hint: "Both unit and E2E testing for complete coverage"
-			},
-			{
-				value: "playwright",
-				label: "Playwright",
-				hint: "End-to-end testing framework by Microsoft"
-			},
-			{
-				value: "jest",
-				label: "Jest",
-				hint: "Classic testing framework with wide ecosystem"
-			},
-			{
-				value: "cypress",
-				label: "Cypress",
-				hint: "E2E testing with time travel debugging"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Skip testing framework setup"
-			}
-		],
-		initialValue: "vitest"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -4285,21 +5411,48 @@ const UI_LIBRARY_OPTIONS = {
 		hint: "No UI component library"
 	}
 };
-async function getUILibraryChoice(uiLibrary, frontends, astroIntegration) {
-	const { web } = splitFrontends$1(frontends);
-	if (web.length === 0) return "none";
-	const compatibleLibraries = getCompatibleUILibraries$1(frontends, astroIntegration);
-	if (uiLibrary !== void 0) return compatibleLibraries.includes(uiLibrary) ? uiLibrary : compatibleLibraries[0];
-	const options = compatibleLibraries.map((lib) => ({
-		value: lib,
-		label: UI_LIBRARY_OPTIONS[lib].label,
-		hint: UI_LIBRARY_OPTIONS[lib].hint
-	}));
+function resolveUILibraryPrompt(context = {}) {
+	const { web } = splitFrontends$1(context.frontends);
+	if (web.length === 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: [],
+		autoValue: "none"
+	};
+	const compatibleLibraries = getCompatibleUILibraries$1(context.frontends, context.astroIntegration);
+	if (context.uiLibrary !== void 0) return {
+		shouldPrompt: false,
+		mode: "single",
+		options: compatibleLibraries.map((lib) => ({
+			value: lib,
+			label: UI_LIBRARY_OPTIONS[lib].label,
+			hint: UI_LIBRARY_OPTIONS[lib].hint
+		})),
+		autoValue: compatibleLibraries.includes(context.uiLibrary) ? context.uiLibrary : compatibleLibraries[0]
+	};
 	const defaultLib = DEFAULT_UI_LIBRARY_BY_FRONTEND[web[0]];
+	return {
+		shouldPrompt: true,
+		mode: "single",
+		options: compatibleLibraries.map((lib) => ({
+			value: lib,
+			label: UI_LIBRARY_OPTIONS[lib].label,
+			hint: UI_LIBRARY_OPTIONS[lib].hint
+		})),
+		initialValue: compatibleLibraries.includes(defaultLib) ? defaultLib : compatibleLibraries[0]
+	};
+}
+async function getUILibraryChoice(uiLibrary, frontends, astroIntegration) {
+	const resolution = resolveUILibraryPrompt({
+		uiLibrary,
+		frontends,
+		astroIntegration
+	});
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const selected = await navigableSelect({
 		message: "Select UI component library",
-		options,
-		initialValue: compatibleLibraries.includes(defaultLib) ? defaultLib : compatibleLibraries[0]
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(selected)) return exitCancelled("Operation cancelled");
 	return selected;
@@ -4307,53 +5460,58 @@ async function getUILibraryChoice(uiLibrary, frontends, astroIntegration) {
 
 //#endregion
 //#region src/prompts/validation.ts
+const VALIDATION_PROMPT_OPTIONS = [
+	{
+		value: "zod",
+		label: "Zod",
+		hint: "TypeScript-first schema validation (recommended)"
+	},
+	{
+		value: "valibot",
+		label: "Valibot",
+		hint: "Smaller bundle alternative to Zod (~1KB)"
+	},
+	{
+		value: "arktype",
+		label: "ArkType",
+		hint: "TypeScript-first validation, 2-4x faster than Zod"
+	},
+	{
+		value: "typebox",
+		label: "TypeBox",
+		hint: "JSON Schema type builder for TypeScript"
+	},
+	{
+		value: "typia",
+		label: "Typia",
+		hint: "Super-fast validation via compile-time transform"
+	},
+	{
+		value: "runtypes",
+		label: "Runtypes",
+		hint: "Runtime type validation with composable validators"
+	},
+	{
+		value: "effect-schema",
+		label: "@effect/schema",
+		hint: "Effect ecosystem schema validation with powerful transformations"
+	},
+	{
+		value: "none",
+		label: "None",
+		hint: "Use Zod internally only (no additional library)"
+	}
+];
+function resolveValidationPrompt(validation) {
+	return createStaticSinglePromptResolution(VALIDATION_PROMPT_OPTIONS, "zod", validation);
+}
 async function getValidationChoice(validation) {
-	if (validation !== void 0) return validation;
+	const resolution = resolveValidationPrompt(validation);
+	if (!resolution.shouldPrompt) return resolution.autoValue ?? "none";
 	const response = await navigableSelect({
 		message: "Select validation library",
-		options: [
-			{
-				value: "zod",
-				label: "Zod",
-				hint: "TypeScript-first schema validation (recommended)"
-			},
-			{
-				value: "valibot",
-				label: "Valibot",
-				hint: "Smaller bundle alternative to Zod (~1KB)"
-			},
-			{
-				value: "arktype",
-				label: "ArkType",
-				hint: "TypeScript-first validation, 2-4x faster than Zod"
-			},
-			{
-				value: "typebox",
-				label: "TypeBox",
-				hint: "JSON Schema type builder for TypeScript"
-			},
-			{
-				value: "typia",
-				label: "Typia",
-				hint: "Super-fast validation via compile-time transform"
-			},
-			{
-				value: "runtypes",
-				label: "Runtypes",
-				hint: "Runtime type validation with composable validators"
-			},
-			{
-				value: "effect-schema",
-				label: "@effect/schema",
-				hint: "Effect ecosystem schema validation with powerful transformations"
-			},
-			{
-				value: "none",
-				label: "None",
-				hint: "Use Zod internally only (no additional library)"
-			}
-		],
-		initialValue: "zod"
+		options: resolution.options,
+		initialValue: resolution.initialValue
 	});
 	if (isCancel$1(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -4622,6 +5780,10 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 			if (results.ecosystem !== "rust") return Promise.resolve("none");
 			return getRustCachingChoice(flags.rustCaching);
 		},
+		rustAuth: ({ results }) => {
+			if (results.ecosystem !== "rust") return Promise.resolve("none");
+			return getRustAuthChoice(flags.rustAuth);
+		},
 		pythonWebFramework: ({ results }) => {
 			if (results.ecosystem !== "python") return Promise.resolve("none");
 			return getPythonWebFrameworkChoice(flags.pythonWebFramework);
@@ -4674,13 +5836,45 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 			if (results.ecosystem !== "go") return Promise.resolve("none");
 			return getGoLoggingChoice(flags.goLogging);
 		},
+		goAuth: ({ results }) => {
+			if (results.ecosystem !== "go") return Promise.resolve("none");
+			return getGoAuthChoice(flags.goAuth);
+		},
+		javaWebFramework: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve("none");
+			return getJavaWebFrameworkChoice(flags.javaWebFramework);
+		},
+		javaBuildTool: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve("none");
+			return getJavaBuildToolChoice(flags.javaBuildTool);
+		},
+		javaOrm: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve("none");
+			if (results.javaWebFramework !== "spring-boot" || results.javaBuildTool === "none") return Promise.resolve("none");
+			return getJavaOrmChoice(flags.javaOrm);
+		},
+		javaAuth: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve("none");
+			if (results.javaWebFramework !== "spring-boot" || results.javaBuildTool === "none") return Promise.resolve("none");
+			return getJavaAuthChoice(flags.javaAuth);
+		},
+		javaLibraries: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve([]);
+			if (results.javaWebFramework !== "spring-boot" || results.javaBuildTool === "none") return Promise.resolve([]);
+			return getJavaLibrariesChoice(flags.javaLibraries);
+		},
+		javaTestingLibraries: ({ results }) => {
+			if (results.ecosystem !== "java") return Promise.resolve([]);
+			if (results.javaBuildTool === "none") return Promise.resolve([]);
+			return getJavaTestingLibrariesChoice(flags.javaTestingLibraries);
+		},
 		aiDocs: () => getAiDocsChoice(flags.aiDocs),
 		git: () => getGitChoice(flags.git),
 		packageManager: ({ results }) => {
-			if (results.ecosystem === "rust" || results.ecosystem === "python" || results.ecosystem === "go") return Promise.resolve(flags.packageManager ?? getUserPkgManager());
+			if (results.ecosystem === "rust" || results.ecosystem === "python" || results.ecosystem === "go" || results.ecosystem === "java") return Promise.resolve(flags.packageManager ?? getUserPkgManager());
 			return getPackageManagerChoice(flags.packageManager);
 		},
-		install: ({ results }) => getinstallChoice(flags.install, results.ecosystem)
+		install: ({ results }) => getinstallChoice(flags.install, results.ecosystem, results.javaBuildTool)
 	}, { onCancel: () => exitCancelled("Operation cancelled") });
 	return {
 		projectName,
@@ -4736,6 +5930,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		rustLogging: result.rustLogging,
 		rustErrorHandling: result.rustErrorHandling,
 		rustCaching: result.rustCaching,
+		rustAuth: result.rustAuth,
 		pythonWebFramework: result.pythonWebFramework,
 		pythonOrm: result.pythonOrm,
 		pythonValidation: result.pythonValidation,
@@ -4749,6 +5944,13 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		goApi: result.goApi,
 		goCli: result.goCli,
 		goLogging: result.goLogging,
+		goAuth: result.goAuth,
+		javaWebFramework: result.javaWebFramework,
+		javaBuildTool: result.javaBuildTool,
+		javaOrm: result.javaOrm,
+		javaAuth: result.javaAuth,
+		javaLibraries: result.javaLibraries,
+		javaTestingLibraries: result.javaTestingLibraries,
 		aiDocs: result.aiDocs
 	};
 }
@@ -5028,6 +6230,7 @@ function getRustFlags(config) {
 	flags.push(`--rust-logging ${config.rustLogging}`);
 	flags.push(`--rust-error-handling ${config.rustErrorHandling}`);
 	flags.push(`--rust-caching ${config.rustCaching}`);
+	flags.push(`--rust-auth ${config.rustAuth}`);
 	appendSharedNonTypeScriptFlags(flags, config);
 	appendCommonFlags(flags, config);
 	return flags;
@@ -5053,11 +6256,24 @@ function getGoFlags(config) {
 	flags.push(`--go-api ${config.goApi}`);
 	flags.push(`--go-cli ${config.goCli}`);
 	flags.push(`--go-logging ${config.goLogging}`);
+	flags.push(`--go-auth ${config.goAuth}`);
 	flags.push(`--auth ${config.auth}`);
 	appendSharedNonTypeScriptFlags(flags, config);
 	appendCommonFlags(flags, config);
 	return flags;
 }
+function getJavaFlags(config) {
+	const flags = ["--ecosystem java"];
+	flags.push(`--java-web-framework ${config.javaWebFramework}`);
+	flags.push(`--java-build-tool ${config.javaBuildTool}`);
+	flags.push(`--java-orm ${config.javaOrm}`);
+	flags.push(`--java-auth ${config.javaAuth}`);
+	flags.push(formatArrayFlag("java-libraries", config.javaLibraries));
+	flags.push(formatArrayFlag("java-testing-libraries", config.javaTestingLibraries));
+	appendSharedNonTypeScriptFlags(flags, config);
+	appendCommonFlags(flags, config);
+	return flags;
+}
 function generateReproducibleCommand(config) {
 	let flags;
 	switch (config.ecosystem) {
@@ -5070,6 +6286,9 @@ function generateReproducibleCommand(config) {
 		case "go":
 			flags = getGoFlags(config);
 			break;
+		case "java":
+			flags = getJavaFlags(config);
+			break;
 		case "typescript":
 		default:
 			flags = getTypeScriptFlags(config);
@@ -5316,6 +6535,7 @@ function processFlags(options, projectName) {
 	if (options.rustLogging !== void 0) config.rustLogging = options.rustLogging;
 	if (options.rustErrorHandling !== void 0) config.rustErrorHandling = options.rustErrorHandling;
 	if (options.rustCaching !== void 0) config.rustCaching = options.rustCaching;
+	if (options.rustAuth !== void 0) config.rustAuth = options.rustAuth;
 	if (options.pythonWebFramework !== void 0) config.pythonWebFramework = options.pythonWebFramework;
 	if (options.pythonOrm !== void 0) config.pythonOrm = options.pythonOrm;
 	if (options.pythonValidation !== void 0) config.pythonValidation = options.pythonValidation;
@@ -5329,6 +6549,13 @@ function processFlags(options, projectName) {
 	if (options.goApi !== void 0) config.goApi = options.goApi;
 	if (options.goCli !== void 0) config.goCli = options.goCli;
 	if (options.goLogging !== void 0) config.goLogging = options.goLogging;
+	if (options.goAuth !== void 0) config.goAuth = options.goAuth;
+	if (options.javaWebFramework !== void 0) config.javaWebFramework = options.javaWebFramework;
+	if (options.javaBuildTool !== void 0) config.javaBuildTool = options.javaBuildTool;
+	if (options.javaOrm !== void 0) config.javaOrm = options.javaOrm;
+	if (options.javaAuth !== void 0) config.javaAuth = options.javaAuth;
+	if (options.javaLibraries !== void 0) config.javaLibraries = processArrayOption(options.javaLibraries);
+	if (options.javaTestingLibraries !== void 0) config.javaTestingLibraries = processArrayOption(options.javaTestingLibraries);
 	return config;
 }
 function getProvidedFlags(options) {
@@ -5342,6 +6569,11 @@ function validateArrayOptions(options) {
 	validateNoneExclusivity(options.frontend, "frontend options");
 	validateNoneExclusivity(options.addons, "addons");
 	validateNoneExclusivity(options.examples, "examples");
+	validateNoneExclusivity(options.aiDocs, "ai docs");
+	validateNoneExclusivity(options.rustLibraries, "rust libraries");
+	validateNoneExclusivity(options.pythonAi, "python ai libraries");
+	validateNoneExclusivity(options.javaLibraries, "java libraries");
+	validateNoneExclusivity(options.javaTestingLibraries, "java testing libraries");
 }
 
 //#endregion
@@ -5777,6 +7009,41 @@ function validateFrontendConstraints(config, providedFlags) {
 	validateWebDeployRequiresWebFrontend(config.webDeploy, hasWebFrontendFlag);
 }
 function validateApiConstraints(_config, _options) {}
+function validateJavaConstraints(config, providedFlags = /* @__PURE__ */ new Set()) {
+	if (config.ecosystem !== "java") return;
+	const hasSpringBoot = config.javaWebFramework === "spring-boot";
+	const hasNoBuildTool = config.javaBuildTool === "none";
+	const hasJavaLibraries = (config.javaLibraries ?? []).some((library) => library !== "none");
+	const hasJavaTestingLibraries = (config.javaTestingLibraries ?? []).some((library) => library !== "none");
+	const hasSpringOnlyFeatures = config.javaOrm !== "none" || config.javaAuth !== "none" || hasJavaLibraries;
+	if (hasNoBuildTool && hasSpringBoot) incompatibilityError({
+		message: "Spring Boot requires Maven or Gradle in the Java scaffold.",
+		provided: {
+			"java-web-framework": config.javaWebFramework ?? "none",
+			"java-build-tool": config.javaBuildTool ?? "none"
+		},
+		suggestions: ["Use --java-build-tool maven or --java-build-tool gradle with Spring Boot", "Use --java-web-framework none for a plain Java source-only scaffold"]
+	});
+	if ((config.javaWebFramework === "none" || hasNoBuildTool) && hasSpringOnlyFeatures) incompatibilityError({
+		message: "Spring-only Java features require the Spring Boot scaffold with Maven or Gradle.",
+		provided: {
+			"java-web-framework": config.javaWebFramework ?? "none",
+			"java-build-tool": config.javaBuildTool ?? "none",
+			"java-orm": config.javaOrm ?? "none",
+			"java-auth": config.javaAuth ?? "none",
+			"java-libraries": (config.javaLibraries ?? []).join(" ") || "none"
+		},
+		suggestions: ["Use --java-web-framework spring-boot and a real build tool for Spring features", "Clear --java-orm, --java-auth, and --java-libraries when using plain Java"]
+	});
+	if (hasNoBuildTool && hasJavaTestingLibraries) incompatibilityError({
+		message: "Java testing libraries require Maven or Gradle to manage test dependencies.",
+		provided: {
+			"java-build-tool": config.javaBuildTool ?? "none",
+			"java-testing-libraries": (config.javaTestingLibraries ?? []).join(" ") || "none"
+		},
+		suggestions: ["Use --java-build-tool maven or --java-build-tool gradle to enable JUnit/Mockito/Testcontainers", "Set --java-testing-libraries none for a source-only plain Java scaffold"]
+	});
+}
 function validateShadcnConstraints(config, providedFlags) {
 	const shadcnFlagMap = {
 		shadcnBase: "--shadcn-base",
@@ -5809,6 +7076,7 @@ function validateFullConfig(config, providedFlags, options) {
 	validateBackendConstraints(config, providedFlags, options);
 	validateFrontendConstraints(config, providedFlags);
 	/* @__PURE__ */ validateApiConstraints(config, options);
+	validateJavaConstraints(config, providedFlags);
 	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
 	validateSelfBackendCompatibility(providedFlags, options, config);
 	validateWorkersCompatibility(providedFlags, options, config);
@@ -5844,6 +7112,7 @@ function validateConfigForProgrammaticUse(config) {
 		validateDatabaseOrmAuth(config);
 		if (config.frontend && config.frontend.length > 0) ensureSingleWebAndNative(config.frontend);
 		validateApiFrontendCompatibility(config.api, config.frontend, config.astroIntegration);
+		validateJavaConstraints(config);
 		validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend);
 		if (config.addons && config.addons.length > 0) validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
 		validateExamplesCompatibility(config.examples ?? [], config.backend, config.frontend ?? [], config.runtime, config.ai);
@@ -6150,6 +7419,12 @@ async function setupMongoDBAtlas(config, cliInput) {
 			displayManualSetupInstructions$4();
 			return;
 		}
+		if (!canPromptInteractively()) {
+			log.info("MongoDB Atlas manual setup selected (non-interactive mode)");
+			await writeEnvFile$4(projectDir, backend);
+			displayManualSetupInstructions$4();
+			return;
+		}
 		const mode = await select({
 			message: "MongoDB Atlas setup: choose mode",
 			options: [{
@@ -6302,6 +7577,11 @@ async function setupNeonPostgres(config, cliInput) {
 			displayManualSetupInstructions$3(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
+		if (!canPromptInteractively()) {
+			await writeEnvFile$3(projectDir, backend);
+			displayManualSetupInstructions$3(backend === "self" ? "apps/web" : "apps/server");
+			return;
+		}
 		const mode = await select({
 			message: "Neon setup: choose mode",
 			options: [{
@@ -6346,7 +7626,7 @@ async function setupNeonPostgres(config, cliInput) {
 			const regionId = await select({
 				message: "Select a region for your Neon project:",
 				options: NEON_REGIONS,
-				initialValue: NEON_REGIONS[0].value
+				initialValue: NEON_REGIONS[0]?.value ?? "aws-us-east-1"
 			});
 			if (isCancel(projectName) || isCancel(regionId)) return exitCancelled("Operation cancelled");
 			const neonConfig = await createNeonProject(projectName, regionId, packageManager);
@@ -6455,11 +7735,11 @@ const AVAILABLE_REGIONS = [
 async function setupWithCreateDb(serverDir, packageManager) {
 	try {
 		log.info("Starting Prisma Postgres setup with create-db.");
-		const selectedRegion = await select({
+		const selectedRegion = canPromptInteractively() ? await select({
 			message: "Select your preferred region:",
 			options: AVAILABLE_REGIONS,
 			initialValue: "ap-southeast-1"
-		});
+		}) : "ap-southeast-1";
 		if (isCancel(selectedRegion)) return null;
 		const createDbArgs = getPackageExecutionArgs(packageManager, `create-db@latest --json --region ${selectedRegion}`);
 		const s = spinner();
@@ -6522,6 +7802,11 @@ async function setupPrismaPostgres(config, cliInput) {
 			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
 			return;
 		}
+		if (!canPromptInteractively()) {
+			await writeEnvFile$2(projectDir, backend);
+			displayManualSetupInstructions$2(backend === "self" ? "apps/web" : "apps/server");
+			return;
+		}
 		const setupMode = await select({
 			message: "Prisma Postgres setup: choose mode",
 			options: [{
@@ -6657,6 +7942,11 @@ async function setupSupabase(config, cliInput) {
 			await writeSupabaseEnvFile(projectDir, backend, "");
 			return;
 		}
+		if (!canPromptInteractively()) {
+			displayManualSupabaseInstructions();
+			await writeSupabaseEnvFile(projectDir, backend, "");
+			return;
+		}
 		const mode = await select({
 			message: "Supabase setup: choose mode",
 			options: [{
@@ -6846,6 +8136,11 @@ async function setupTurso(config, cliInput) {
 			displayManualSetupInstructions$1();
 			return;
 		}
+		if (!canPromptInteractively()) {
+			await writeEnvFile$1(projectDir, backend);
+			displayManualSetupInstructions$1();
+			return;
+		}
 		const mode = await select({
 			message: "Turso setup: choose mode",
 			options: [{
@@ -6968,6 +8263,12 @@ async function setupUpstash(config, cliInput) {
 			displayManualSetupInstructions();
 			return;
 		}
+		if (!canPromptInteractively()) {
+			log.info("Upstash Redis manual setup selected (non-interactive mode)");
+			await writeEnvFile(projectDir, backend);
+			displayManualSetupInstructions();
+			return;
+		}
 		const mode = await select({
 			message: "Upstash Redis setup: choose mode",
 			options: [{
@@ -7176,6 +8477,10 @@ async function displayPostInstallInstructions(config) {
 		displayGoInstructions(config);
 		return;
 	}
+	if (ecosystem === "java") {
+		displayJavaInstructions(config);
+		return;
+	}
 	if (ecosystem === "python") {
 		displayPythonInstructions(config);
 		return;
@@ -7445,6 +8750,8 @@ function displayRustInstructions(config) {
 		moka: "Moka",
 		redis: "Redis"
 	}[rustCaching] || rustCaching}\n`;
+	const { rustAuth } = config;
+	if (rustAuth && rustAuth !== "none") output += `${pc.cyan("•")} Auth: ${{ oauth2: "OAuth2" }[rustAuth] || rustAuth}\n`;
 	output += `\n${pc.bold("Common Cargo commands:")}\n`;
 	output += `${pc.cyan("•")} Build: cargo build\n`;
 	output += `${pc.cyan("•")} Run: cargo run\n`;
@@ -7458,7 +8765,7 @@ function displayRustInstructions(config) {
 	consola$1.box(output);
 }
 function displayGoInstructions(config) {
-	const { relativePath, depsInstalled, goWebFramework, goOrm, goApi, goCli, goLogging } = config;
+	const { relativePath, depsInstalled, goWebFramework, goOrm, goApi, goCli, goLogging, goAuth } = config;
 	const cdCmd = `cd ${relativePath}`;
 	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
 	let stepCounter = 2;
@@ -7486,6 +8793,10 @@ function displayGoInstructions(config) {
 		zerolog: "Zerolog",
 		slog: "slog"
 	}[goLogging] || goLogging}\n`;
+	if (goAuth && goAuth !== "none") output += `${pc.cyan("•")} Auth: ${{
+		casbin: "Casbin",
+		jwt: "golang-jwt"
+	}[goAuth] || goAuth}\n`;
 	output += `\n${pc.bold("Common Go commands:")}\n`;
 	output += `${pc.cyan("•")} Build: go build ./...\n`;
 	output += `${pc.cyan("•")} Run: go run cmd/server/main.go\n`;
@@ -7501,6 +8812,162 @@ function displayGoInstructions(config) {
 	output += pc.dim("Your star helps other developers discover the project.");
 	consola$1.box(output);
 }
+const JAVA_GROUP_ID = "com.example";
+const JAVA_RESERVED_WORDS = new Set([
+	"abstract",
+	"assert",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"default",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"extends",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"instanceof",
+	"int",
+	"interface",
+	"long",
+	"native",
+	"new",
+	"non-sealed",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"sealed",
+	"short",
+	"static",
+	"strictfp",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"try",
+	"void",
+	"volatile",
+	"while",
+	"yield",
+	"record",
+	"permits",
+	"true",
+	"false",
+	"null"
+]);
+function sanitizeJavaPackageSuffix(projectName) {
+	const alphanumericOnly = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+	const withLetterPrefix = /^[a-z]/.test(alphanumericOnly) ? alphanumericOnly : `app${alphanumericOnly}`;
+	return (JAVA_RESERVED_WORDS.has(withLetterPrefix) ? `app${withLetterPrefix}` : withLetterPrefix) || "app";
+}
+function getJavaMainClass(projectName) {
+	return `${JAVA_GROUP_ID}.${sanitizeJavaPackageSuffix(projectName)}.Application`;
+}
+function getJavaMainSourcePath(projectName) {
+	return `src/main/java/${getJavaMainClass(projectName).replace(/\./g, "/")}.java`;
+}
+function displayJavaInstructions(config) {
+	const { projectName, relativePath, depsInstalled, javaWebFramework, javaBuildTool, javaOrm, javaAuth, javaLibraries, javaTestingLibraries } = config;
+	const cdCmd = `cd ${relativePath}`;
+	const isSpringBoot = javaWebFramework === "spring-boot" && javaBuildTool !== "none";
+	const rawJavaLibraries = isSpringBoot ? javaLibraries.filter((library) => library !== "none") : [];
+	const rawJavaLibrarySet = new Set(rawJavaLibraries);
+	const jpaRequiredJavaLibraries = new Set(["flyway", "liquibase"]);
+	const effectiveJavaLibraries = [];
+	for (const library of rawJavaLibraries) {
+		if (jpaRequiredJavaLibraries.has(library) && javaOrm !== "spring-data-jpa") continue;
+		if (library === "liquibase" && rawJavaLibrarySet.has("flyway")) continue;
+		effectiveJavaLibraries.push(library);
+	}
+	const effectiveJavaTestingLibraries = javaBuildTool === "none" ? [] : javaTestingLibraries.filter((library) => library !== "none");
+	const buildToolCommand = javaBuildTool === "none" ? null : javaBuildTool === "gradle" ? process.platform === "win32" ? "gradlew.bat" : "./gradlew" : process.platform === "win32" ? "mvnw.cmd" : "./mvnw";
+	const runCommand = buildToolCommand ? isSpringBoot ? javaBuildTool === "gradle" ? `${buildToolCommand} bootRun` : `${buildToolCommand} spring-boot:run` : javaBuildTool === "gradle" ? `${buildToolCommand} run` : `${buildToolCommand} exec:java` : null;
+	const packageCommand = buildToolCommand ? javaBuildTool === "gradle" ? `${buildToolCommand} build` : `${buildToolCommand} package` : null;
+	const sourceCompileCommand = buildToolCommand ? null : `javac -d out ${getJavaMainSourcePath(projectName)}`;
+	const sourceRunCommand = buildToolCommand ? null : `java -cp out ${getJavaMainClass(projectName)}`;
+	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
+	let stepCounter = 2;
+	if (!depsInstalled && buildToolCommand && effectiveJavaTestingLibraries.length > 0) output += `${pc.cyan(`${stepCounter++}.`)} ${buildToolCommand} test\n`;
+	if (runCommand) output += `${pc.cyan(`${stepCounter++}.`)} ${runCommand}\n`;
+	else if (sourceCompileCommand && sourceRunCommand) {
+		output += `${pc.cyan(`${stepCounter++}.`)} ${sourceCompileCommand}\n`;
+		output += `${pc.cyan(`${stepCounter++}.`)} ${sourceRunCommand}\n`;
+	} else output += `${pc.cyan(`${stepCounter++}.`)} Add Maven or Gradle, then run the app\n`;
+	output += `\n${pc.bold("Your Java project includes:")}\n`;
+	if (isSpringBoot) output += `${pc.cyan("•")} Web Framework: ${{ "spring-boot": "Spring Boot" }[javaWebFramework] || javaWebFramework}\n`;
+	else output += `${pc.cyan("•")} Scaffold: Plain Java\n`;
+	if (javaBuildTool && javaBuildTool !== "none") output += `${pc.cyan("•")} Build Tool: ${{
+		maven: "Maven Wrapper",
+		gradle: "Gradle Wrapper"
+	}[javaBuildTool] || javaBuildTool}\n`;
+	else output += `${pc.cyan("•")} Build Tool: None\n`;
+	if (isSpringBoot && javaOrm && javaOrm !== "none") output += `${pc.cyan("•")} ORM: ${{ "spring-data-jpa": "Spring Data JPA" }[javaOrm] || javaOrm}\n`;
+	if (isSpringBoot && javaAuth && javaAuth !== "none") output += `${pc.cyan("•")} Auth: ${{ "spring-security": "Spring Security" }[javaAuth] || javaAuth}\n`;
+	if (effectiveJavaLibraries.length > 0) {
+		const libraryNames = {
+			"spring-actuator": "Spring Actuator",
+			"spring-validation": "Spring Validation",
+			flyway: "Flyway",
+			liquibase: "Liquibase",
+			"springdoc-openapi": "Springdoc OpenAPI",
+			lombok: "Lombok",
+			mapstruct: "MapStruct",
+			caffeine: "Caffeine"
+		};
+		const libraryList = effectiveJavaLibraries.map((library) => libraryNames[library] || library).join(", ");
+		output += `${pc.cyan("•")} Libraries: ${libraryList}\n`;
+	}
+	if (effectiveJavaTestingLibraries.length > 0) {
+		const testingNames = {
+			junit5: "JUnit 5",
+			mockito: "Mockito",
+			testcontainers: "Testcontainers",
+			assertj: "AssertJ",
+			"rest-assured": "REST Assured",
+			wiremock: "WireMock",
+			awaitility: "Awaitility",
+			archunit: "ArchUnit",
+			jqwik: "jqwik"
+		};
+		const testingList = effectiveJavaTestingLibraries.map((library) => testingNames[library] || library).join(", ");
+		output += `${pc.cyan("•")} Testing: ${testingList}\n`;
+	}
+	output += `\n${pc.bold("Common Java commands:")}\n`;
+	if (buildToolCommand && runCommand && packageCommand) {
+		if (effectiveJavaTestingLibraries.length > 0) output += `${pc.cyan("•")} Test: ${buildToolCommand} test\n`;
+		output += `${pc.cyan("•")} Run: ${runCommand}\n`;
+		output += `${pc.cyan("•")} Package: ${packageCommand}\n`;
+	} else if (sourceCompileCommand && sourceRunCommand) {
+		output += `${pc.cyan("•")} Compile: ${sourceCompileCommand}\n`;
+		output += `${pc.cyan("•")} Run: ${sourceRunCommand}\n`;
+	} else output += `${pc.cyan("•")} Configure Maven or Gradle before running build commands\n`;
+	if (isSpringBoot) {
+		output += `\n${pc.bold("Your project will be available at:")}\n`;
+		output += `${pc.cyan("•")} API: http://localhost:8080\n`;
+	}
+	output += `\n${pc.bold("Enjoying Better Fullstack?")} Help us grow — star the repo!\n`;
+	output += `${pc.cyan("https://github.com/Marve10s/Better-Fullstack")}\n`;
+	output += pc.dim("Your star helps other developers discover the project.");
+	consola$1.box(output);
+}
 function displayPythonInstructions(config) {
 	const { relativePath, depsInstalled, pythonWebFramework, pythonOrm, pythonValidation, pythonAi, pythonTaskQueue, pythonQuality } = config;
 	const cdCmd = `cd ${relativePath}`;
@@ -7521,7 +8988,8 @@ function displayPythonInstructions(config) {
 	}[pythonWebFramework] || pythonWebFramework}\n`;
 	if (pythonOrm && pythonOrm !== "none") output += `${pc.cyan("•")} ORM: ${{
 		sqlalchemy: "SQLAlchemy",
-		sqlmodel: "SQLModel"
+		sqlmodel: "SQLModel",
+		"tortoise-orm": "Tortoise ORM"
 	}[pythonOrm] || pythonOrm}\n`;
 	if (pythonValidation && pythonValidation !== "none") output += `${pc.cyan("•")} Validation: ${{ pydantic: "Pydantic" }[pythonValidation] || pythonValidation}\n`;
 	if (pythonAi && pythonAi.length > 0 && !pythonAi.includes("none")) {
@@ -7566,6 +9034,7 @@ async function createProject(options, cliInput = {}) {
 		if (!result.success || !result.tree) throw new Error(result.error || "Failed to generate project templates");
 		await writeTreeToFilesystem(result.tree, projectDir);
 		await setPackageManagerVersion(projectDir, options.packageManager);
+		await ensurePackageManagerProjectFiles(projectDir, options.packageManager);
 		if (!isConvex && options.database !== "none") await setupDatabase(options, cliInput);
 		if (options.addons.length > 0 && options.addons[0] !== "none") await setupAddons(options);
 		await applyDependencyVersionChannel(projectDir, options.versionChannel);
@@ -7579,6 +9048,8 @@ async function createProject(options, cliInput = {}) {
 		if (options.install && options.ecosystem === "rust") await runCargoBuild({ projectDir });
 		if (options.install && options.ecosystem === "python") await runUvSync({ projectDir });
 		if (options.install && options.ecosystem === "go") await runGoModTidy({ projectDir });
+		if (options.install && options.ecosystem === "java" && options.javaBuildTool !== "none") if (options.javaBuildTool === "gradle") await runGradleTests({ projectDir });
+		else await runMavenTests({ projectDir });
 		await initializeGit(projectDir, options.git);
 		if (!isSilent()) await displayPostInstallInstructions({
 			...options,
@@ -7610,12 +9081,18 @@ async function setPackageManagerVersion(projectDir, packageManager) {
 		await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 	}
 }
+async function ensurePackageManagerProjectFiles(projectDir, packageManager) {
+	if (packageManager !== "yarn") return;
+	const yarnLockPath = path.join(projectDir, "yarn.lock");
+	if (await fs.pathExists(yarnLockPath)) return;
+	await fs.writeFile(yarnLockPath, "");
+}
 
 //#endregion
 //#region src/helpers/core/command-handlers.ts
 function shouldPromptForVersionChannel(input) {
 	if (input.yes || input.versionChannel !== void 0 || isSilent()) return false;
-	return process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.CI !== "true";
+	return canPromptInteractively();
 }
 async function createProjectHandler(input, options = {}) {
 	const { silent = false } = options;
@@ -7707,6 +9184,7 @@ async function createProjectHandler(input, options = {}) {
 							rustLogging: "none",
 							rustErrorHandling: "none",
 							rustCaching: "none",
+							rustAuth: "none",
 							cms: "none",
 							caching: "none",
 							i18n: "none",
@@ -7727,6 +9205,13 @@ async function createProjectHandler(input, options = {}) {
 							goApi: "none",
 							goCli: "none",
 							goLogging: "none",
+							goAuth: "none",
+							javaWebFramework: "none",
+							javaBuildTool: "none",
+							javaOrm: "none",
+							javaAuth: "none",
+							javaLibraries: [],
+							javaTestingLibraries: [],
 							aiDocs: []
 						},
 						reproducibleCommand: "",
@@ -7991,93 +9476,13 @@ function displaySponsorsBox(sponsors$1) {
 
 //#endregion
 //#region src/index.ts
+const OPTION_ENTRY_COUNT = Object.values(types_exports.OPTION_CATEGORY_METADATA).reduce((sum, metadata) => sum + metadata.options.length, 0);
 const router = os.router({
 	create: os.meta({
-		description: "Scaffold a new Better Fullstack project from 270+ compatible stack options",
+		description: `Scaffold a new Better Fullstack project from ${OPTION_ENTRY_COUNT} compatible stack options`,
 		default: true,
 		negateBooleans: true
-	}).input(z.tuple([types_exports.ProjectNameSchema.optional(), z.object({
-		template: types_exports.TemplateSchema.optional().describe("Use a predefined template"),
-		yes: z.boolean().optional().default(false).describe("Use default configuration"),
-		yolo: z.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
-		verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
-		dryRun: z.boolean().optional().default(false).describe("Preview generated file tree without writing to disk"),
-		ecosystem: types_exports.EcosystemSchema.optional().describe("Language ecosystem (typescript, rust, python, or go)"),
-		database: types_exports.DatabaseSchema.optional(),
-		orm: types_exports.ORMSchema.optional(),
-		auth: types_exports.AuthSchema.optional(),
-		payments: types_exports.PaymentsSchema.optional(),
-		email: types_exports.EmailSchema.optional(),
-		fileUpload: types_exports.FileUploadSchema.optional(),
-		effect: types_exports.EffectSchema.optional(),
-		stateManagement: types_exports.StateManagementSchema.optional(),
-		validation: types_exports.ValidationSchema.optional(),
-		forms: types_exports.FormsSchema.optional(),
-		testing: types_exports.TestingSchema.optional(),
-		ai: types_exports.AISchema.optional(),
-		realtime: types_exports.RealtimeSchema.optional(),
-		jobQueue: types_exports.JobQueueSchema.optional(),
-		animation: types_exports.AnimationSchema.optional(),
-		logging: types_exports.LoggingSchema.optional(),
-		observability: types_exports.ObservabilitySchema.optional(),
-		featureFlags: types_exports.FeatureFlagsSchema.optional().describe("Feature flags provider"),
-		analytics: types_exports.AnalyticsSchema.optional().describe("Privacy-focused analytics"),
-		cms: types_exports.CMSSchema.optional().describe("Headless CMS solution"),
-		caching: types_exports.CachingSchema.optional().describe("Caching solution"),
-		i18n: types_exports.I18nSchema.optional().describe("Internationalization (i18n) library"),
-		search: types_exports.SearchSchema.optional().describe("Search engine solution"),
-		fileStorage: types_exports.FileStorageSchema.optional().describe("File storage solution (S3, R2)"),
-		frontend: z.array(types_exports.FrontendSchema).optional(),
-		astroIntegration: types_exports.AstroIntegrationSchema.optional().describe("Astro UI framework integration (react, vue, svelte, solid)"),
-		addons: z.array(types_exports.AddonsSchema).optional(),
-		examples: z.array(types_exports.ExamplesSchema).optional(),
-		git: z.boolean().optional(),
-		packageManager: types_exports.PackageManagerSchema.optional(),
-		install: z.boolean().optional(),
-		versionChannel: types_exports.VersionChannelSchema.optional().describe("Dependency version channel (stable, latest, beta)"),
-		dbSetup: types_exports.DatabaseSetupSchema.optional(),
-		backend: types_exports.BackendSchema.optional(),
-		runtime: types_exports.RuntimeSchema.optional(),
-		api: types_exports.APISchema.optional(),
-		cssFramework: types_exports.CSSFrameworkSchema.optional(),
-		uiLibrary: types_exports.UILibrarySchema.optional(),
-		shadcnBase: types_exports.ShadcnBaseSchema.optional().describe("shadcn/ui headless library (radix, base)"),
-		shadcnStyle: types_exports.ShadcnStyleSchema.optional().describe("shadcn/ui visual style (vega, nova, maia, lyra, mira)"),
-		shadcnIconLibrary: types_exports.ShadcnIconLibrarySchema.optional().describe("shadcn/ui icon library (lucide, tabler, hugeicons, phosphor, remixicon)"),
-		shadcnColorTheme: types_exports.ShadcnColorThemeSchema.optional().describe("shadcn/ui color theme (neutral, blue, violet, etc.)"),
-		shadcnBaseColor: types_exports.ShadcnBaseColorSchema.optional().describe("shadcn/ui base neutral color (neutral, stone, zinc, gray)"),
-		shadcnFont: types_exports.ShadcnFontSchema.optional().describe("shadcn/ui font (inter, geist, figtree, etc.)"),
-		shadcnRadius: types_exports.ShadcnRadiusSchema.optional().describe("shadcn/ui border radius (default, none, small, medium, large)"),
-		webDeploy: types_exports.WebDeploySchema.optional(),
-		serverDeploy: types_exports.ServerDeploySchema.optional(),
-		directoryConflict: types_exports.DirectoryConflictSchema.optional(),
-		renderTitle: z.boolean().optional(),
-		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
-		manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup"),
-		rustWebFramework: types_exports.RustWebFrameworkSchema.optional().describe("Rust web framework (axum, actix-web)"),
-		rustFrontend: types_exports.RustFrontendSchema.optional().describe("Rust WASM frontend (leptos, dioxus)"),
-		rustOrm: types_exports.RustOrmSchema.optional().describe("Rust ORM/database (sea-orm, sqlx)"),
-		rustApi: types_exports.RustApiSchema.optional().describe("Rust API layer (tonic, async-graphql)"),
-		rustCli: types_exports.RustCliSchema.optional().describe("Rust CLI tools (clap, ratatui)"),
-		rustLibraries: z.array(types_exports.RustLibrariesSchema).optional().describe("Rust core libraries"),
-		rustLogging: types_exports.RustLoggingSchema.optional().describe("Rust logging (tracing, env-logger)"),
-		rustErrorHandling: types_exports.RustErrorHandlingSchema.optional().describe("Rust error handling (anyhow-thiserror, eyre)"),
-		rustCaching: types_exports.RustCachingSchema.optional().describe("Rust caching (moka, redis)"),
-		pythonWebFramework: types_exports.PythonWebFrameworkSchema.optional().describe("Python web framework (fastapi, django)"),
-		pythonOrm: types_exports.PythonOrmSchema.optional().describe("Python ORM/database (sqlalchemy, sqlmodel)"),
-		pythonValidation: types_exports.PythonValidationSchema.optional().describe("Python validation (pydantic)"),
-		pythonAi: z.array(types_exports.PythonAiSchema).optional().describe("Python AI/ML frameworks"),
-		pythonAuth: types_exports.PythonAuthSchema.optional().describe("Python auth library (authlib, jwt)"),
-		pythonTaskQueue: types_exports.PythonTaskQueueSchema.optional().describe("Python task queue (celery)"),
-		pythonGraphql: types_exports.PythonGraphqlSchema.optional().describe("Python GraphQL framework (strawberry)"),
-		pythonQuality: types_exports.PythonQualitySchema.optional().describe("Python code quality (ruff)"),
-		goWebFramework: types_exports.GoWebFrameworkSchema.optional().describe("Go web framework (gin, echo, fiber)"),
-		goOrm: types_exports.GoOrmSchema.optional().describe("Go ORM/database (gorm, sqlc)"),
-		goApi: types_exports.GoApiSchema.optional().describe("Go API layer (grpc-go)"),
-		goCli: types_exports.GoCliSchema.optional().describe("Go CLI tools (cobra, bubbletea)"),
-		goLogging: types_exports.GoLoggingSchema.optional().describe("Go logging (zap, zerolog, slog)"),
-		aiDocs: z.array(types_exports.AiDocsSchema).optional().describe("AI documentation files (claude-md, agents-md, cursorrules)")
-	})])).handler(async ({ input }) => {
+	}).input(CreateCommandInputSchema).handler(async ({ input }) => {
 		const [projectName, options] = input;
 		const result = await createProjectHandler({
 			projectName,
@@ -8309,6 +9714,7 @@ async function createVirtual(options) {
 				rustLogging: options.rustLogging || (options.ecosystem === "rust" ? "tracing" : "none"),
 				rustErrorHandling: options.rustErrorHandling || (options.ecosystem === "rust" ? "anyhow-thiserror" : "none"),
 				rustCaching: options.rustCaching || "none",
+				rustAuth: options.rustAuth || "none",
 				pythonWebFramework: options.pythonWebFramework || "none",
 				pythonOrm: options.pythonOrm || "none",
 				pythonValidation: options.pythonValidation || "none",
@@ -8322,6 +9728,13 @@ async function createVirtual(options) {
 				goApi: options.goApi || "none",
 				goCli: options.goCli || "none",
 				goLogging: options.goLogging || "none",
+				goAuth: options.goAuth || "none",
+				javaWebFramework: options.javaWebFramework || (options.ecosystem === "java" ? "spring-boot" : "none"),
+				javaBuildTool: options.javaBuildTool || (options.ecosystem === "java" ? "maven" : "none"),
+				javaOrm: options.javaOrm || "none",
+				javaAuth: options.javaAuth || "none",
+				javaLibraries: options.javaLibraries || [],
+				javaTestingLibraries: options.javaTestingLibraries || (options.ecosystem === "java" ? ["junit5"] : []),
 				aiDocs: options.aiDocs || ["claude-md"]
 			},
 			templates: EMBEDDED_TEMPLATES$1