create-better-t-stack 3.27.4 → 3.28.0

package/dist/{src-nmBsmday.mjs → src-CHenuE55.mjs}

@@ -5,7 +5,7 @@ import { initTRPC } from "@trpc/server";
 import { Result, Result as Result$1, TaggedError } from "better-result";
 import { createCli } from "trpc-cli";
 import z from "zod";
-import { cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import { cancel, confirm, intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import path from "node:path";
 import envPaths from "env-paths";
@@ -86,6 +86,7 @@ const ADDON_COMPATIBILITY = {
 	opentui: [],
 	wxt: [],
 	skills: [],
+	evlog: [],
 	none: []
 };
 //#endregion
@@ -757,7 +758,7 @@ function splitFrontends(values = []) {
 }
 function ensureSingleWebAndNative(frontends) {
 	const { web, native } = splitFrontends(frontends);
-	if (web.length > 1) return validationErr$1("Cannot select multiple web frameworks. Choose only one of: tanstack-router, tanstack-start, react-router, next, nuxt, svelte, solid");
+	if (web.length > 1) return validationErr$1("Cannot select multiple web frameworks. Choose only one of: tanstack-router, tanstack-start, react-router, next, nuxt, svelte, solid, astro");
 	if (native.length > 1) return validationErr$1("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
 	return Result.ok(void 0);
 }
@@ -765,18 +766,36 @@ const FULLSTACK_FRONTENDS$1 = [
 	"next",
 	"tanstack-start",
 	"nuxt",
+	"svelte",
 	"astro"
 ];
+const EVLOG_SERVER_BACKENDS = [
+	"hono",
+	"express",
+	"fastify",
+	"elysia"
+];
+const EVLOG_FULLSTACK_FRONTENDS = FULLSTACK_FRONTENDS$1;
+const evlogCompatibilityMessage = "evlog addon supports Hono, Express, Fastify, Elysia, or backend self with Next.js, TanStack Start, Nuxt, SvelteKit, or Astro. Convex and backend none are not supported yet.";
+function supportsEvlogAddon(frontend = [], backend, _runtime) {
+	if (!backend) return true;
+	if (EVLOG_SERVER_BACKENDS.includes(backend)) return true;
+	if (backend === "self") {
+		if (frontend.length === 0) return true;
+		return frontend.some((f) => EVLOG_FULLSTACK_FRONTENDS.includes(f));
+	}
+	return false;
+}
 function validateSelfBackendCompatibility(providedFlags, options, config) {
 	const backend = config.backend || options.backend;
 	const frontends = config.frontend || options.frontend || [];
 	if (backend === "self") {
 		const { web, native } = splitFrontends(frontends);
-		if (!(web.length === 1 && FULLSTACK_FRONTENDS$1.includes(web[0]))) return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, or --frontend astro. Support for SvelteKit will be added in a future update.");
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS$1.includes(web[0]))) return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, or --frontend astro.");
 		if (native.length > 1) return validationErr$1("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
 	}
 	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS$1.includes(f));
-	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend astro, or choose a different backend. Support for SvelteKit will be added in a future update.");
+	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend astro, or choose a different backend.");
 	return Result.ok(void 0);
 }
 function validateWorkersCompatibility(providedFlags, options, config) {
@@ -849,7 +868,11 @@ function validateServerDeployRequiresBackend(serverDeploy, backend) {
 	if (serverDeploy && serverDeploy !== "none" && (!backend || backend === "none")) return validationErr$1("'--server-deploy' requires a backend. Please select a backend or set '--server-deploy none'.");
 	return Result.ok(void 0);
 }
-function validateAddonCompatibility(addon, frontend, _auth) {
+function validateAddonCompatibility(addon, frontend, _auth, backend, runtime) {
+	if (addon === "evlog" && !supportsEvlogAddon(frontend, backend, runtime)) return {
+		isCompatible: false,
+		reason: evlogCompatibilityMessage
+	};
 	const compatibleFrontends = ADDON_COMPATIBILITY[addon];
 	if (compatibleFrontends.length > 0) {
 		if (!frontend.some((f) => compatibleFrontends.includes(f))) return {
@@ -859,23 +882,26 @@ function validateAddonCompatibility(addon, frontend, _auth) {
 	}
 	return { isCompatible: true };
 }
-function getCompatibleAddons(allAddons, frontend, existingAddons = [], auth) {
+function getCompatibleAddons(allAddons, frontend, existingAddons = [], auth, backend, runtime) {
 	return allAddons.filter((addon) => {
 		if (existingAddons.includes(addon)) return false;
 		if (addon === "none") return false;
-		const { isCompatible } = validateAddonCompatibility(addon, frontend, auth);
+		const { isCompatible } = validateAddonCompatibility(addon, frontend, auth, backend, runtime);
 		return isCompatible;
 	});
 }
-function validateAddonsAgainstFrontends(addons = [], frontends = [], auth) {
+function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backend, runtime) {
 	if (addons.includes("turborepo") && addons.includes("nx")) return validationErr$1("Cannot combine 'turborepo' and 'nx' addons. Choose one monorepo tool.");
 	for (const addon of addons) {
 		if (addon === "none") continue;
-		const { isCompatible, reason } = validateAddonCompatibility(addon, frontends, auth);
+		const { isCompatible, reason } = validateAddonCompatibility(addon, frontends, auth, backend, runtime);
 		if (!isCompatible) return validationErr$1(`Incompatible addon/frontend combination: ${reason}`);
 	}
 	return Result.ok(void 0);
 }
+function validateAddonsAgainstConfig(addons = [], config) {
+	return validateAddonsAgainstFrontends(addons, config.frontend ?? [], config.auth, config.backend, config.runtime);
+}
 function validatePaymentsCompatibility(payments, auth, _backend, frontends = []) {
 	if (!payments || payments === "none") return Result.ok(void 0);
 	if (payments === "polar") {
@@ -1207,6 +1233,10 @@ function getAddonDisplay(addon) {
 			label = "MCP";
 			hint = "Install MCP servers, including Better T Stack, via add-mcp";
 			break;
+		case "evlog":
+			label = "evlog";
+			hint = "Request logging with Better Auth context and AI SDK telemetry";
+			break;
 		default:
 			label = addon;
 			hint = `Add ${addon}`;
@@ -1233,6 +1263,7 @@ const ADDON_GROUPS = {
 		"opentui",
 		"wxt"
 	],
+	Observability: ["evlog"],
 	"AI & Agent Tools": ["skills", "mcp"]
 };
 function createGroupedOptions() {
@@ -1259,13 +1290,13 @@ function sortAndPruneGroupedOptions(groupedOptions) {
 function validateAddonSelection(selected) {
 	if (selected?.includes("turborepo") && selected.includes("nx")) return "Choose either Turborepo or Nx as your monorepo tool, not both.";
 }
-async function getAddonsChoice(addons, frontends, auth) {
+async function getAddonsChoice(addons, frontends, auth, backend, runtime) {
 	if (addons !== void 0) return addons;
 	const allAddons = types_exports.AddonsSchema.options.filter((addon) => addon !== "none");
 	const groupedOptions = createGroupedOptions();
 	const frontendsArray = frontends || [];
 	for (const addon of allAddons) {
-		const { isCompatible } = validateAddonCompatibility(addon, frontendsArray, auth);
+		const { isCompatible } = validateAddonCompatibility(addon, frontendsArray, auth, backend, runtime);
 		if (!isCompatible) continue;
 		const { label, hint } = getAddonDisplay(addon);
 		addOptionToGroup(groupedOptions, {
@@ -1285,10 +1316,10 @@ async function getAddonsChoice(addons, frontends, auth) {
 	if (isCancel$1(response)) throw new UserCancelledError({ message: "Operation cancelled" });
 	return response;
 }
-async function getAddonsToAdd(frontend, existingAddons = [], auth) {
+async function getAddonsToAdd(config) {
 	const groupedOptions = createGroupedOptions();
-	const frontendArray = frontend || [];
-	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, existingAddons, auth);
+	const frontendArray = config.frontend || [];
+	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, config.addons, config.auth, config.backend, config.runtime);
 	for (const addon of compatibleAddons) {
 		const { label, hint } = getAddonDisplay(addon);
 		addOptionToGroup(groupedOptions, {
@@ -1381,6 +1412,597 @@ const addPackageDependency = async (opts) => {
 	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 };
 //#endregion
+//#region src/helpers/addons/evlog-setup.ts
+const evlogBackends = [
+	"hono",
+	"express",
+	"fastify",
+	"elysia"
+];
+const evlogWebFrontends = [
+	"next",
+	"nuxt",
+	"svelte",
+	"tanstack-start",
+	"astro"
+];
+function isEvlogBackend(backend) {
+	return evlogBackends.includes(backend);
+}
+function getEvlogWebFrontend(frontends) {
+	return frontends.find((frontend) => evlogWebFrontends.includes(frontend));
+}
+function shouldIdentifyWebAuth(config) {
+	return config.auth === "better-auth" && config.backend === "self";
+}
+function prependMissingImports(content, imports) {
+	const missingImports = imports.filter((line) => !content.includes(line));
+	if (missingImports.length === 0) return content;
+	const importBlock = `${missingImports.join("\n")}\n`;
+	const referenceMatch = content.match(/^(?:\/\/\/ <reference[^\n]*>\n)+/);
+	if (referenceMatch) return `${referenceMatch[0]}${importBlock}${content.slice(referenceMatch[0].length)}`;
+	return `${importBlock}${content}`;
+}
+function addNamedImport(content, moduleName, names) {
+	const importRegex = new RegExp(`import \\{([^}]+)\\} from "${moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}";`);
+	const match = content.match(importRegex);
+	if (!match) return prependMissingImports(content, [`import { ${names.join(", ")} } from "${moduleName}";`]);
+	const nextNames = [...match[1].split(",").map((name) => name.trim()).filter(Boolean)];
+	for (const name of names) if (!nextNames.includes(name)) nextNames.push(name);
+	return content.replace(match[0], `import { ${nextNames.join(", ")} } from "${moduleName}";`);
+}
+function insertBeforeOnce(content, marker, snippet, alreadyPresent) {
+	if (content.includes(alreadyPresent)) return content;
+	if (!content.includes(marker)) return content;
+	return content.replace(marker, `${snippet}${marker}`);
+}
+function insertAfterOnce(content, marker, snippet, alreadyPresent) {
+	if (content.includes(alreadyPresent)) return content;
+	if (!content.includes(marker)) return content;
+	return content.replace(marker, `${marker}${snippet}`);
+}
+async function writeFileIfChanged(filePath, content) {
+	if ((await fs.pathExists(filePath) ? await fs.readFile(filePath, "utf-8") : void 0) === content) return;
+	await fs.ensureDir(path.dirname(filePath));
+	await fs.writeFile(filePath, content);
+}
+async function updateFileIfExists(filePath, update) {
+	if (!await fs.pathExists(filePath)) return;
+	const content = await fs.readFile(filePath, "utf-8");
+	const nextContent = update(content);
+	if (nextContent !== content) await fs.writeFile(filePath, nextContent);
+}
+function usesCreateAuthFactory(config) {
+	return config.runtime === "workers" || config.serverDeploy === "cloudflare" || config.backend === "self" && config.webDeploy === "cloudflare";
+}
+function getAuthImportLine(config) {
+	return usesCreateAuthFactory(config) ? `import { createAuth } from "@${config.projectName}/auth";` : `import { auth } from "@${config.projectName}/auth";`;
+}
+function getAuthExpression(config) {
+	return usesCreateAuthFactory(config) ? "createAuth()" : "auth";
+}
+function addAiSdkEvlogTelemetry(content, loggerExpression) {
+	let nextContent = addNamedImport(content, "evlog/ai", ["createAILogger", "createEvlogIntegration"]);
+	if (!nextContent.includes("const ai = createAILogger(")) nextContent = nextContent.replace(/^(\s*)const model = wrapLanguageModel\({/m, (_match, indent) => `${indent}const ai = createAILogger(${loggerExpression});\n${indent}const model = wrapLanguageModel({`);
+	if (!nextContent.includes("model: ai.wrap(model)")) nextContent = nextContent.replace(/(const result = streamText\({\n\s*)model,/, "$1model: ai.wrap(model),");
+	if (!nextContent.includes("createEvlogIntegration(ai)")) nextContent = nextContent.replace(/(messages:\s*await convertToModelMessages\([^)]+\),?)/, (match) => `${match.endsWith(",") ? match : `${match},`}\n\t\texperimental_telemetry: {\n\t\t\tisEnabled: true,\n\t\t\tintegrations: [createEvlogIntegration(ai)],\n\t\t},`);
+	return nextContent;
+}
+function addEvlogBetterAuthServerSetup(content, backend, authExpression) {
+	let nextContent = addNamedImport(content, "evlog/better-auth", ["createAuthMiddleware", "type BetterAuthInstance"]);
+	const usesAuthFactory = authExpression.endsWith("()");
+	const evlogAuthExpression = `${authExpression} as BetterAuthInstance`;
+	const authOptions = "{ exclude: [\"/api/auth/**\"], maskEmail: true }";
+	const identifySnippet = usesAuthFactory ? "" : `const identifyUser = createAuthMiddleware(${evlogAuthExpression}, ${authOptions});\n\n`;
+	const identifyUserSetup = usesAuthFactory ? `\n\tconst identifyUser = createAuthMiddleware(${evlogAuthExpression}, ${authOptions});` : "";
+	if (backend === "hono") {
+		nextContent = insertBeforeOnce(nextContent, "const app = new Hono", identifySnippet, "createAuthMiddleware(");
+		return insertAfterOnce(nextContent, "app.use(evlog());", `\napp.use("*", async (c, next) => {${identifyUserSetup}\n\tawait identifyUser(c.get("log"), c.req.raw.headers, c.req.path);\n\tawait next();\n});`, "identifyUser(c.get(\"log\")");
+	}
+	if (backend === "express") {
+		nextContent = insertBeforeOnce(nextContent, "const app = express();", identifySnippet, "createAuthMiddleware(");
+		return insertAfterOnce(nextContent, "app.use(evlog());", `\napp.use(async (req, _res, next) => {${identifyUserSetup}\n\tawait identifyUser(req.log, req.headers, req.path);\n\tnext();\n});`, "identifyUser(req.log");
+	}
+	if (backend === "fastify") {
+		nextContent = addNamedImport(nextContent, "evlog/fastify", ["useLogger"]);
+		nextContent = insertBeforeOnce(nextContent, "const fastify = Fastify", identifySnippet, "createAuthMiddleware(");
+		return insertAfterOnce(nextContent, "fastify.register(evlog);", `\nfastify.addHook("preHandler", async (request) => {${identifyUserSetup}\n\tawait identifyUser(useLogger(), request.headers, request.url);\n});`, "identifyUser(useLogger()");
+	}
+	nextContent = insertBeforeOnce(nextContent, "new Elysia", identifySnippet, "createAuthMiddleware(");
+	return insertAfterOnce(nextContent, ".use(evlog())", `\n\t.derive(async ({ request, log }) => {${identifyUserSetup.replace(/\n\t/g, "\n		")}\n\t\tawait identifyUser(log, request.headers, new URL(request.url).pathname);\n\t\treturn {};\n\t})`, "identifyUser(log");
+}
+function addEvlogServerSetup(content, backend, serviceName) {
+	const initSnippet = `initLogger({\n\tenv: { service: "${serviceName}" },\n});\n\n`;
+	if (backend === "hono") {
+		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog, type EvlogVariables } from \"evlog/hono\";"]);
+		nextContent = insertBeforeOnce(nextContent, "const app = new Hono", initSnippet, "initLogger({");
+		nextContent = nextContent.replace("const app = new Hono();", "const app = new Hono<EvlogVariables>();");
+		nextContent = nextContent.replace("import { logger } from \"hono/logger\";\n", "").replace(/\napp\.use\(logger\(\)\);/, "");
+		return insertAfterOnce(nextContent, "const app = new Hono<EvlogVariables>();", "\n\napp.use(evlog());", "app.use(evlog());");
+	}
+	if (backend === "express") {
+		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/express\";"]);
+		nextContent = insertBeforeOnce(nextContent, "const app = express();", initSnippet, "initLogger({");
+		return insertAfterOnce(nextContent, "const app = express();", "\n\napp.use(evlog());", "app.use(evlog());");
+	}
+	if (backend === "fastify") {
+		let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/fastify\";"]);
+		nextContent = insertBeforeOnce(nextContent, "const fastify = Fastify", initSnippet, "initLogger({");
+		return insertBeforeOnce(nextContent, "fastify.register(fastifyCors", "fastify.register(evlog);\n", "fastify.register(evlog);");
+	}
+	let nextContent = prependMissingImports(content, ["import { initLogger } from \"evlog\";", "import { evlog } from \"evlog/elysia\";"]);
+	nextContent = insertBeforeOnce(nextContent, "new Elysia", initSnippet, "initLogger({");
+	for (const marker of ["new Elysia({ adapter: node() })", "new Elysia()"]) nextContent = insertAfterOnce(nextContent, marker, "\n	.use(evlog())", ".use(evlog())");
+	return nextContent;
+}
+function addNuxtEvlogSetup(content, serviceName) {
+	let nextContent = content;
+	if (!nextContent.includes("\"evlog/nuxt\"") && !nextContent.includes("'evlog/nuxt'")) nextContent = nextContent.replace(/modules:\s*\[/, (match) => `${match}\n    "evlog/nuxt",`);
+	if (!nextContent.includes("evlog:")) nextContent = nextContent.replace(/\n\}\)\s*$/, (match) => {
+		const contentBeforeConfigClose = nextContent.slice(0, -match.length);
+		return `${!/[,{]\s*$/.test(contentBeforeConfigClose) ? "," : ""}\n  evlog: {\n    env: { service: "${serviceName}" },\n  },\n})`;
+	});
+	return nextContent;
+}
+function addSvelteViteEvlogSetup(content, serviceName) {
+	let nextContent = prependMissingImports(content, ["import evlog from \"evlog/vite\";"]);
+	if (nextContent.includes("evlog({")) return nextContent;
+	return nextContent.replace("plugins: [tailwindcss(), sveltekit()],", `plugins: [\n    tailwindcss(),\n    sveltekit(),\n    evlog({ service: "${serviceName}" }),\n  ],`);
+}
+function addSvelteHooksEvlogSetup(content) {
+	let nextContent = prependMissingImports(content, ["import { createEvlogHooks } from \"evlog/sveltekit\";"]);
+	if (!nextContent.includes("export const handle") && !nextContent.includes("const authHandle")) {
+		if (!nextContent.includes("createEvlogHooks()")) nextContent = `${nextContent.trimEnd()}\n\nexport const { handle, handleError } = createEvlogHooks();\n`;
+		return nextContent;
+	}
+	nextContent = prependMissingImports(nextContent, ["import { sequence } from \"@sveltejs/kit/hooks\";"]);
+	if (!nextContent.includes("const { handle: evlogHandle, handleError }")) nextContent = nextContent.replace(/((?:import .+\n)+)/, `$1\nconst { handle: evlogHandle, handleError } = createEvlogHooks();\n\n`);
+	nextContent = nextContent.replace(/export const handle(:\s*Handle)?\s*=\s*async/, (_match, typeAnnotation) => `const authHandle${typeAnnotation ?? ""} = async`);
+	if (!nextContent.includes("sequence(evlogHandle, authHandle)")) nextContent = `${nextContent.trimEnd()}\n\nexport const handle = sequence(evlogHandle as Handle, authHandle);\nexport { handleError };\n`;
+	return nextContent;
+}
+function addSvelteLocalsType(content) {
+	let nextContent = prependMissingImports(content, ["import type { RequestLogger } from \"evlog\";"]);
+	if (nextContent.includes("log: RequestLogger")) return nextContent;
+	if (nextContent.includes("// interface Locals {}")) return nextContent.replace("// interface Locals {}", "interface Locals {\n			log: RequestLogger;\n		}");
+	return nextContent.replace("namespace App {", "namespace App {\n		interface Locals {\n			log: RequestLogger;\n		}\n");
+}
+function addTanstackStartRootEvlogSetup(content) {
+	let nextContent = prependMissingImports(content, ["import { createMiddleware } from \"@tanstack/react-start\";", "import { evlogErrorHandler } from \"evlog/nitro/v3\";"]);
+	const middlewareEntry = "createMiddleware().server(evlogErrorHandler)";
+	if (nextContent.includes(`middleware: [${middlewareEntry}]`)) return nextContent;
+	if (nextContent.includes("middleware: [")) return nextContent.replace("middleware: [", `middleware: [${middlewareEntry}, `);
+	if (/server:\s*{/.test(nextContent)) return nextContent.replace(/server:\s*{\n/, `server: {\n    middleware: [${middlewareEntry}],\n`);
+	return nextContent.replace("head: () => ({", `server: {\n    middleware: [${middlewareEntry}],\n  },\n\n  head: () => ({`);
+}
+function addAstroMiddlewareEvlogSetup(content, serviceName) {
+	let nextContent = prependMissingImports(content, ["import { createRequestLogger, initLogger } from \"evlog\";"]);
+	const initSnippet = `initLogger({\n  env: { service: "${serviceName}" },\n});\n\n`;
+	nextContent = insertBeforeOnce(nextContent, "export const onRequest", initSnippet, "initLogger({");
+	if (nextContent.includes("createRequestLogger({")) return nextContent;
+	const contextMarker = "export const onRequest = defineMiddleware(async (context, next) => {";
+	if (nextContent.includes(contextMarker)) {
+		nextContent = insertAfterOnce(nextContent, contextMarker, `\n  const url = new URL(context.request.url);\n  const log = createRequestLogger({\n    method: context.request.method,\n    path: url.pathname,\n  });\n\n  context.locals.log = log;\n`, "const log = createRequestLogger({");
+		return nextContent.replace("return next();", "const response = await next();\n  log.emit();\n  return response;");
+	}
+	const localsMarker = "export const onRequest = defineMiddleware(async ({ request, locals }, next) => {";
+	if (nextContent.includes(localsMarker)) {
+		nextContent = insertAfterOnce(nextContent, localsMarker, `\n  const url = new URL(request.url);\n  const log = createRequestLogger({\n    method: request.method,\n    path: url.pathname,\n  });\n\n  locals.log = log;\n`, "const log = createRequestLogger({");
+		return nextContent.replace("return next();", "const response = await next();\n  log.emit();\n  return response;");
+	}
+	return nextContent;
+}
+function addAstroLocalsType(content) {
+	let nextContent = prependMissingImports(content, ["import type { RequestLogger } from \"evlog\";"]);
+	if (nextContent.includes("log: RequestLogger")) return nextContent;
+	if (nextContent.includes("interface Locals {")) return nextContent.replace("interface Locals {", "interface Locals {\n    log: RequestLogger;");
+	if (nextContent.includes("declare namespace App {")) return nextContent.replace("declare namespace App {", "declare namespace App {\n  interface Locals {\n    log: RequestLogger;\n  }\n");
+	return `${nextContent.trimEnd()}\n\ndeclare namespace App {\n  interface Locals {\n    log: RequestLogger;\n  }\n}\n`;
+}
+function addNextRouteWrappers(content) {
+	let nextContent = prependMissingImports(content, ["import { withEvlog } from \"@/lib/evlog\";"]);
+	if (nextContent.includes("withEvlog(handler)") || nextContent.includes("withEvlog(handleRequest)")) return nextContent;
+	nextContent = nextContent.replace("export { handler as GET, handler as POST };", "export const GET = withEvlog(handler);\nexport const POST = withEvlog(handler);");
+	for (const method of [
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]) nextContent = nextContent.replace(`export const ${method} = handleRequest;`, `export const ${method} = withEvlog(handleRequest);`);
+	return nextContent;
+}
+function addNextAiEvlogSetup(content) {
+	let nextContent = addNamedImport(content, "@/lib/evlog", ["withEvlog"]);
+	if (!nextContent.includes("withEvlog(async (req: Request)")) {
+		nextContent = nextContent.replace("export async function POST(req: Request) {", "export const POST = withEvlog(async (req: Request) => {");
+		if (nextContent.includes("export const POST = withEvlog(async (req: Request) => {")) nextContent = nextContent.replace(/\n}\s*$/, "\n});\n");
+	}
+	return nextContent;
+}
+function addNuxtAiEvlogSetup(content) {
+	return addAiSdkEvlogTelemetry(content, "useLogger(event)");
+}
+function addSvelteAiEvlogSetup(content) {
+	return addAiSdkEvlogTelemetry(content.replace("export const POST: RequestHandler = async ({ request }) => {", "export const POST: RequestHandler = async ({ request, locals }) => {"), "locals.log");
+}
+function addTanstackStartAiEvlogSetup(content) {
+	return addAiSdkEvlogTelemetry(prependMissingImports(content, ["import type { RequestLogger } from \"evlog\";", "import { useRequest } from \"nitro/context\";"]), "useRequest().context.log as RequestLogger");
+}
+function addBackendAiEvlogSetup(content, backend) {
+	if (backend === "hono") return addAiSdkEvlogTelemetry(content, "c.get(\"log\")");
+	if (backend === "express") return addAiSdkEvlogTelemetry(content, "req.log");
+	if (backend === "fastify") return addAiSdkEvlogTelemetry(addNamedImport(content, "evlog/fastify", ["useLogger"]), "useLogger()");
+	return addAiSdkEvlogTelemetry(content, "context.log");
+}
+function addNextBetterAuthToRoute(content) {
+	let nextContent = addNamedImport(content, "@/lib/evlog-auth", ["identifyEvlogUser"]);
+	nextContent = nextContent.replace("function handler(req:", "async function handler(req:");
+	for (const marker of [
+		"async function handler(req: NextRequest) {",
+		"async function handleRequest(req: NextRequest) {",
+		"export const POST = withEvlog(async (req: Request) => {"
+	]) nextContent = insertAfterOnce(nextContent, marker, "\n	await identifyEvlogUser(req);", "identifyEvlogUser(req)");
+	return nextContent;
+}
+function addSvelteBetterAuthEvlogSetup(content, config) {
+	if (!content.includes("authHandle") || content.includes("evlogAuthHandle")) return content;
+	let nextContent = addNamedImport(content, "evlog/better-auth", ["createAuthMiddleware", "type BetterAuthInstance"]);
+	if (!nextContent.includes(`@${config.projectName}/auth`)) nextContent = prependMissingImports(nextContent, [getAuthImportLine(config)]);
+	if (usesCreateAuthFactory(config) && config.webDeploy === "cloudflare" && !nextContent.includes(`@${config.projectName}/env/server`)) nextContent = prependMissingImports(nextContent, [`import { env as localEnv } from "@${config.projectName}/env/server";`]);
+	const authExpression = getAuthExpression(config);
+	const authOptions = "{ exclude: [\"/api/auth/**\"], maskEmail: true }";
+	const authHandleSnippet = usesCreateAuthFactory(config) && config.webDeploy === "cloudflare" ? `const evlogAuthHandle: Handle = async ({ event, resolve }) => {\n\tif (building) {\n\t\treturn resolve(event);\n\t}\n\n\tconst authEnv = event.platform?.env ?? localEnv;\n\tconst identifyUser = createAuthMiddleware(createAuth(authEnv) as BetterAuthInstance, ${authOptions});\n\tawait identifyUser(event.locals.log, event.request.headers, event.url.pathname);\n\treturn resolve(event);\n};\n\n` : `const identifyUser = createAuthMiddleware(${authExpression} as BetterAuthInstance, ${authOptions});\n\nconst evlogAuthHandle: Handle = async ({ event, resolve }) => {\n\tawait identifyUser(event.locals.log, event.request.headers, event.url.pathname);\n\treturn resolve(event);\n};\n\n`;
+	nextContent = insertAfterOnce(nextContent, "const { handle: evlogHandle, handleError } = createEvlogHooks();\n\n", authHandleSnippet, "evlogAuthHandle");
+	return nextContent.replace("sequence(evlogHandle as Handle, authHandle)", "sequence(evlogHandle as Handle, evlogAuthHandle, authHandle)").replace("sequence(evlogHandle, authHandle)", "sequence(evlogHandle as Handle, evlogAuthHandle, authHandle)");
+}
+function addAstroBetterAuthEvlogSetup(content, config) {
+	if (content.includes("createAuthMiddleware(")) return content;
+	let nextContent = addNamedImport(content, "evlog/better-auth", ["createAuthMiddleware", "type BetterAuthInstance"]);
+	if (!nextContent.includes(`@${config.projectName}/auth`)) nextContent = prependMissingImports(nextContent, [getAuthImportLine(config)]);
+	const authExpression = getAuthExpression(config);
+	const authOptions = "{ exclude: [\"/api/auth/**\"], maskEmail: true }";
+	const usesFactory = usesCreateAuthFactory(config);
+	if (!usesFactory) nextContent = insertBeforeOnce(nextContent, "export const onRequest", `const identifyUser = createAuthMiddleware(${authExpression} as BetterAuthInstance, ${authOptions});\n\n`, "const identifyUser = createAuthMiddleware(");
+	for (const marker of ["context.locals.log = log;", "locals.log = log;"]) {
+		if (!nextContent.includes(marker)) continue;
+		const requestExpression = marker.startsWith("context") ? "context.request" : "request";
+		const identifySnippet = usesFactory ? `\n\n  const identifyUser = createAuthMiddleware(${authExpression} as BetterAuthInstance, ${authOptions});\n  await identifyUser(log, ${requestExpression}.headers, url.pathname);` : `\n\n  await identifyUser(log, ${requestExpression}.headers, url.pathname);`;
+		return insertAfterOnce(nextContent, marker, identifySnippet, "identifyUser(log");
+	}
+	return nextContent;
+}
+function getNextEvlogFile(serviceName) {
+	return `import { createEvlog } from "evlog/next";
+import { createInstrumentation } from "evlog/next/instrumentation";
+
+export const { withEvlog, useLogger, log, createError } = createEvlog({
+  service: "${serviceName}",
+});
+
+export const { register, onRequestError } = createInstrumentation({
+  service: "${serviceName}",
+});
+`;
+}
+function getNextInstrumentationFile() {
+	return `import { defineNodeInstrumentation } from "evlog/next/instrumentation";
+
+export const { register, onRequestError } = defineNodeInstrumentation(() => import("./src/lib/evlog"));
+`;
+}
+function getNextProxyFile() {
+	return `import { evlogMiddleware } from "evlog/next";
+
+export const proxy = evlogMiddleware();
+
+export const config = {
+  matcher: ["/api/:path*"],
+};
+`;
+}
+function getNextEvlogAuthFile(config) {
+	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
+import { useLogger } from "@/lib/evlog";
+
+export async function identifyEvlogUser(request: Request) {
+  const identifyUser = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+    exclude: ["/api/auth/**"],
+    maskEmail: true,
+  });
+  await identifyUser(useLogger(), request.headers, new URL(request.url).pathname);
+}
+`;
+	return `${getAuthImportLine(config)}
+import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
+import { useLogger } from "@/lib/evlog";
+
+const identifyUser = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+  exclude: ["/api/auth/**"],
+  maskEmail: true,
+});
+
+export async function identifyEvlogUser(request: Request) {
+  await identifyUser(useLogger(), request.headers, new URL(request.url).pathname);
+}
+`;
+}
+function getNitroEvlogAuthPluginFile(config) {
+	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+import { createAuthIdentifier, type BetterAuthInstance } from "evlog/better-auth";
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("request", async (event) => {
+    const identify = createAuthIdentifier(${getAuthExpression(config)} as BetterAuthInstance, {
+      exclude: ["/api/auth/**"],
+      maskEmail: true,
+    });
+    await identify(event);
+  });
+});
+`;
+	return `${getAuthImportLine(config)}
+import { createAuthIdentifier, type BetterAuthInstance } from "evlog/better-auth";
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook(
+    "request",
+    createAuthIdentifier(${getAuthExpression(config)} as BetterAuthInstance, {
+      exclude: ["/api/auth/**"],
+      maskEmail: true,
+    }),
+  );
+});
+`;
+}
+function getNuxtEvlogAuthMiddlewareFile(config) {
+	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
+
+export default defineEventHandler(async (event) => {
+  if (!event.context.log) return;
+  const identify = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+    exclude: ["/api/auth/**"],
+    maskEmail: true,
+  });
+  await identify(event.context.log, event.headers, event.path);
+});
+`;
+	return `${getAuthImportLine(config)}
+import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
+
+const identify = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+  exclude: ["/api/auth/**"],
+  maskEmail: true,
+});
+
+export default defineEventHandler(async (event) => {
+  if (!event.context.log) return;
+  await identify(event.context.log, event.headers, event.path);
+});
+`;
+}
+function getTanstackNitroConfigFile(serviceName) {
+	return `import { defineConfig } from "nitro";
+import evlog from "evlog/nitro/v3";
+
+export default defineConfig({
+  experimental: {
+    asyncContext: true,
+  },
+  modules: [
+    evlog({
+      env: { service: "${serviceName}" },
+    }),
+  ],
+});
+`;
+}
+function getAstroMiddlewareFile(serviceName) {
+	return `import { defineMiddleware } from "astro:middleware";
+import { createRequestLogger, initLogger } from "evlog";
+
+initLogger({
+  env: { service: "${serviceName}" },
+});
+
+export const onRequest = defineMiddleware(async ({ request, locals }, next) => {
+  const url = new URL(request.url);
+  const log = createRequestLogger({
+    method: request.method,
+    path: url.pathname,
+  });
+
+  locals.log = log;
+
+  try {
+    const response = await next();
+    log.emit();
+    return response;
+  } catch (error) {
+    log.error(error instanceof Error ? error : new Error(String(error)));
+    log.emit();
+    throw error;
+  }
+});
+`;
+}
+function getAstroEnvFile() {
+	return `/// <reference types="astro/client" />
+
+import type { RequestLogger } from "evlog";
+
+declare namespace App {
+  interface Locals {
+    log: RequestLogger;
+  }
+}
+`;
+}
+async function setupNextEvlog(config, serviceName) {
+	const webDir = path.join(config.projectDir, "apps/web");
+	const evlogPath = path.join(webDir, "src/lib/evlog.ts");
+	if (!await fs.pathExists(evlogPath)) await writeFileIfChanged(evlogPath, getNextEvlogFile(serviceName));
+	const identifyWebAuth = shouldIdentifyWebAuth(config);
+	if (identifyWebAuth) {
+		const evlogAuthPath = path.join(webDir, "src/lib/evlog-auth.ts");
+		if (!await fs.pathExists(evlogAuthPath)) await writeFileIfChanged(evlogAuthPath, getNextEvlogAuthFile(config));
+	}
+	const instrumentationPath = path.join(webDir, "instrumentation.ts");
+	if (!await fs.pathExists(instrumentationPath)) await writeFileIfChanged(instrumentationPath, getNextInstrumentationFile());
+	const proxyPath = path.join(webDir, "src/proxy.ts");
+	const rootProxyPath = path.join(webDir, "proxy.ts");
+	if (!await fs.pathExists(proxyPath) && !await fs.pathExists(rootProxyPath)) await writeFileIfChanged(proxyPath, getNextProxyFile());
+	const updateNextApiRoute = (content) => {
+		let nextContent = addNextRouteWrappers(content);
+		if (identifyWebAuth) nextContent = addNextBetterAuthToRoute(nextContent);
+		return nextContent;
+	};
+	await updateFileIfExists(path.join(webDir, "src/app/api/trpc/[trpc]/route.ts"), updateNextApiRoute);
+	await updateFileIfExists(path.join(webDir, "src/app/api/rpc/[[...rest]]/route.ts"), updateNextApiRoute);
+	if (config.examples.includes("ai")) await updateFileIfExists(path.join(webDir, "src/app/api/ai/route.ts"), (content) => {
+		let nextContent = addNextAiEvlogSetup(content);
+		if (identifyWebAuth) nextContent = addNextBetterAuthToRoute(nextContent);
+		return nextContent;
+	});
+}
+async function setupNuxtEvlog(config, serviceName) {
+	const webDir = path.join(config.projectDir, "apps/web");
+	await updateFileIfExists(path.join(webDir, "nuxt.config.ts"), (content) => addNuxtEvlogSetup(content, serviceName));
+	if (shouldIdentifyWebAuth(config)) {
+		const oldAuthPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
+		if (await fs.pathExists(oldAuthPluginPath)) {
+			if ((await fs.readFile(oldAuthPluginPath, "utf-8")).includes("evlog/better-auth")) await fs.remove(oldAuthPluginPath);
+		}
+		const authMiddlewarePath = path.join(webDir, "server/middleware/evlog-auth.ts");
+		if (!await fs.pathExists(authMiddlewarePath)) await writeFileIfChanged(authMiddlewarePath, getNuxtEvlogAuthMiddlewareFile(config));
+	}
+	if (config.examples.includes("ai")) await updateFileIfExists(path.join(webDir, "server/api/ai.post.ts"), addNuxtAiEvlogSetup);
+}
+async function setupSvelteEvlog(config, serviceName) {
+	const webDir = path.join(config.projectDir, "apps/web");
+	await updateFileIfExists(path.join(webDir, "vite.config.ts"), (content) => addSvelteViteEvlogSetup(content, serviceName));
+	const hooksPath = path.join(webDir, "src/hooks.server.ts");
+	if (await fs.pathExists(hooksPath)) await updateFileIfExists(hooksPath, addSvelteHooksEvlogSetup);
+	else await writeFileIfChanged(hooksPath, `import { createEvlogHooks } from "evlog/sveltekit";
+
+export const { handle, handleError } = createEvlogHooks();
+`);
+	await updateFileIfExists(path.join(webDir, "src/app.d.ts"), addSvelteLocalsType);
+	if (shouldIdentifyWebAuth(config)) await updateFileIfExists(path.join(webDir, "src/hooks.server.ts"), (content) => addSvelteBetterAuthEvlogSetup(content, config));
+	if (config.examples.includes("ai")) await updateFileIfExists(path.join(webDir, "src/routes/api/ai/+server.ts"), addSvelteAiEvlogSetup);
+}
+async function setupTanstackStartEvlog(config, serviceName) {
+	const webDir = path.join(config.projectDir, "apps/web");
+	const nitroConfigPath = path.join(webDir, "nitro.config.ts");
+	if (!await fs.pathExists(nitroConfigPath)) await writeFileIfChanged(nitroConfigPath, getTanstackNitroConfigFile(serviceName));
+	await updateFileIfExists(path.join(webDir, "src/routes/__root.tsx"), addTanstackStartRootEvlogSetup);
+	if (shouldIdentifyWebAuth(config)) {
+		const authPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
+		if (!await fs.pathExists(authPluginPath)) await writeFileIfChanged(authPluginPath, getNitroEvlogAuthPluginFile(config));
+	}
+	if (config.examples.includes("ai")) await updateFileIfExists(path.join(webDir, "src/routes/api/ai/$.ts"), addTanstackStartAiEvlogSetup);
+}
+async function setupAstroEvlog(config, serviceName) {
+	const webDir = path.join(config.projectDir, "apps/web");
+	const middlewarePath = path.join(webDir, "src/middleware.ts");
+	if (!await fs.pathExists(middlewarePath)) await writeFileIfChanged(middlewarePath, getAstroMiddlewareFile(serviceName));
+	else await updateFileIfExists(middlewarePath, (content) => addAstroMiddlewareEvlogSetup(content, serviceName));
+	const envPath = path.join(webDir, "src/env.d.ts");
+	if (!await fs.pathExists(envPath)) await writeFileIfChanged(envPath, getAstroEnvFile());
+	else await updateFileIfExists(envPath, addAstroLocalsType);
+	if (shouldIdentifyWebAuth(config)) await updateFileIfExists(middlewarePath, (content) => addAstroBetterAuthEvlogSetup(content, config));
+}
+async function setupEvlogWeb(config) {
+	const frontend = getEvlogWebFrontend(config.frontend);
+	if (!frontend) return;
+	const serviceName = `${config.projectName}-web`;
+	if (frontend === "next") await setupNextEvlog(config, serviceName);
+	else if (frontend === "nuxt") await setupNuxtEvlog(config, serviceName);
+	else if (frontend === "svelte") await setupSvelteEvlog(config, serviceName);
+	else if (frontend === "tanstack-start") await setupTanstackStartEvlog(config, serviceName);
+	else if (frontend === "astro") await setupAstroEvlog(config, serviceName);
+}
+async function setupEvlog(config) {
+	return Result.tryPromise({
+		try: async () => {
+			if (isEvlogBackend(config.backend)) {
+				const serverIndexPath = path.join(config.projectDir, "apps/server/src/index.ts");
+				if (await fs.pathExists(serverIndexPath)) {
+					const content = await fs.readFile(serverIndexPath, "utf-8");
+					let nextContent = addEvlogServerSetup(content, config.backend, `${config.projectName}-server`);
+					if (config.auth === "better-auth") nextContent = addEvlogBetterAuthServerSetup(nextContent, config.backend, getAuthExpression(config));
+					if (config.examples.includes("ai")) nextContent = addBackendAiEvlogSetup(nextContent, config.backend);
+					if (nextContent !== content) await fs.writeFile(serverIndexPath, nextContent);
+				}
+			}
+			await setupEvlogWeb(config);
+		},
+		catch: (error) => new AddonSetupError({
+			addon: "evlog",
+			message: `Failed to set up evlog: ${error instanceof Error ? error.message : String(error)}`,
+			cause: error
+		})
+	});
+}
+//#endregion
+//#region src/prompts/navigable-group.ts
+/**
+* Navigable group - a group of prompts that allows going back
+*/
+/**
+* Define a group of prompts that supports going back to previous prompts.
+* Returns a result object with all the values, or handles cancel/go-back navigation.
+*/
+async function navigableGroup(prompts, opts) {
+	const results = {};
+	const promptNames = Object.keys(prompts);
+	let currentIndex = 0;
+	let goingBack = false;
+	while (currentIndex < promptNames.length) {
+		const name = promptNames[currentIndex];
+		const prompt = prompts[name];
+		setIsFirstPrompt$1(currentIndex === 0);
+		setLastPromptShownUI(false);
+		const result = await prompt({ results })?.catch((e) => {
+			throw e;
+		});
+		if (isGoBack(result)) {
+			goingBack = true;
+			if (currentIndex > 0) {
+				const prevName = promptNames[currentIndex - 1];
+				delete results[prevName];
+				currentIndex--;
+				continue;
+			}
+			goingBack = false;
+			continue;
+		}
+		if (isCancel$1(result)) {
+			if (typeof opts?.onCancel === "function") {
+				results[name] = "canceled";
+				opts.onCancel({ results });
+			}
+			setIsFirstPrompt$1(false);
+			return results;
+		}
+		if (goingBack && !didLastPromptShowUI()) {
+			if (currentIndex > 0) {
+				const prevName = promptNames[currentIndex - 1];
+				delete results[prevName];
+				currentIndex--;
+				continue;
+			}
+		}
+		goingBack = false;
+		results[name] = result;
+		currentIndex++;
+	}
+	setIsFirstPrompt$1(false);
+	return results;
+}
+//#endregion
 //#region src/utils/external-commands.ts
 function shouldSkipExternalCommands() {
 	return process.env.BTS_SKIP_EXTERNAL_COMMANDS === "1" || process.env.BTS_TEST_MODE === "1";
@@ -1484,64 +2106,143 @@ function getPackageRunnerPrefix(packageManager) {
 const TEMPLATES$2 = {
 	"next-mdx": {
 		label: "Next.js: Fumadocs MDX",
-		hint: "Recommended template with MDX support",
+		hint: "recommended",
 		value: "+next+fuma-docs-mdx"
 	},
 	"next-mdx-static": {
-		label: "Next.js: Fumadocs MDX (Static)",
-		hint: "Static export template with MDX support",
+		label: "Next.js Static: Fumadocs MDX",
 		value: "+next+fuma-docs-mdx+static"
 	},
 	waku: {
-		label: "Waku: Content Collections",
-		hint: "Template using Waku with content collections",
+		label: "Waku: Fumadocs MDX",
 		value: "waku"
 	},
 	"react-router": {
-		label: "React Router: MDX Remote",
-		hint: "Template for React Router with MDX remote",
+		label: "React Router: Fumadocs MDX (not RSC)",
 		value: "react-router"
 	},
 	"react-router-spa": {
-		label: "React Router: SPA",
-		hint: "Template for React Router SPA",
+		label: "React Router SPA: Fumadocs MDX (not RSC)",
+		hint: "SPA mode allows you to host the site statically, compatible with a CDN.",
 		value: "react-router-spa"
 	},
 	"tanstack-start": {
-		label: "Tanstack Start: MDX Remote",
-		hint: "Template for Tanstack Start with MDX remote",
+		label: "Tanstack Start: Fumadocs MDX (not RSC)",
 		value: "tanstack-start"
 	},
 	"tanstack-start-spa": {
-		label: "Tanstack Start: SPA",
-		hint: "Template for Tanstack Start SPA",
+		label: "Tanstack Start SPA: Fumadocs MDX (not RSC)",
+		hint: "SPA mode allows you to host the site statically, compatible with a CDN.",
 		value: "tanstack-start-spa"
 	}
 };
 const DEFAULT_TEMPLATE$2 = "next-mdx";
 const DEFAULT_DEV_PORT$1 = 4e3;
+function aiChatDisabledForTemplate(template) {
+	return template === "next-mdx-static" || template.endsWith("-spa");
+}
 async function setupFumadocs(config) {
 	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	cliLog.info("Setting up Fumadocs...");
 	const configuredOptions = config.addonOptions?.fumadocs;
 	let template = configuredOptions?.template;
-	if (!template) if (isSilent()) template = DEFAULT_TEMPLATE$2;
+	let search = configuredOptions?.search;
+	let ogImage = configuredOptions?.ogImage;
+	let aiChat = configuredOptions?.aiChat;
+	if (isSilent()) template = template ?? DEFAULT_TEMPLATE$2;
 	else {
-		const selectedTemplate = await select({
-			message: "Choose a template",
-			options: Object.entries(TEMPLATES$2).map(([key, templateOption]) => ({
-				value: key,
-				label: templateOption.label,
-				hint: templateOption.hint
-			})),
-			initialValue: DEFAULT_TEMPLATE$2
+		const promptResult = await Result.tryPromise({
+			try: () => navigableGroup({
+				template: async () => {
+					if (template !== void 0) return template;
+					return navigableSelect({
+						message: "Choose a template",
+						options: Object.entries(TEMPLATES$2).map(([key, t]) => ({
+							value: key,
+							label: t.label,
+							hint: "hint" in t ? t.hint : void 0
+						})),
+						initialValue: DEFAULT_TEMPLATE$2
+					});
+				},
+				search: async () => {
+					if (search !== void 0) return search;
+					return navigableSelect({
+						message: "Choose a search solution?",
+						options: [{
+							value: "orama",
+							label: "Default",
+							hint: "local search powered by Orama, recommended"
+						}, {
+							value: "orama-cloud",
+							label: "Orama Cloud",
+							hint: "3rd party search solution, signup needed"
+						}],
+						initialValue: "orama"
+					});
+				},
+				ogImage: async ({ results }) => {
+					if (ogImage !== void 0) return ogImage;
+					if (!(results.template ?? template ?? DEFAULT_TEMPLATE$2).startsWith("next-")) return "skip";
+					return navigableSelect({
+						message: "Configure Open Graph Image generation?",
+						options: [{
+							value: "next-og",
+							label: "next/og",
+							hint: "Next.js built-in solution"
+						}, {
+							value: "takumi",
+							label: "Takumi",
+							hint: "Output WebP format, framework-agnostic"
+						}],
+						initialValue: "next-og"
+					});
+				},
+				aiChat: async ({ results }) => {
+					if (aiChat !== void 0) return aiChat;
+					if (aiChatDisabledForTemplate(results.template ?? template ?? DEFAULT_TEMPLATE$2)) return "none";
+					return navigableSelect({
+						message: "Configure AI Chat?",
+						options: [
+							{
+								value: "none",
+								label: "No"
+							},
+							{
+								value: "openrouter",
+								label: "AI SDK",
+								hint: "default to OpenRouter"
+							},
+							{
+								value: "inkeep",
+								label: "Inkeep AI",
+								hint: "API key required"
+							}
+						],
+						initialValue: "none"
+					});
+				}
+			}),
+			catch: (e) => new AddonSetupError({
+				addon: "fumadocs",
+				message: `Failed to run Fumadocs prompts: ${e instanceof Error ? e.message : String(e)}`,
+				cause: e
+			})
 		});
-		if (isCancel(selectedTemplate)) return userCancelled("Operation cancelled");
-		template = selectedTemplate;
-	}
-	const templateArg = TEMPLATES$2[template].value;
+		if (promptResult.isErr()) return Result.err(promptResult.error);
+		const results = promptResult.value;
+		if (results.template === void 0 || results.search === void 0 || results.ogImage === void 0 || results.aiChat === void 0) return userCancelled("Operation cancelled");
+		template = results.template;
+		search = results.search;
+		ogImage = results.ogImage === "skip" ? void 0 : results.ogImage;
+		aiChat = results.aiChat === "none" ? void 0 : results.aiChat;
+	}
+	if (!template) return userCancelled("Operation cancelled");
 	const isNextTemplate = template.startsWith("next-");
+	if (!isNextTemplate) ogImage = void 0;
+	if (aiChatDisabledForTemplate(template)) aiChat = void 0;
+	const templateArg = TEMPLATES$2[template].value;
 	const devPort = configuredOptions?.devPort ?? DEFAULT_DEV_PORT$1;
 	const options = [
 		`--template ${templateArg}`,
@@ -1549,7 +2250,10 @@ async function setupFumadocs(config) {
 		"--no-git"
 	];
 	if (isNextTemplate) options.push("--src");
-	if (config.addons.includes("biome")) options.push("--linter biome");
+	if (config.addons.includes("biome") || config.addons.includes("ultracite")) options.push("--linter biome");
+	if (search) options.push(`--search ${search}`);
+	if (ogImage) options.push(`--og-image ${ogImage}`);
+	if (aiChat) options.push(`--ai-chat ${aiChat}`);
 	const args = getPackageExecutionArgs(packageManager, `create-fumadocs-app@latest fumadocs ${options.join(" ")}`);
 	const appsDir = path.join(projectDir, "apps");
 	await fs.ensureDir(appsDir);
@@ -1812,67 +2516,84 @@ async function setupMcp(config) {
 	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	cliLog.info("Setting up MCP servers...");
-	let scope = config.addonOptions?.mcp?.scope;
-	if (!scope) if (isSilent()) scope = DEFAULT_SCOPE$1;
-	else {
-		const selectedScope = await select({
-			message: "Where should MCP servers be installed?",
-			options: [{
-				value: "project",
-				label: "Project",
-				hint: "Writes to project config files (recommended for teams)"
-			}, {
-				value: "global",
-				label: "Global",
-				hint: "Writes to user-level config files (personal machine)"
-			}],
-			initialValue: DEFAULT_SCOPE$1
-		});
-		if (isCancel(selectedScope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		scope = selectedScope;
-	}
-	const recommendedServers = getRecommendedMcpServers(config, scope);
-	if (recommendedServers.length === 0) return Result.ok(void 0);
-	const allServersByKey = new Map(getAllMcpServers(config).map((server) => [server.key, server]));
-	const serverOptions = recommendedServers.map((s) => ({
-		value: s.key,
-		label: s.label,
-		hint: s.target
-	}));
+	const configuredScope = config.addonOptions?.mcp?.scope;
 	const configuredServerKeys = config.addonOptions?.mcp?.servers;
-	const availableServerKeys = new Set(allServersByKey.keys());
-	let selectedServerKeys = configuredServerKeys?.filter((serverKey) => availableServerKeys.has(serverKey)) ?? [];
-	if (selectedServerKeys.length === 0 && configuredServerKeys === void 0) if (isSilent()) selectedServerKeys = serverOptions.map((o) => o.value);
-	else {
-		const promptedServerKeys = await multiselect({
-			message: "Select MCP servers to install",
-			options: serverOptions,
-			required: false,
-			initialValues: serverOptions.map((o) => o.value)
-		});
-		if (isCancel(promptedServerKeys)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		selectedServerKeys = [...promptedServerKeys];
-	}
-	if (selectedServerKeys.length === 0) return Result.ok(void 0);
-	const agentOptions = filterAgentsForScope(scope).map((a) => ({
-		value: a.value,
-		label: a.label
-	}));
-	const defaultAgents = uniqueValues$1(DEFAULT_AGENTS$2.filter((agent) => agentOptions.some((option) => option.value === agent)));
 	const configuredAgents = config.addonOptions?.mcp?.agents;
-	let selectedAgents = configuredAgents?.filter((agent) => agentOptions.some((option) => option.value === agent)) ?? [];
-	if (selectedAgents.length === 0 && configuredAgents === void 0) if (isSilent()) selectedAgents = defaultAgents;
-	else {
-		const promptedAgents = await multiselect({
-			message: "Select agents to install MCP servers to",
-			options: agentOptions,
-			required: false,
-			initialValues: defaultAgents
+	const allServersByKey = new Map(getAllMcpServers(config).map((server) => [server.key, server]));
+	const availableServerKeys = new Set(allServersByKey.keys());
+	let scope;
+	let selectedServerKeys;
+	let selectedAgents;
+	if (isSilent()) {
+		scope = configuredScope ?? DEFAULT_SCOPE$1;
+		const recommendedServers = getRecommendedMcpServers(config, scope);
+		if (recommendedServers.length === 0) return Result.ok(void 0);
+		const serverOptions = recommendedServers.map((s) => s.key);
+		selectedServerKeys = configuredServerKeys?.filter((k) => availableServerKeys.has(k)) ?? serverOptions;
+		if (selectedServerKeys.length === 0) return Result.ok(void 0);
+		const agentOptions = filterAgentsForScope(scope);
+		const defaultAgents = uniqueValues$1(DEFAULT_AGENTS$2.filter((a) => agentOptions.some((o) => o.value === a)));
+		selectedAgents = configuredAgents?.filter((a) => agentOptions.some((o) => o.value === a)) ?? defaultAgents;
+		if (selectedAgents.length === 0) return Result.ok(void 0);
+	} else {
+		const results = await navigableGroup({
+			scope: async () => {
+				if (configuredScope !== void 0) return configuredScope;
+				return navigableSelect({
+					message: "Where should MCP servers be installed?",
+					options: [{
+						value: "project",
+						label: "Project",
+						hint: "Writes to project config files (recommended for teams)"
+					}, {
+						value: "global",
+						label: "Global",
+						hint: "Writes to user-level config files (personal machine)"
+					}],
+					initialValue: DEFAULT_SCOPE$1
+				});
+			},
+			servers: async ({ results: r }) => {
+				const recommended = getRecommendedMcpServers(config, r.scope ?? configuredScope ?? DEFAULT_SCOPE$1);
+				if (recommended.length === 0) return [];
+				const options = recommended.map((s) => ({
+					value: s.key,
+					label: s.label,
+					hint: s.target
+				}));
+				if (configuredServerKeys !== void 0) return configuredServerKeys.filter((k) => availableServerKeys.has(k));
+				return navigableMultiselect({
+					message: "Select MCP servers to install",
+					options,
+					required: false,
+					initialValues: options.map((o) => o.value)
+				});
+			},
+			agents: async ({ results: r }) => {
+				const currentScope = r.scope ?? configuredScope ?? DEFAULT_SCOPE$1;
+				const currentServers = r.servers;
+				if (currentServers !== void 0 && currentServers.length === 0) return [];
+				const agentOpts = filterAgentsForScope(currentScope);
+				if (agentOpts.length === 0) return [];
+				const defaults = uniqueValues$1(DEFAULT_AGENTS$2.filter((a) => agentOpts.some((o) => o.value === a)));
+				if (configuredAgents !== void 0) return configuredAgents.filter((a) => agentOpts.some((o) => o.value === a));
+				return navigableMultiselect({
+					message: "Select agents to install MCP servers to",
+					options: agentOpts.map((a) => ({
+						value: a.value,
+						label: a.label
+					})),
+					required: false,
+					initialValues: defaults
+				});
+			}
 		});
-		if (isCancel(promptedAgents)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		selectedAgents = [...promptedAgents];
+		if (results.scope === void 0 || results.servers === void 0 || results.agents === void 0) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		scope = results.scope;
+		selectedServerKeys = results.servers;
+		selectedAgents = results.agents;
+		if (selectedServerKeys.length === 0 || selectedAgents.length === 0) return Result.ok(void 0);
 	}
-	if (selectedAgents.length === 0) return Result.ok(void 0);
 	const selectedServers = [];
 	for (const key of selectedServerKeys) {
 		const server = allServersByKey.get(key);
@@ -1994,7 +2715,8 @@ const SKILL_SOURCES = {
 	"elysiajs/skills": { label: "ElysiaJS" },
 	"waynesutton/convexskills": { label: "Convex" },
 	"msmps/opentui-skill": { label: "OpenTUI Platform" },
-	"haydenbleasel/ultracite": { label: "Ultracite" }
+	"haydenbleasel/ultracite": { label: "Ultracite" },
+	"https://www.evlog.dev": { label: "evlog" }
 };
 const AVAILABLE_AGENTS = [
 	{
@@ -2134,6 +2856,7 @@ function getRecommendedSourceKeys(config) {
 	if (backend === "convex") sources.push("waynesutton/convexskills");
 	if (addons.includes("opentui")) sources.push("msmps/opentui-skill");
 	if (addons.includes("ultracite")) sources.push("haydenbleasel/ultracite");
+	if (addons.includes("evlog")) sources.push("https://www.evlog.dev");
 	return sources;
 }
 const CURATED_SKILLS_BY_SOURCE = {
@@ -2180,7 +2903,6 @@ const CURATED_SKILLS_BY_SOURCE = {
 			"building-native-ui",
 			"native-data-fetching",
 			"expo-deployment",
-			"upgrading-expo",
 			"expo-cicd-workflows"
 		];
 		if (config.frontend.includes("native-uniwind")) skills.push("expo-tailwind-setup");
@@ -2205,7 +2927,8 @@ const CURATED_SKILLS_BY_SOURCE = {
 		"convex-security-check"
 	],
 	"msmps/opentui-skill": () => ["opentui"],
-	"haydenbleasel/ultracite": () => ["ultracite"]
+	"haydenbleasel/ultracite": () => ["ultracite"],
+	"https://www.evlog.dev": () => ["review-logging-patterns", "analyze-logs"]
 };
 function getCuratedSkillNamesForSourceKey(sourceKey, config) {
 	return CURATED_SKILLS_BY_SOURCE[sourceKey](config);
@@ -2236,55 +2959,64 @@ async function setupSkills(config) {
 		}));
 	});
 	if (skillOptions.length === 0) return Result.ok(void 0);
-	let scope = skillsOptions?.scope;
-	if (!scope) if (isSilent()) scope = DEFAULT_SCOPE;
-	else {
-		const selectedScope = await select({
-			message: "Where should skills be installed?",
-			options: [{
-				value: "project",
-				label: "Project",
-				hint: "Writes to project config files (recommended for teams)"
-			}, {
-				value: "global",
-				label: "Global",
-				hint: "Writes to user-level config files (personal machine)"
-			}],
-			initialValue: DEFAULT_SCOPE
-		});
-		if (isCancel(selectedScope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		scope = selectedScope;
-	}
-	const allSkillValues = skillOptions.map((opt) => opt.value);
+	const configuredScope = skillsOptions?.scope;
 	const configuredSelections = skillsOptions?.selections;
-	let selectedSkills;
-	if (configuredSelections !== void 0) selectedSkills = configuredSelections.flatMap((selection) => selection.skills.map((skill) => `${selection.source}::${skill}`));
-	else if (isSilent()) selectedSkills = allSkillValues;
-	else {
-		const promptedSkills = await multiselect({
-			message: "Select skills to install",
-			options: skillOptions,
-			required: false,
-			initialValues: allSkillValues
-		});
-		if (isCancel(promptedSkills)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		selectedSkills = promptedSkills;
-	}
-	if (selectedSkills.length === 0) return Result.ok(void 0);
 	const configuredAgents = skillsOptions?.agents;
-	let selectedAgents = configuredAgents ? [...configuredAgents] : [];
-	if (selectedAgents.length === 0 && configuredAgents === void 0) if (isSilent()) selectedAgents = [...DEFAULT_AGENTS$1];
-	else {
-		const promptedAgents = await multiselect({
-			message: "Select agents to install skills to",
-			options: AVAILABLE_AGENTS,
-			required: false,
-			initialValues: [...DEFAULT_AGENTS$1]
+	const allSkillValues = skillOptions.map((opt) => opt.value);
+	let scope;
+	let selectedSkills;
+	let selectedAgents;
+	if (isSilent()) {
+		scope = configuredScope ?? DEFAULT_SCOPE;
+		selectedSkills = configuredSelections !== void 0 ? configuredSelections.flatMap((selection) => selection.skills.map((skill) => `${selection.source}::${skill}`)) : allSkillValues;
+		if (selectedSkills.length === 0) return Result.ok(void 0);
+		selectedAgents = configuredAgents ? [...configuredAgents] : [...DEFAULT_AGENTS$1];
+		if (selectedAgents.length === 0) return Result.ok(void 0);
+	} else {
+		const results = await navigableGroup({
+			scope: async () => {
+				if (configuredScope !== void 0) return configuredScope;
+				return navigableSelect({
+					message: "Where should skills be installed?",
+					options: [{
+						value: "project",
+						label: "Project",
+						hint: "Writes to project config files (recommended for teams)"
+					}, {
+						value: "global",
+						label: "Global",
+						hint: "Writes to user-level config files (personal machine)"
+					}],
+					initialValue: DEFAULT_SCOPE
+				});
+			},
+			skills: async () => {
+				if (configuredSelections !== void 0) return configuredSelections.flatMap((selection) => selection.skills.map((skill) => `${selection.source}::${skill}`));
+				return navigableMultiselect({
+					message: "Select skills to install",
+					options: skillOptions,
+					required: false,
+					initialValues: allSkillValues
+				});
+			},
+			agents: async ({ results: r }) => {
+				const pickedSkills = r.skills;
+				if (pickedSkills !== void 0 && pickedSkills.length === 0) return [];
+				if (configuredAgents !== void 0) return [...configuredAgents];
+				return navigableMultiselect({
+					message: "Select agents to install skills to",
+					options: AVAILABLE_AGENTS,
+					required: false,
+					initialValues: [...DEFAULT_AGENTS$1]
+				});
+			}
 		});
-		if (isCancel(promptedAgents)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
-		selectedAgents = [...promptedAgents];
+		if (results.scope === void 0 || results.skills === void 0 || results.agents === void 0) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+		scope = results.scope;
+		selectedSkills = results.skills;
+		selectedAgents = results.agents;
+		if (selectedSkills.length === 0 || selectedAgents.length === 0) return Result.ok(void 0);
 	}
-	if (selectedAgents.length === 0) return Result.ok(void 0);
 	const skillsBySource = {};
 	for (const skillKey of selectedSkills) {
 		const [source, skillName] = skillKey.split("::");
@@ -2474,7 +3206,8 @@ async function setupTui(config) {
 	cliLog.info("Setting up OpenTUI...");
 	let template = resolveTuiTemplate(config);
 	if (!template) {
-		const selectedTemplate = await select({
+		setIsFirstPrompt(true);
+		const selectedTemplate = await navigableSelect({
 			message: "Choose a template",
 			options: Object.entries(TEMPLATES$1).map(([key, templateOption]) => ({
 				value: key,
@@ -2483,7 +3216,7 @@ async function setupTui(config) {
 			})),
 			initialValue: DEFAULT_TEMPLATE$1
 		});
-		if (isCancel(selectedTemplate)) return userCancelled("Operation cancelled");
+		if (isCancel$1(selectedTemplate)) return userCancelled("Operation cancelled");
 		template = selectedTemplate;
 	}
 	const args = getPackageExecutionArgs(packageManager, `create-tui@latest --template ${template} --no-git --no-install tui`);
@@ -2563,42 +3296,40 @@ async function postProcessTuiWorkspace(tuiDir) {
 //#endregion
 //#region src/helpers/addons/ultracite-setup.ts
 const LINTERS = {
-	biome: {
-		label: "Biome",
-		hint: "Fast formatter and linter"
-	},
-	eslint: {
-		label: "ESLint",
-		hint: "Traditional JavaScript linter"
-	},
-	oxlint: {
-		label: "Oxlint",
-		hint: "Oxidation compiler linter"
-	}
-};
-const EDITORS = {
-	vscode: { label: "VS Code" },
-	cursor: { label: "Cursor" },
-	windsurf: { label: "Windsurf" },
-	antigravity: { label: "Antigravity" },
-	kiro: { label: "Kiro" },
-	trae: { label: "Trae" },
-	void: { label: "Void" },
-	zed: { label: "Zed" }
+	biome: { label: "Biome (Recommended)" },
+	eslint: { label: "ESLint + Prettier + Stylelint" },
+	oxlint: { label: "Oxlint + Oxfmt" }
 };
 const AGENTS = {
-	claude: { label: "Claude" },
+	universal: { label: "Universal (AGENTS.md — covers all agents)" },
+	claude: { label: "Claude Code" },
 	codex: { label: "Codex" },
 	jules: { label: "Jules" },
+	replit: { label: "Replit Agent" },
+	devin: { label: "Devin" },
+	lovable: { label: "Lovable" },
+	zencoder: { label: "Zencoder" },
+	ona: { label: "Ona" },
+	openclaw: { label: "OpenClaw" },
+	continue: { label: "Continue" },
+	"snowflake-cortex": { label: "Snowflake Cortex" },
+	deepagents: { label: "Deepagents" },
+	qoder: { label: "Qoder" },
+	"kimi-cli": { label: "Kimi CLI" },
+	mcpjam: { label: "MCPJam" },
+	mux: { label: "Mux" },
+	pi: { label: "Pi" },
+	adal: { label: "AdaL" },
 	copilot: { label: "GitHub Copilot" },
 	cline: { label: "Cline" },
-	amp: { label: "Amp" },
+	amp: { label: "AMP" },
 	aider: { label: "Aider" },
 	"firebase-studio": { label: "Firebase Studio" },
-	"open-hands": { label: "Open Hands" },
+	"open-hands": { label: "OpenHands" },
 	gemini: { label: "Gemini" },
 	junie: { label: "Junie" },
-	augmentcode: { label: "AugmentCode" },
+	augmentcode: { label: "Augment Code" },
+	bob: { label: "IBM Bob" },
 	"kilo-code": { label: "Kilo Code" },
 	goose: { label: "Goose" },
 	"roo-code": { label: "Roo Code" },
@@ -2606,21 +3337,23 @@ const AGENTS = {
 	droid: { label: "Droid" },
 	opencode: { label: "OpenCode" },
 	crush: { label: "Crush" },
-	qwen: { label: "Qwen" },
+	qwen: { label: "Qwen Code" },
 	"amazon-q-cli": { label: "Amazon Q CLI" },
 	firebender: { label: "Firebender" },
 	"cursor-cli": { label: "Cursor CLI" },
 	"mistral-vibe": { label: "Mistral Vibe" },
-	vercel: { label: "Vercel" }
+	vercel: { label: "Vercel Agent" }
 };
 const HOOKS = {
 	cursor: { label: "Cursor" },
 	windsurf: { label: "Windsurf" },
-	claude: { label: "Claude" }
+	codebuddy: { label: "CodeBuddy" },
+	claude: { label: "Claude Code" },
+	copilot: { label: "GitHub Copilot" }
 };
 const DEFAULT_LINTER = "biome";
-const DEFAULT_EDITORS = ["vscode", "cursor"];
-const DEFAULT_AGENTS = ["claude", "codex"];
+const DEFAULT_EDITORS = ["vscode"];
+const DEFAULT_AGENTS = ["universal"];
 const DEFAULT_HOOKS = [];
 function getFrameworksFromFrontend(frontend) {
 	const frameworkMap = {
@@ -2633,7 +3366,8 @@ function getFrameworksFromFrontend(frontend) {
 		"native-uniwind": "react",
 		"native-unistyles": "react",
 		svelte: "svelte",
-		solid: "solid"
+		solid: "solid",
+		astro: "astro"
 	};
 	const frameworks = /* @__PURE__ */ new Set();
 	for (const f of frontend) if (f !== "none" && frameworkMap[f]) frameworks.add(frameworkMap[f]);
@@ -2651,10 +3385,7 @@ function buildUltraciteInitArgs({ packageManager, linter, frameworks, editors, a
 	if (editors.length > 0) ultraciteArgs.push("--editors", ...editors);
 	if (agents.length > 0) ultraciteArgs.push("--agents", ...agents);
 	if (hooks.length > 0) ultraciteArgs.push("--hooks", ...hooks);
-	if (gitHooks.length > 0) {
-		const integrations = gitHooks.includes("husky") ? [...new Set([...gitHooks, "lint-staged"])] : gitHooks;
-		ultraciteArgs.push("--integrations", ...integrations);
-	}
+	if (gitHooks.length > 0) ultraciteArgs.push("--integrations", ...gitHooks);
 	return [
 		...getPackageRunnerPrefix(packageManager),
 		"ultracite@latest",
@@ -2678,67 +3409,60 @@ async function setupUltracite(config, gitHooks) {
 		agents = agents ?? [...DEFAULT_AGENTS];
 		hooks = hooks ?? [...DEFAULT_HOOKS];
 	} else {
-		const groupResult = await Result.tryPromise({
-			try: async () => {
-				return await group({
-					linter: () => select({
-						message: "Choose linter/formatter",
-						options: Object.entries(LINTERS).map(([key, linterOption]) => ({
-							value: key,
-							label: linterOption.label,
-							hint: linterOption.hint
-						})),
-						initialValue: linter ?? DEFAULT_LINTER
-					}),
-					editors: () => multiselect({
-						message: "Choose editors",
-						required: false,
-						options: Object.entries(EDITORS).map(([key, editor]) => ({
-							value: key,
-							label: editor.label
-						})),
-						initialValues: editors ?? [...DEFAULT_EDITORS]
-					}),
-					agents: () => multiselect({
-						message: "Choose agents",
-						required: false,
-						options: Object.entries(AGENTS).map(([key, agent]) => ({
-							value: key,
-							label: agent.label
-						})),
-						initialValues: agents ?? [...DEFAULT_AGENTS]
-					}),
-					hooks: () => multiselect({
-						message: "Choose hooks",
-						required: false,
-						options: Object.entries(HOOKS).map(([key, hook]) => ({
-							value: key,
-							label: hook.label
-						})),
-						initialValues: hooks ?? [...DEFAULT_HOOKS]
-					})
-				}, { onCancel: () => {
-					throw new UserCancelledError({ message: "Operation cancelled" });
-				} });
+		const results = await navigableGroup({
+			linter: async () => {
+				if (linter !== void 0) return linter;
+				return navigableSelect({
+					message: "Which linter do you want to use?",
+					options: Object.entries(LINTERS).map(([key, linterOption]) => ({
+						value: key,
+						label: linterOption.label
+					})),
+					initialValue: linter ?? DEFAULT_LINTER
+				});
 			},
-			catch: (e) => {
-				if (e instanceof UserCancelledError) return e;
-				return new AddonSetupError({
-					addon: "ultracite",
-					message: `Failed to get user preferences: ${e instanceof Error ? e.message : String(e)}`,
-					cause: e
+			editors: async () => {
+				if (editors !== void 0) return editors;
+				return navigableMultiselect({
+					message: "Which editors do you want to configure (recommended)?",
+					required: false,
+					options: [{
+						value: "vscode",
+						label: "VSCode / Cursor / Windsurf"
+					}, {
+						value: "zed",
+						label: "Zed"
+					}]
+				});
+			},
+			agents: async () => {
+				if (agents !== void 0) return agents;
+				return navigableMultiselect({
+					message: "Which agent files do you want to add (optional)?",
+					required: false,
+					options: Object.entries(AGENTS).map(([key, agent]) => ({
+						value: key,
+						label: agent.label
+					}))
+				});
+			},
+			hooks: async () => {
+				if (hooks !== void 0) return hooks;
+				return navigableMultiselect({
+					message: "Which agent hooks do you want to enable (optional)?",
+					required: false,
+					options: Object.entries(HOOKS).map(([key, hook]) => ({
+						value: key,
+						label: hook.label
+					}))
 				});
 			}
 		});
-		if (groupResult.isErr()) {
-			if (UserCancelledError.is(groupResult.error)) return userCancelled(groupResult.error.message);
-			cliLog.error(pc.red("Failed to set up Ultracite"));
-			return groupResult;
-		}
-		linter = groupResult.value.linter;
-		editors = groupResult.value.editors;
-		agents = groupResult.value.agents;
-		hooks = groupResult.value.hooks;
+		if (results.linter === void 0 || results.editors === void 0 || results.agents === void 0 || results.hooks === void 0) return userCancelled("Operation cancelled");
+		linter = results.linter;
+		editors = results.editors;
+		agents = results.agents;
+		hooks = results.hooks;
 	}
 	const frameworks = getFrameworksFromFrontend(frontend);
 	const args = buildUltraciteInitArgs({
@@ -2809,7 +3533,8 @@ async function setupWxt(config) {
 	let template = configuredOptions?.template;
 	if (!template) if (isSilent()) template = DEFAULT_TEMPLATE;
 	else {
-		const selectedTemplate = await select({
+		setIsFirstPrompt(true);
+		const selectedTemplate = await navigableSelect({
 			message: "Choose a template",
 			options: Object.entries(TEMPLATES).map(([key, templateOption]) => ({
 				value: key,
@@ -2818,7 +3543,7 @@ async function setupWxt(config) {
 			})),
 			initialValue: DEFAULT_TEMPLATE
 		});
-		if (isCancel(selectedTemplate)) return userCancelled("Operation cancelled");
+		if (isCancel$1(selectedTemplate)) return userCancelled("Operation cancelled");
 		template = selectedTemplate;
 	}
 	const devPort = configuredOptions?.devPort ?? DEFAULT_DEV_PORT;
@@ -2926,6 +3651,7 @@ async function setupAddons(config) {
 	if (addons.includes("wxt")) await runSetup(() => setupWxt(config));
 	if (addons.includes("skills")) await runSetup(() => setupSkills(config));
 	if (addons.includes("mcp")) await runSetup(() => setupMcp(config));
+	if (addons.includes("evlog")) await runSetup(() => setupEvlog(config));
 }
 async function setupBiome(projectDir) {
 	await addPackageDependency({
@@ -3089,7 +3815,7 @@ async function addHandlerInternal(input) {
 	} else if (isSilent()) return Result.err(new CLIError({ message: "Addons are required in silent mode. Provide them via add() or add-json." }));
 	else {
 		const promptResult = await Result.tryPromise({
-			try: () => getAddonsToAdd(existingConfig.frontend, existingConfig.addons, existingConfig.auth),
+			try: () => getAddonsToAdd(existingConfig),
 			catch: (e) => {
 				if (UserCancelledError.is(e)) return e;
 				return new CLIError({
@@ -3113,6 +3839,8 @@ async function addHandlerInternal(input) {
 		}
 		addonsToAdd = selectedAddons;
 	}
+	const addonsValidationResult = validateAddonsAgainstConfig(addonsToAdd, existingConfig);
+	if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
 	if (!isSilent()) log.info(pc.cyan(`Adding addons: ${addonsToAdd.join(", ")}`));
 	const updatedAddons = [...existingConfig.addons, ...addonsToAdd];
 	const mergedAddonOptions = mergeAddonOptions(existingConfig.addonOptions, input.addonOptions);
@@ -3140,7 +3868,12 @@ async function addHandlerInternal(input) {
 	};
 	if (!isSilent()) log.info(pc.dim("Installing addon files..."));
 	const vfs = new VirtualFileSystem();
-	for (const pkgPath of ["package.json", "apps/web/package.json"]) {
+	for (const pkgPath of [
+		"package.json",
+		"apps/web/package.json",
+		"apps/server/package.json",
+		"apps/native/package.json"
+	]) {
 		const fullPath = path.join(projectDir, pkgPath);
 		if (await fs.pathExists(fullPath)) {
 			const content = await fs.readFile(fullPath, "utf-8");
@@ -3295,6 +4028,7 @@ const FULLSTACK_FRONTENDS = [
 	"next",
 	"tanstack-start",
 	"nuxt",
+	"svelte",
 	"astro"
 ];
 async function getBackendFrameworkChoice(backendFramework, frontends) {
@@ -3648,62 +4382,6 @@ async function getinstallChoice(install) {
 	return response;
 }
 //#endregion
-//#region src/prompts/navigable-group.ts
-/**
-* Navigable group - a group of prompts that allows going back
-*/
-/**
-* Define a group of prompts that supports going back to previous prompts.
-* Returns a result object with all the values, or handles cancel/go-back navigation.
-*/
-async function navigableGroup(prompts, opts) {
-	const results = {};
-	const promptNames = Object.keys(prompts);
-	let currentIndex = 0;
-	let goingBack = false;
-	while (currentIndex < promptNames.length) {
-		const name = promptNames[currentIndex];
-		const prompt = prompts[name];
-		setIsFirstPrompt$1(currentIndex === 0);
-		setLastPromptShownUI(false);
-		const result = await prompt({ results })?.catch((e) => {
-			throw e;
-		});
-		if (isGoBack(result)) {
-			goingBack = true;
-			if (currentIndex > 0) {
-				const prevName = promptNames[currentIndex - 1];
-				delete results[prevName];
-				currentIndex--;
-				continue;
-			}
-			goingBack = false;
-			continue;
-		}
-		if (isCancel$1(result)) {
-			if (typeof opts?.onCancel === "function") {
-				results[name] = "canceled";
-				opts.onCancel({ results });
-			}
-			setIsFirstPrompt$1(false);
-			return results;
-		}
-		if (goingBack && !didLastPromptShowUI()) {
-			if (currentIndex > 0) {
-				const prevName = promptNames[currentIndex - 1];
-				delete results[prevName];
-				currentIndex--;
-				continue;
-			}
-		}
-		goingBack = false;
-		results[name] = result;
-		currentIndex++;
-	}
-	setIsFirstPrompt$1(false);
-	return results;
-}
-//#endregion
 //#region src/utils/config-validation.ts
 function validationErr(message) {
 	return Result.err(new ValidationError({ message }));
@@ -3887,7 +4565,7 @@ function validateFullConfig(config, providedFlags, options) {
 		if (config.runtime === "workers" && config.serverDeploy === "none") yield* validationErr("Cloudflare Workers runtime requires a server deployment. Please choose 'cloudflare' for --server-deploy.");
 		if (providedFlags.has("serverDeploy") && config.serverDeploy === "cloudflare" && config.runtime !== "workers") yield* validationErr(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
 		if (config.addons && config.addons.length > 0) {
-			yield* validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
+			yield* validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime);
 			config.addons = [...new Set(config.addons)];
 		}
 		yield* validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? [], config.api);
@@ -3901,7 +4579,7 @@ function validateConfigForProgrammaticUse(config) {
 		if (config.frontend && config.frontend.length > 0) yield* ensureSingleWebAndNative(config.frontend);
 		yield* validateApiFrontendCompatibility(config.api, config.frontend);
 		yield* validatePaymentsCompatibility(config.payments, config.auth, config.backend, config.frontend);
-		if (config.addons && config.addons.length > 0) yield* validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
+		if (config.addons && config.addons.length > 0) yield* validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime);
 		yield* validateExamplesCompatibility(config.examples ?? [], config.backend, config.database, config.frontend ?? [], config.api);
 		return Result.ok(void 0);
 	});
@@ -4096,7 +4774,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 		api: ({ results }) => getApiChoice(flags.api, results.frontend, results.backend),
 		auth: ({ results }) => getAuthChoice(flags.auth, results.backend, results.frontend),
 		payments: ({ results }) => getPaymentsChoice(flags.payments, results.auth, results.backend, results.frontend),
-		addons: ({ results }) => getAddonsChoice(flags.addons, results.frontend, results.auth),
+		addons: ({ results }) => getAddonsChoice(flags.addons, results.frontend, results.auth, results.backend, results.runtime),
 		examples: ({ results }) => getExamplesChoice(flags.examples, results.database, results.frontend, results.backend, results.api),
 		dbSetup: ({ results }) => getDBSetupChoice(results.database ?? "none", flags.dbSetup, results.orm, results.backend, results.runtime),
 		webDeploy: ({ results }) => getDeploymentChoice(flags.webDeploy, results.runtime, results.backend, results.frontend, results.dbSetup),
@@ -6076,7 +6754,10 @@ async function displayPostInstallInstructions(config) {
 			output += `${pc.cyan("•")} Backend API: http://localhost:3000\n`;
 			if (api === "orpc") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:3000/api-reference\n`;
 		}
-		if (isBackendSelf && api === "orpc") output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}/api/rpc/api-reference\n`;
+		if (isBackendSelf && api === "orpc") {
+			const rpcPath = frontend?.includes("next") || frontend?.includes("tanstack-start") ? "/api/rpc" : "/rpc";
+			output += `${pc.cyan("•")} OpenAPI (Scalar UI): http://localhost:${webPort}${rpcPath}/api-reference\n`;
+		}
 		if (addons?.includes("starlight")) output += `${pc.cyan("•")} Docs: http://localhost:4321\n`;
 		if (addons?.includes("fumadocs")) output += `${pc.cyan("•")} Fumadocs: http://localhost:4000\n`;
 	}
@@ -6104,7 +6785,8 @@ async function displayPostInstallInstructions(config) {
 }
 function getNativeInstructions(isConvex, isBackendSelf, frontend, runCmd) {
 	const envVar = isConvex ? "EXPO_PUBLIC_CONVEX_URL" : "EXPO_PUBLIC_SERVER_URL";
-	const exampleUrl = isConvex ? "https://<YOUR_CONVEX_URL>" : isBackendSelf ? "http://<YOUR_LOCAL_IP>:3001" : "http://<YOUR_LOCAL_IP>:3000";
+	const selfBackendPort = frontend.includes("svelte") ? "5173" : frontend.includes("astro") ? "4321" : "3001";
+	const exampleUrl = isConvex ? "https://<YOUR_CONVEX_URL>" : isBackendSelf ? `http://<YOUR_LOCAL_IP>:${selfBackendPort}` : "http://<YOUR_LOCAL_IP>:3000";
 	const envFileName = ".env";
 	const ipNote = isConvex ? "your Convex deployment URL (find after running 'dev:setup')" : "your local IP address";
 	let instructions = `${pc.yellow("NOTE:")} For Expo connectivity issues, update\n   apps/native/${envFileName} with ${ipNote}:\n   ${`${envVar}=${exampleUrl}`}\n`;
@@ -6251,8 +6933,8 @@ function getPolarInstructions(backend) {
 function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
 	const isBackendSelf = backend === "self";
-	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") instructions.push(`${pc.bold("Deploy web with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
-	else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
+	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy web with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	else if (webDeploy === "cloudflare" && (serverDeploy === "cloudflare" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
@@ -6532,6 +7214,10 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			...config,
 			dbSetupOptions: effectiveDbSetupOptions
 		};
+		if (!input.yolo) {
+			const addonsValidationResult = validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime);
+			if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
+		}
 		const reproducibleCommand = generateReproducibleCommand(config);
 		if (input.dryRun) {
 			const elapsedTimeMs = Date.now() - startTime;