create-better-t-stack 3.42.2 → 3.43.0

package/dist/{src-C0_lYEa0.mjs → src-BSgSoI0r.mjs}

@@ -1,26 +1,27 @@
 #!/usr/bin/env node
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-yhw22V8Z.mjs";
 import { getAllJsonSchemas } from "@better-t-stack/types/json-schema";
-import { initTRPC } from "@trpc/server";
+import { os } from "@orpc/server";
 import { Result, Result as Result$1, TaggedError } from "better-result";
 import { createCli } from "trpc-cli";
-import z from "zod";
+import z, { z as z$1 } from "zod";
 import { box, cancel, confirm, intro, isCancel, limitOptions, log, outro, select, spinner, text } from "@clack/prompts";
 import pc from "picocolors";
 import path from "node:path";
 import envPaths from "env-paths";
 import fs from "fs-extra";
 import { fileURLToPath } from "node:url";
-import { desktopWebFrontends as desktopWebFrontends$2, usesAlchemyManagedDatabase } from "@better-t-stack/types";
-import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, processAddonTemplates, processAddonsDeps, processNxConfig, processPackageConfigs, processTemplateString, processTurboConfig, processVitePlusConfig } from "@better-t-stack/template-generator";
+import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, processAddonTemplates, processAddonsDeps, processNxConfig, processPackageConfigs, processPwaPlugins, processTemplateString, processTurboConfig, processVitePlusConfig } from "@better-t-stack/template-generator";
+import { BetterTStackConfigSchema, CONVEX_AI_INCOMPATIBLE_FRONTENDS, CONVEX_BETTER_AUTH_INCOMPATIBLE_FRONTENDS, CONVEX_BETTER_AUTH_SUPPORTED_FRONTENDS, FULLSTACK_FRONTENDS, OBSERVABILITY_ADDONS, OBSERVABILITY_ADDONS as OBSERVABILITY_ADDONS$1, SERVER_BACKENDS, TASK_RUNNER_ADDONS, TASK_RUNNER_ADDONS as TASK_RUNNER_ADDONS$1, TRPC_INCOMPATIBLE_FRONTENDS, allowedApisForFrontends, allowedApisForFrontends as allowedApisForFrontends$1, getBackendDisabledOptions, getDesktopDeployConflict, hasCloudflareNextPostgresConflict, isExampleAIAllowed, isExampleAIAllowed as isExampleAIAllowed$1, isExampleTodoAllowed, isExampleTodoAllowed as isExampleTodoAllowed$1, isFrontendAllowedWithBackend, isFrontendAllowedWithBackend as isFrontendAllowedWithBackend$1, supportsClerkBackend, supportsClerkFrontend, supportsConvexBetterAuth, supportsDatabaseSetup, supportsDatabaseSetupRuntime, supportsOrmDatabase, supportsPaymentsAuth, supportsPrismaWebDeploy, supportsPrismaWebDeploy as supportsPrismaWebDeploy$1, supportsRuntimeBackend, supportsRuntimeDatabase, supportsServerDeployRuntime, usesAlchemyManagedDatabase, validateAddonCompatibility, validateAddonCompatibility as validateAddonCompatibility$1, webFrontends } from "@better-t-stack/types";
+import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1, wrapTextWithPrefix } from "@clack/core";
 import { consola, createConsola } from "consola";
 import { AsyncLocalStorage } from "node:async_hooks";
 import gradient from "gradient-string";
 import { $, execa } from "execa";
 import { writeTree } from "@better-t-stack/template-generator/fs-writer";
-import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
+import * as fs$1 from "node:fs/promises";
 import { applyEdits, modify, parse } from "jsonc-parser";
-import os from "node:os";
+import os$1 from "node:os";
 import { clean, coerce, satisfies } from "semver";
 import { format } from "oxfmt";
 //#region src/utils/display-config.ts
@@ -76,6 +77,7 @@ const VALUE_LABELS = {
 	skills: "Agent skills",
 	mcp: "MCP servers",
 	evlog: "evlog",
+	axiom: "Axiom",
 	todo: "Todo app",
 	ai: "AI chat",
 	turso: "Turso",
@@ -205,32 +207,6 @@ function getDefaultConfig() {
 	};
 }
 const DEFAULT_CONFIG = getDefaultConfig();
-const ADDON_COMPATIBILITY = {
-	pwa: [
-		"tanstack-router",
-		"react-router",
-		"solid",
-		"next"
-	],
-	tauri: desktopWebFrontends$2,
-	electrobun: desktopWebFrontends$2,
-	biome: [],
-	husky: [],
-	lefthook: [],
-	turborepo: [],
-	nx: [],
-	"vite-plus": [],
-	starlight: [],
-	ultracite: [],
-	mcp: [],
-	oxlint: [],
-	fumadocs: [],
-	opentui: [],
-	wxt: [],
-	skills: [],
-	evlog: [],
-	none: []
-};
 //#endregion
 //#region src/utils/context.ts
 const cliStorage = new AsyncLocalStorage();
@@ -396,42 +372,52 @@ const noopSpinner = {
 const FRAME_MS = 80;
 const HIDE_CURSOR = "\x1B[?25l";
 const SHOW_CURSOR = "\x1B[?25h";
-const CLEAR_LINE = "\r\x1B[2K";
-let cursorHidden = false;
+const ERASE_DOWN = "\r\x1B[J";
+const cursorUp = (rows) => `\x1b[${rows}A`;
+let cursorOutput;
 let restoreCursorOnExit = false;
-function hideCursor() {
-	if (cursorHidden) return;
-	cursorHidden = true;
-	process.stdout.write(HIDE_CURSOR);
+function hideCursor(out) {
+	if (cursorOutput) return;
+	cursorOutput = out;
+	out.write(HIDE_CURSOR);
 	if (!restoreCursorOnExit) {
 		restoreCursorOnExit = true;
 		process.once("exit", () => {
-			if (cursorHidden) process.stdout.write(SHOW_CURSOR);
+			cursorOutput?.write(SHOW_CURSOR);
 		});
 	}
 }
-function showCursor() {
-	if (!cursorHidden) return;
-	cursorHidden = false;
-	process.stdout.write(SHOW_CURSOR);
+function showCursor(out) {
+	if (cursorOutput !== out) return;
+	cursorOutput = void 0;
+	out.write(SHOW_CURSOR);
 }
 /**
 * The clack spinner puts stdin in raw mode and exits the process on Ctrl-C from its own
 * keypress handler. This one never touches stdin, so Ctrl-C stays a SIGINT and the
 * interrupt scope decides what happens.
 */
-function createTerminalSpinner() {
-	const out = process.stdout;
-	const animate = out.isTTY && !process.env.CI;
+function createTerminalSpinner(out) {
+	const animate = Boolean(out.isTTY) && !process.env.CI;
 	let text = "";
 	let active = false;
 	let interruptedBefore = false;
 	let frame = 0;
 	let dots = 0;
+	let renderedRows = 0;
 	let timer;
+	const clearFrame = () => {
+		if (renderedRows > 1) out.write(cursorUp(renderedRows - 1));
+		out.write(ERASE_DOWN);
+		renderedRows = 0;
+	};
 	const render = () => {
 		const suffix = ".".repeat(Math.floor(dots)).slice(0, 3);
-		out.write(`${CLEAR_LINE}${pc.magenta(SPINNER_FRAMES[frame])}  ${text}${suffix}`);
+		const line = `${pc.magenta(SPINNER_FRAMES[frame])}  ${text}${suffix}`;
+		clearFrame();
+		const wrapped = wrapTextWithPrefix(out, line, "");
+		out.write(wrapped.replaceAll("\n", "\r\n"));
+		renderedRows = wrapped.split("\n").length;
 		frame = (frame + 1) % SPINNER_FRAMES.length;
 		dots = dots < 4 ? dots + .125 : 0;
 	};
@@ -446,7 +432,7 @@ function createTerminalSpinner() {
 			setText(message);
 			out.write(`${pc.gray(S_BAR)}\n`);
 			if (animate) {
-				hideCursor();
+				hideCursor(out);
 				render();
 				timer = setInterval(render, FRAME_MS);
 			} else out.write(`${pc.magenta(SPINNER_FRAMES[0])}  ${text}\n`);
@@ -457,16 +443,16 @@ function createTerminalSpinner() {
 			active = false;
 			if (timer) clearInterval(timer);
 			if (animate) {
-				out.write(CLEAR_LINE);
-				showCursor();
+				clearFrame();
+				showCursor(out);
 			}
 			const cancelled = wasInterrupted() && !interruptedBefore;
 			out.write(cancelled ? `${pc.yellow(S_STEP_CANCEL)}  ${text} (cancelled)\n` : `${pc.green(S_STEP_SUBMIT)}  ${message || text}\n`);
 		}
 	};
 }
-function createSpinner() {
-	return isSilent() ? noopSpinner : createTerminalSpinner();
+function createSpinner(output) {
+	return isSilent() ? noopSpinner : createTerminalSpinner(output ?? process.stdout);
 }
 const baseConsola = createConsola({
 	...consola.options,
@@ -1059,40 +1045,9 @@ import * as import__better_t_stack_types from "@better-t-stack/types";
 __reExport(types_exports, import__better_t_stack_types);
 //#endregion
 //#region src/utils/compatibility.ts
-const WEB_FRAMEWORKS = [
-	"tanstack-router",
-	"react-router",
-	"tanstack-start",
-	"next",
-	"nuxt",
-	"svelte",
-	"solid",
-	"astro"
-];
+const WEB_FRAMEWORKS = webFrontends;
 //#endregion
 //#region src/utils/compatibility-rules.ts
-const TASK_RUNNER_ADDONS = [
-	"turborepo",
-	"nx",
-	"vite-plus"
-];
-const STATIC_DESKTOP_ADDONS = ["tauri", "electrobun"];
-const TAURI_STATIC_EXPORT_FRONTENDS = ["next", "tanstack-start"];
-const CONVEX_BETTER_AUTH_INCOMPATIBLE_FRONTENDS = [
-	"nuxt",
-	"svelte",
-	"solid",
-	"astro"
-];
-const CONVEX_BETTER_AUTH_SUPPORTED_FRONTENDS = [
-	"tanstack-router",
-	"react-router",
-	"tanstack-start",
-	"next",
-	"native-bare",
-	"native-uniwind",
-	"native-unistyles"
-];
 function validationErr$1(message) {
 	return Result.err(new ValidationError({ message }));
 }
@@ -1111,111 +1066,29 @@ function ensureSingleWebAndNative(frontends) {
 	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);
 }
-const FULLSTACK_FRONTENDS$1 = [
-	"next",
-	"tanstack-start",
-	"nuxt",
-	"svelte",
-	"solid",
-	"astro"
-];
-const EVLOG_SERVER_BACKENDS = [
-	"hono",
-	"express",
-	"fastify",
-	"elysia"
-];
-const EVLOG_FULLSTACK_FRONTENDS = [
-	"next",
-	"tanstack-start",
-	"nuxt",
-	"svelte",
-	"astro"
-];
-const evlogCompatibilityMessage = "evlog addon supports Hono, Express, Fastify, Elysia, or backend self with Next.js, TanStack Start, Nuxt, SvelteKit, or Astro. Convex and backend none are not supported yet.";
-function supportsEvlogAddon(frontend = [], backend, _runtime) {
-	if (!backend) return true;
-	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) {
+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, SvelteKit, Solid, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend solid, or --frontend astro.");
+		if (!(web.length === 1 && FULLSTACK_FRONTENDS.some((frontend) => frontend === web[0]))) return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, Solid, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend solid, or --frontend astro.");
 		if (native.length > 1) return validationErr$1("Cannot select multiple native frameworks. Choose only one of: native-bare, native-uniwind, native-unistyles");
 	}
-	const hasFullstackFrontend = frontends.some((f) => FULLSTACK_FRONTENDS$1.includes(f));
-	if (providedFlags.has("backend") && !hasFullstackFrontend && backend === "self") return validationErr$1("Backend 'self' (fullstack) currently only supports Next.js, TanStack Start, Nuxt, SvelteKit, Solid, and Astro frontends. Please use --frontend next, --frontend tanstack-start, --frontend nuxt, --frontend svelte, --frontend solid, --frontend astro, or choose a different backend.");
 	return Result.ok(void 0);
 }
 function validateWorkersCompatibility(providedFlags, options, config) {
-	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && config.backend !== "hono") return validationErr$1(`Cloudflare Workers runtime (--runtime workers) is only supported with Hono backend (--backend hono). Current backend: ${config.backend}. Please use '--backend hono' or choose a different runtime.`);
-	if (providedFlags.has("backend") && config.backend && config.backend !== "hono" && config.runtime === "workers") return validationErr$1(`Backend '${config.backend}' is not compatible with Cloudflare Workers runtime. Cloudflare Workers runtime is only supported with Hono backend. Please use '--backend hono' or choose a different runtime.`);
-	if (providedFlags.has("runtime") && options.runtime === "workers" && config.database === "mongodb") return validationErr$1("Cloudflare Workers runtime (--runtime workers) is not compatible with MongoDB database. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle or Prisma ORM. Please use a different database or runtime.");
-	if (providedFlags.has("database") && config.database === "mongodb" && config.runtime === "workers") return validationErr$1("MongoDB database is not compatible with Cloudflare Workers runtime. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle or Prisma ORM. Please use a different database or runtime.");
+	if (providedFlags.has("runtime") && options.runtime === "workers" && config.backend && !supportsRuntimeBackend("workers", config.backend)) return validationErr$1(`Cloudflare Workers runtime (--runtime workers) is only supported with Hono backend (--backend hono). Current backend: ${config.backend}. Please use '--backend hono' or choose a different runtime.`);
+	if (providedFlags.has("backend") && config.backend && !supportsRuntimeBackend("workers", config.backend) && config.runtime === "workers") return validationErr$1(`Backend '${config.backend}' is not compatible with Cloudflare Workers runtime. Cloudflare Workers runtime is only supported with Hono backend. Please use '--backend hono' or choose a different runtime.`);
+	if (providedFlags.has("runtime") && !supportsRuntimeDatabase(options.runtime, config.database)) return validationErr$1("Cloudflare Workers runtime (--runtime workers) is not compatible with MongoDB database. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle or Prisma ORM. Please use a different database or runtime.");
+	if (providedFlags.has("database") && !supportsRuntimeDatabase(config.runtime, config.database)) return validationErr$1("MongoDB database is not compatible with Cloudflare Workers runtime. MongoDB requires Prisma or Mongoose ORM, but Workers runtime only supports Drizzle or Prisma ORM. Please use a different database or runtime.");
 	return Result.ok(void 0);
 }
 function validateApiFrontendCompatibility(api, frontends = []) {
-	const includesNuxt = frontends.includes("nuxt");
-	const includesSvelte = frontends.includes("svelte");
-	const includesSolid = frontends.includes("solid");
-	const includesAstro = frontends.includes("astro");
-	if ((includesNuxt || includesSvelte || includesSolid || includesAstro) && api === "trpc") return validationErr$1(`tRPC API is not supported with '${includesNuxt ? "nuxt" : includesSvelte ? "svelte" : includesSolid ? "solid" : "astro"}' frontend. Please use --api orpc or --api none or remove '${includesNuxt ? "nuxt" : includesSvelte ? "svelte" : includesSolid ? "solid" : "astro"}' from --frontend.`);
-	return Result.ok(void 0);
-}
-function isFrontendAllowedWithBackend(frontend, backend, auth) {
-	if (backend === "convex") {
-		if (auth === "better-auth" && CONVEX_BETTER_AUTH_INCOMPATIBLE_FRONTENDS.includes(frontend)) return false;
-		if (frontend === "solid" || frontend === "astro") return false;
+	if (api === "trpc" && !allowedApisForFrontends(frontends).includes(api)) {
+		const frontend = frontends.find((f) => TRPC_INCOMPATIBLE_FRONTENDS.some((value) => value === f));
+		return validationErr$1(`tRPC API is not supported with '${frontend}' frontend. Please use --api orpc or --api none or remove '${frontend}' from --frontend.`);
 	}
-	if (auth === "clerk") {
-		if ([
-			"nuxt",
-			"svelte",
-			"solid",
-			"astro"
-		].includes(frontend)) return false;
-	}
-	return true;
-}
-function supportsConvexBetterAuth(frontends = []) {
-	return frontends.some((frontend) => CONVEX_BETTER_AUTH_SUPPORTED_FRONTENDS.includes(frontend));
-}
-function allowedApisForFrontends(frontends = []) {
-	const includesNuxt = frontends.includes("nuxt");
-	const includesSvelte = frontends.includes("svelte");
-	const includesSolid = frontends.includes("solid");
-	const includesAstro = frontends.includes("astro");
-	const base = [
-		"trpc",
-		"orpc",
-		"none"
-	];
-	if (includesNuxt || includesSvelte || includesSolid || includesAstro) return ["orpc", "none"];
-	return base;
-}
-function isExampleTodoAllowed(backend, database, api) {
-	if (backend === "convex") return true;
-	if (database === "none" || api === "none") return false;
-	return true;
-}
-function isExampleAIAllowed(backend, frontends = []) {
-	if (backend === "none") return false;
-	const includesSolid = frontends.includes("solid");
-	const includesAstro = frontends.includes("astro");
-	if (includesSolid || includesAstro) return false;
-	if (backend === "convex") {
-		const includesNuxt = frontends.includes("nuxt");
-		const includesSvelte = frontends.includes("svelte");
-		if (includesNuxt || includesSvelte) return false;
-	}
-	return true;
+	return Result.ok(void 0);
 }
 function validateWebDeployRequiresWebFrontend(webDeploy, hasWebFrontendFlag) {
 	if (webDeploy && webDeploy !== "none" && !hasWebFrontendFlag) return validationErr$1("'--web-deploy' requires a web frontend. Please select a web frontend or set '--web-deploy none'.");
@@ -1227,97 +1100,48 @@ function validateServerDeployRequiresBackend(serverDeploy, backend) {
 }
 function validateDockerServerDeploy(serverDeploy, backend, runtime) {
 	if (serverDeploy !== "docker") return Result.ok(void 0);
-	if (backend === "convex" || backend === "self") return validationErr$1("'--server-deploy docker' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy docker' instead.");
-	if (runtime === "workers") return validationErr$1("'--server-deploy docker' is not compatible with '--runtime workers'. Use '--runtime bun' or '--runtime node', or choose '--server-deploy cloudflare'.");
+	if (backend && backend !== "none" && !SERVER_BACKENDS.includes(backend)) return validationErr$1("'--server-deploy docker' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy docker' instead.");
+	if (runtime && !supportsServerDeployRuntime(serverDeploy, runtime)) return validationErr$1("'--server-deploy docker' is not compatible with '--runtime workers'. Use '--runtime bun' or '--runtime node', or choose '--server-deploy cloudflare'.");
 	return Result.ok(void 0);
 }
 function validateVercelServerDeploy(serverDeploy, backend, runtime) {
 	if (serverDeploy !== "vercel") return Result.ok(void 0);
-	if (backend === "convex" || backend === "self") return validationErr$1("'--server-deploy vercel' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy vercel' instead.");
-	if (runtime === "workers") return validationErr$1("'--server-deploy vercel' is not compatible with '--runtime workers'. Use '--runtime bun' or '--runtime node', or choose '--server-deploy cloudflare'.");
+	if (backend && backend !== "none" && !SERVER_BACKENDS.includes(backend)) return validationErr$1("'--server-deploy vercel' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy vercel' instead.");
+	if (runtime && !supportsServerDeployRuntime(serverDeploy, runtime)) return validationErr$1("'--server-deploy vercel' is not compatible with '--runtime workers'. Use '--runtime bun' or '--runtime node', or choose '--server-deploy cloudflare'.");
 	return Result.ok(void 0);
 }
 function validatePrismaServerDeploy(serverDeploy, backend, runtime) {
 	if (serverDeploy !== "prisma") return Result.ok(void 0);
-	if (backend === "convex" || backend === "self") return validationErr$1("'--server-deploy prisma' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy prisma' instead.");
-	if (runtime !== "bun" && runtime !== "node") return validationErr$1("'--server-deploy prisma' requires '--runtime bun' or '--runtime node'. Use '--server-deploy cloudflare' for Workers.");
+	if (backend && backend !== "none" && !SERVER_BACKENDS.includes(backend)) return validationErr$1("'--server-deploy prisma' requires a separate server backend (hono, express, fastify, elysia). For a fullstack 'self' backend, use '--web-deploy prisma' instead.");
+	if (!supportsServerDeployRuntime(serverDeploy, runtime)) return validationErr$1("'--server-deploy prisma' requires '--runtime bun' or '--runtime node'. Use '--server-deploy cloudflare' for Workers.");
 	return Result.ok(void 0);
 }
-const PRISMA_COMPUTE_WEB_FRONTENDS = [
-	"next",
-	"nuxt",
-	"astro",
-	"react-router",
-	"tanstack-start",
-	"svelte",
-	"solid"
-];
-function supportsPrismaWebDeploy(frontend) {
-	return frontend.some((value) => PRISMA_COMPUTE_WEB_FRONTENDS.includes(value));
-}
 function validatePrismaWebDeploy(webDeploy, frontend) {
 	if (webDeploy !== "prisma" || !frontend) return Result.ok(void 0);
 	if (!supportsPrismaWebDeploy(frontend)) return validationErr$1("'--web-deploy prisma' requires a supported server frontend. Choose Next.js, Nuxt, Astro, React Router, TanStack Start, SvelteKit, or Solid. TanStack Router is a static SPA, while Prisma Compute requires an executable server artifact.");
 	return Result.ok(void 0);
 }
 function validateCloudflareWebDeployKnownIssues(config) {
-	if (config.webDeploy !== "cloudflare" || !config.frontend?.includes("next")) return Result.ok(void 0);
-	if (config.database === "postgres" && config.orm === "prisma" && config.dbSetup !== "neon" && config.dbSetup !== "prisma-postgres") return validationErr$1("This Prisma PostgreSQL setup with Next.js on Cloudflare is temporarily unavailable because OpenNext does not preserve pg-cloudflare's workerd files. Use Neon or Prisma Postgres, choose another Cloudflare frontend, or choose Prisma, Docker, or Vercel deployment.");
+	if (hasCloudflareNextPostgresConflict(config)) return validationErr$1("This Prisma PostgreSQL setup with Next.js on Cloudflare is temporarily unavailable because OpenNext does not preserve pg-cloudflare's workerd files. Use Neon or Prisma Postgres, choose another Cloudflare frontend, or choose Prisma, Docker, or Vercel deployment.");
 	return Result.ok(void 0);
 }
-const DESKTOP_STATIC_EXPORT_FRONTENDS = [
-	"next",
-	"svelte",
-	"astro",
-	"react-router"
-];
 function validateDockerWebDeployDesktopAddons(webDeploy, addons, frontend, backend, auth) {
-	if (webDeploy !== "docker" || !addons || !frontend) return Result.ok(void 0);
-	const desktopAddons = addons.filter((addon) => STATIC_DESKTOP_ADDONS.includes(addon));
-	if (desktopAddons.length === 0) return Result.ok(void 0);
-	const affected = frontend.find((f) => DESKTOP_STATIC_EXPORT_FRONTENDS.includes(f));
-	if (!affected) return Result.ok(void 0);
-	if (affected === "next" && !desktopAddons.includes("tauri") && backend === "convex" && auth === "better-auth") return Result.ok(void 0);
+	const conflict = getDesktopDeployConflict(webDeploy, addons, frontend, backend, auth);
+	if (webDeploy !== "docker" || !conflict) return Result.ok(void 0);
+	const { selectedDesktopAddons: desktopAddons, affectedFrontend: affected } = conflict;
 	return validationErr$1(`'--web-deploy docker' is not compatible with the ${desktopAddons.join(", ")} addon on '${affected}' because desktop addons switch the web build to a static export, which the docker image cannot serve. Remove the addon or use the static-serving tanstack-router frontend.`);
 }
 function validatePrismaWebDeployDesktopAddons(webDeploy, addons, frontend) {
-	if (webDeploy !== "prisma" || !addons || !frontend) return Result.ok(void 0);
-	const desktopAddons = addons.filter((addon) => STATIC_DESKTOP_ADDONS.includes(addon));
-	if (desktopAddons.length === 0) return Result.ok(void 0);
-	const affected = frontend.find((value) => DESKTOP_STATIC_EXPORT_FRONTENDS.includes(value));
-	if (!affected) return Result.ok(void 0);
+	const conflict = getDesktopDeployConflict(webDeploy, addons, frontend);
+	if (webDeploy !== "prisma" || !conflict) return Result.ok(void 0);
+	const { selectedDesktopAddons: desktopAddons, affectedFrontend: affected } = conflict;
 	return validationErr$1(`'--web-deploy prisma' is not compatible with the ${desktopAddons.join(", ")} addon on '${affected}' because desktop addons replace its executable server output with a static export, while Prisma Compute requires an executable server artifact. Remove the addon or choose a server deployment that supports this desktop build.`);
 }
-function validateAddonCompatibility(addon, frontend, auth, backend, runtime) {
-	if (addon === "evlog" && !supportsEvlogAddon(frontend, backend, runtime)) return {
-		isCompatible: false,
-		reason: evlogCompatibilityMessage
-	};
-	if (STATIC_DESKTOP_ADDONS.includes(addon) && auth === "clerk" && frontend.includes("react-router")) return {
-		isCompatible: false,
-		reason: `${addon} addon forces React Router into a static export, but Clerk on React Router requires SSR middleware. Remove the addon or use a different auth/frontend.`
-	};
-	if (backend === "self" && STATIC_DESKTOP_ADDONS.includes(addon)) return {
-		isCompatible: false,
-		reason: `${addon} addon requires a separate backend or no backend because backend 'self' emits server routes that cannot be bundled as static desktop assets.`
-	};
-	if (addon === "tauri" && backend === "convex" && auth === "better-auth" && frontend.some((f) => TAURI_STATIC_EXPORT_FRONTENDS.includes(f))) return {
-		isCompatible: false,
-		reason: "tauri addon is not compatible with Convex Better Auth on Next.js or TanStack Start because those templates use server auth bootstrap and cannot be exported as static desktop assets."
-	};
-	const compatibleFrontends = ADDON_COMPATIBILITY[addon];
-	if (compatibleFrontends.length > 0) {
-		if (!frontend.some((f) => compatibleFrontends.includes(f))) return {
-			isCompatible: false,
-			reason: `${addon} addon requires one of these frontends: ${compatibleFrontends.join(", ")}`
-		};
-	}
-	return { isCompatible: true };
-}
 function getCompatibleAddons(allAddons, frontend, existingAddons = [], auth, backend, runtime) {
 	return allAddons.filter((addon) => {
 		if (existingAddons.includes(addon)) return false;
 		if (addon === "none") return false;
+		if (OBSERVABILITY_ADDONS.includes(addon) && existingAddons.some((existing) => OBSERVABILITY_ADDONS.includes(existing))) return false;
 		if (TASK_RUNNER_ADDONS.includes(addon) && existingAddons.some((existingAddon) => TASK_RUNNER_ADDONS.includes(existingAddon))) return false;
 		const { isCompatible } = validateAddonCompatibility(addon, frontend, auth, backend, runtime);
 		return isCompatible;
@@ -1327,8 +1151,8 @@ function validateAddonsAgainstFrontends(addons = [], frontends = [], auth, backe
 	if (addons.filter((addon) => TASK_RUNNER_ADDONS.includes(addon)).length > 1) return validationErr$1("Cannot combine 'turborepo', 'nx', and 'vite-plus' addons. Choose one task runner.");
 	for (const addon of addons) {
 		if (addon === "none") continue;
-		const { isCompatible, reason } = validateAddonCompatibility(addon, frontends, auth, backend, runtime);
-		if (!isCompatible) return validationErr$1(`Incompatible addon/frontend combination: ${reason}`);
+		const compatibility = validateAddonCompatibility(addon, frontends, auth, backend, runtime);
+		if (!compatibility.isCompatible) return validationErr$1(`Incompatible addon/frontend combination: ${compatibility.reason}`);
 	}
 	return Result.ok(void 0);
 }
@@ -1344,25 +1168,22 @@ function validateAddonsAgainstConfig(addons = [], config) {
 function validatePaymentsCompatibility(payments, auth, _backend, _frontends = []) {
 	if (!payments || payments === "none") return Result.ok(void 0);
 	if (payments === "polar") {
-		if (!auth || auth === "none" || auth !== "better-auth") return validationErr$1("Polar payments requires Better Auth. Please use '--auth better-auth' or choose a different payments provider.");
+		if (!supportsPaymentsAuth(payments, auth)) return validationErr$1("Polar payments requires Better Auth. Please use '--auth better-auth' or choose a different payments provider.");
 	}
 	return Result.ok(void 0);
 }
 function validateExamplesCompatibility(examples, backend, database, frontend, api) {
 	const examplesArr = examples ?? [];
 	if (examplesArr.length === 0 || examplesArr.includes("none")) return Result.ok(void 0);
-	if (examplesArr.includes("todo") && backend !== "convex") {
+	if (examplesArr.includes("todo") && !isExampleTodoAllowed(backend, database, api)) {
 		if (database === "none") return validationErr$1("The 'todo' example requires a database. Cannot use --examples todo when database is 'none'.");
 		if (api === "none") return validationErr$1("The 'todo' example requires an API layer (tRPC or oRPC). Cannot use --examples todo when api is 'none'.");
 	}
-	if (examplesArr.includes("ai") && (frontend ?? []).includes("solid")) return validationErr$1("The 'ai' example is not compatible with the Solid frontend.");
-	if (examplesArr.includes("ai") && (frontend ?? []).includes("astro")) return validationErr$1("The 'ai' example is not compatible with the Astro frontend.");
+	if (examplesArr.includes("ai") && !isExampleAIAllowed(backend, frontend) && frontend?.includes("solid")) return validationErr$1("The 'ai' example is not compatible with the Solid frontend.");
+	if (examplesArr.includes("ai") && !isExampleAIAllowed(backend, frontend) && frontend?.includes("astro")) return validationErr$1("The 'ai' example is not compatible with the Astro frontend.");
 	if (examplesArr.includes("ai") && backend === "none") return validationErr$1("The 'ai' example requires a backend.");
 	if (examplesArr.includes("ai") && backend === "convex") {
-		const frontendArr = frontend ?? [];
-		const includesNuxt = frontendArr.includes("nuxt");
-		const includesSvelte = frontendArr.includes("svelte");
-		if (includesNuxt || includesSvelte) return validationErr$1("The 'ai' example with Convex backend only supports React-based frontends (Next.js, TanStack Router, TanStack Start, React Router). Svelte and Nuxt are not supported with Convex AI.");
+		if ((frontend ?? []).some((f) => CONVEX_AI_INCOMPATIBLE_FRONTENDS.some((value) => value === f))) return validationErr$1("The 'ai' example with Convex backend only supports React-based frontends (Next.js, TanStack Router, TanStack Start, React Router). Svelte and Nuxt are not supported with Convex AI.");
 	}
 	return Result.ok(void 0);
 }
@@ -1755,6 +1576,10 @@ function getAddonDisplay(addon) {
 			label = "evlog";
 			hint = "Request logging with Better Auth context and AI SDK telemetry";
 			break;
+		case "axiom":
+			label = "Axiom";
+			hint = "Managed production observability through evlog and Alchemy";
+			break;
 		default:
 			label = addon;
 			hint = `Add ${addon}`;
@@ -1785,7 +1610,7 @@ const ADDON_GROUPS = {
 		"opentui",
 		"wxt"
 	],
-	Observability: ["evlog"],
+	Observability: ["evlog", "axiom"],
 	"AI & Agent Tools": ["skills", "mcp"]
 };
 function createGroupedOptions() {
@@ -1810,7 +1635,8 @@ function sortAndPruneGroupedOptions(groupedOptions) {
 	});
 }
 function validateAddonSelection(selected) {
-	if ((selected?.filter((addon) => TASK_RUNNER_ADDONS.includes(addon)) ?? []).length > 1) return "Choose Turborepo, Nx, or Vite+ as your task runner, not more than one.";
+	if ((selected?.filter((addon) => TASK_RUNNER_ADDONS$1.includes(addon)) ?? []).length > 1) return "Choose Turborepo, Nx, or Vite+ as your task runner, not more than one.";
+	if ((selected?.filter((addon) => OBSERVABILITY_ADDONS$1.includes(addon)) ?? []).length > 1) return "Choose evlog or Axiom, not both. Axiom already includes evlog.";
 }
 async function getAddonsChoice(addons, frontends, auth, backend, runtime, previousValue) {
 	if (addons !== void 0) return addons;
@@ -1818,7 +1644,7 @@ async function getAddonsChoice(addons, frontends, auth, backend, runtime, previo
 	const groupedOptions = createGroupedOptions();
 	const frontendsArray = frontends || [];
 	for (const addon of allAddons) {
-		const { isCompatible } = validateAddonCompatibility(addon, frontendsArray, auth, backend, runtime);
+		const { isCompatible } = validateAddonCompatibility$1(addon, frontendsArray, auth, backend, runtime);
 		if (!isCompatible) continue;
 		const { label, hint } = getAddonDisplay(addon);
 		addOptionToGroup(groupedOptions, {
@@ -1833,7 +1659,7 @@ async function getAddonsChoice(addons, frontends, auth, backend, runtime, previo
 		options: groupedOptions,
 		initialValues: (previousValue ?? DEFAULT_CONFIG.addons).filter((addonValue) => Object.values(groupedOptions).some((options) => options.some((opt) => opt.value === addonValue))),
 		required: false,
-		exclusive: [TASK_RUNNER_ADDONS],
+		exclusive: [TASK_RUNNER_ADDONS$1, OBSERVABILITY_ADDONS$1],
 		validate: validateAddonSelection
 	});
 	if (isCancel$1(response)) throw new UserCancelledError({ message: "Operation cancelled" });
@@ -1842,7 +1668,7 @@ async function getAddonsChoice(addons, frontends, auth, backend, runtime, previo
 async function getAddonsToAdd(config) {
 	const groupedOptions = createGroupedOptions();
 	const frontendArray = config.frontend || [];
-	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, config.addons, config.auth, config.backend, config.runtime);
+	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none" && addon !== "axiom"), frontendArray, config.addons, config.auth, config.backend, config.runtime);
 	for (const addon of compatibleAddons) {
 		const { label, hint } = getAddonDisplay(addon);
 		addOptionToGroup(groupedOptions, {
@@ -1857,41 +1683,45 @@ async function getAddonsToAdd(config) {
 		message: "Select addons to add",
 		options: groupedOptions,
 		required: false,
-		exclusive: [TASK_RUNNER_ADDONS],
+		exclusive: [TASK_RUNNER_ADDONS$1, OBSERVABILITY_ADDONS$1],
 		validate: validateAddonSelection
 	});
-	if (isCancel$1(response)) throw new UserCancelledError({ message: "Operation cancelled" });
+	if (!Array.isArray(response)) throw new UserCancelledError({ message: "Operation cancelled" });
 	return response;
 }
 //#endregion
 //#region src/utils/bts-config.ts
 const BTS_CONFIG_FILE = "bts.jsonc";
-/**
-* Reads the BTS configuration file from the project directory.
-*/
+function parseBtsConfig(content) {
+	const errors = [];
+	const value = parse(content, errors, { allowTrailingComma: true });
+	if (errors.length > 0) throw new Error("Invalid JSONC in bts.jsonc");
+	return BetterTStackConfigSchema.parse(value);
+}
 async function readBtsConfig(projectDir) {
-	try {
-		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
-		if (!await fs.pathExists(configPath)) return null;
-		return parse(await fs.readFile(configPath, "utf-8"));
-	} catch {
-		return null;
-	}
+	const result = await Result.tryPromise({
+		try: async () => parseBtsConfig(await fs$1.readFile(path.join(projectDir, BTS_CONFIG_FILE), "utf8")),
+		catch: () => null
+	});
+	return result.isOk() ? result.value : null;
 }
-/**
-* Updates specific fields in the BTS configuration file.
-*/
 async function updateBtsConfig(projectDir, updates) {
-	try {
-		const configPath = path.join(projectDir, BTS_CONFIG_FILE);
-		if (!await fs.pathExists(configPath)) return;
-		let content = await fs.readFile(configPath, "utf-8");
-		for (const [key, value] of Object.entries(updates)) {
-			const edits = modify(content, [key], value, { formattingOptions: { tabSize: 2 } });
-			content = applyEdits(content, edits);
-		}
-		await fs.writeFile(configPath, content, "utf-8");
-	} catch {}
+	return Result.tryPromise({
+		try: async () => {
+			const configPath = path.join(projectDir, BTS_CONFIG_FILE);
+			let content = await fs$1.readFile(configPath, "utf8");
+			BetterTStackConfigSchema.parse({
+				...parseBtsConfig(content),
+				...updates
+			});
+			for (const [key, value] of Object.entries(updates)) content = applyEdits(content, modify(content, [key], value, { formattingOptions: { tabSize: 2 } }));
+			await fs$1.writeFile(configPath, content, "utf8");
+		},
+		catch: (cause) => new CLIError({
+			message: `Failed to update bts.jsonc: ${cause instanceof Error ? cause.message : String(cause)}`,
+			cause
+		})
+	});
 }
 //#endregion
 //#region src/utils/telemetry.ts
@@ -2019,12 +1849,12 @@ function shouldSkipExternalCommands() {
 //#endregion
 //#region src/utils/requirements.ts
 const PACKAGE_MANAGER_VERSION_RANGES = {
-	bun: ">=1.2.14",
+	bun: ">=1.3.3",
 	npm: ">=11.16.0",
 	pnpm: ">=10.26.0"
 };
 const PACKAGE_MANAGER_REASONS = {
-	bun: "generated Bun workspaces use dependency catalogs",
+	bun: "Varlock requires Bun 1.3.3 or newer",
 	npm: "generated npm workspaces use the allowScripts install-script policy",
 	pnpm: "generated pnpm workspaces use catalogs and the allowBuilds policy"
 };
@@ -2047,6 +1877,7 @@ function addNodeRequirement(requirements, range, reason) {
 }
 function getNodeToolingRequirements(config) {
 	const requirements = [];
+	addNodeRequirement(requirements, ">=22.3.0", "Varlock configuration loading");
 	for (const frontend of config.frontend) switch (frontend) {
 		case "astro":
 			addNodeRequirement(requirements, ">=22.12.0", "Astro 7");
@@ -2070,9 +1901,7 @@ function getNodeToolingRequirements(config) {
 			break;
 		case "native-bare":
 		case "native-uniwind":
-		case "native-unistyles":
-			addNodeRequirement(requirements, "^22.13.0 || ^24.3.0 || >=26.0.0", "React Native 0.86");
-			break;
+		case "native-unistyles": addNodeRequirement(requirements, "^22.13.0 || ^24.3.0 || >=26.0.0", "React Native 0.86");
 	}
 	if (![
 		"none",
@@ -2101,7 +1930,7 @@ function getBaselineRequirements(packageManager, hostRuntime) {
 		range: PACKAGE_MANAGER_VERSION_RANGES[packageManager],
 		reason: PACKAGE_MANAGER_REASONS[packageManager]
 	});
-	if (hostRuntime === "node") addNodeRequirement(requirements, ">=22.0.0", "create-better-t-stack");
+	if (hostRuntime === "node") addNodeRequirement(requirements, ">=22.12.0", "create-better-t-stack");
 	return requirements;
 }
 function getLocalVersionRequirements(config, hostRuntime) {
@@ -2151,7 +1980,7 @@ async function readToolVersion(tool) {
 	const result = await Result.tryPromise({
 		try: async () => {
 			const { stdout } = await execa(tool, ["--version"], {
-				cwd: os.tmpdir(),
+				cwd: os$1.tmpdir(),
 				stderr: "pipe"
 			});
 			return normalizeVersion(stdout);
@@ -2260,11 +2089,14 @@ function isEvlogBackend(backend) {
 function getEvlogWebFrontend(frontends) {
 	return frontends.find((frontend) => evlogWebFrontends.includes(frontend));
 }
+function usesAxiom(config) {
+	return config.addons.includes("axiom");
+}
 function shouldWireEvlogServerFsDrain(config) {
-	return isEvlogBackend(config.backend) && config.runtime !== "workers" && config.serverDeploy !== "cloudflare";
+	return !usesAxiom(config) && isEvlogBackend(config.backend) && config.runtime !== "workers" && config.serverDeploy !== "cloudflare";
 }
 function shouldWireEvlogWebFsDrain(config) {
-	return getEvlogWebFrontend(config.frontend) !== void 0 && config.webDeploy !== "cloudflare";
+	return !usesAxiom(config) && getEvlogWebFrontend(config.frontend) !== void 0 && config.webDeploy !== "cloudflare";
 }
 function supportsEvlogLocalLogs(config) {
 	return shouldWireEvlogServerFsDrain(config) || shouldWireEvlogWebFsDrain(config);
@@ -2272,13 +2104,15 @@ function supportsEvlogLocalLogs(config) {
 function shouldIdentifyWebAuth(config) {
 	return config.auth === "better-auth" && config.backend === "self";
 }
-function getEvlogServerMiddlewareMarker(backend, fsDrain) {
-	const options = fsDrain ? `{ drain: ${NODE_DEV_FS_DRAIN_EXPRESSION} }` : "";
+function getEvlogServerMiddlewareMarker(backend, fsDrain, axiom = false) {
+	const options = axiom ? "{ drain: createAxiomDrain() }" : fsDrain ? `{ drain: ${NODE_DEV_FS_DRAIN_EXPRESSION} }` : "";
 	if (backend === "hono" || backend === "express") return `app.use(evlog(${options}));`;
 	if (backend === "fastify") return `fastify.register(evlog${options ? `, ${options}` : ""});`;
 	return `.use(evlog(${options}))`;
 }
 function findEvlogServerMiddlewareMarker(content, backend) {
+	const axiomMarker = getEvlogServerMiddlewareMarker(backend, false, true);
+	if (content.includes(axiomMarker)) return axiomMarker;
 	const fsDrainMarker = getEvlogServerMiddlewareMarker(backend, true);
 	return content.includes(fsDrainMarker) ? fsDrainMarker : getEvlogServerMiddlewareMarker(backend, false);
 }
@@ -2322,11 +2156,11 @@ async function updateFileIfExists(filePath, update) {
 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 getAuthImportLine(config, source) {
+	return usesCreateAuthFactory(config) ? `import { createAuth } from "${source}";` : `import { auth } from "${source}";`;
 }
 function getAuthExpression(config) {
-	return usesCreateAuthFactory(config) ? "createAuth()" : "auth";
+	return usesCreateAuthFactory(config) ? "(await createAuth())" : "auth";
 }
 function addAiSdkEvlogTelemetry(content, loggerExpression) {
 	let nextContent = addNamedImport(content, "evlog/ai", ["createAILogger", "createEvlogIntegration"]);
@@ -2364,15 +2198,16 @@ function addEvlogBetterAuthServerSetup(content, backend, authExpression) {
 	const evlogMarker = findEvlogServerMiddlewareMarker(nextContent, backend);
 	return insertAfterOnce(nextContent, evlogMarker, `\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, fsDrain) {
+function addEvlogServerSetup(content, backend, serviceName, fsDrain, axiom = false) {
 	const initSnippet = `initLogger({\n\tenv: { service: "${serviceName}" },\n});\n\n`;
-	const evlogMarker = getEvlogServerMiddlewareMarker(backend, fsDrain);
+	const evlogMarker = getEvlogServerMiddlewareMarker(backend, fsDrain, axiom);
 	const legacyEvlogMarker = getEvlogServerMiddlewareMarker(backend, false);
 	if (backend === "hono") {
 		let nextContent = prependMissingImports(content, [
 			"import { initLogger } from \"evlog\";",
 			"import { evlog, type EvlogVariables } from \"evlog/hono\";",
-			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+			...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
 		]);
 		nextContent = insertBeforeOnce(nextContent, "const app = new Hono", initSnippet, "initLogger({");
 		nextContent = nextContent.replace("const app = new Hono();", "const app = new Hono<EvlogVariables>();");
@@ -2384,7 +2219,8 @@ function addEvlogServerSetup(content, backend, serviceName, fsDrain) {
 		let nextContent = prependMissingImports(content, [
 			"import { initLogger } from \"evlog\";",
 			"import { evlog } from \"evlog/express\";",
-			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+			...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
 		]);
 		nextContent = insertBeforeOnce(nextContent, "const app = express();", initSnippet, "initLogger({");
 		if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
@@ -2394,7 +2230,8 @@ function addEvlogServerSetup(content, backend, serviceName, fsDrain) {
 		let nextContent = prependMissingImports(content, [
 			"import { initLogger } from \"evlog\";",
 			"import { evlog } from \"evlog/fastify\";",
-			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+			...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+			...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
 		]);
 		nextContent = insertBeforeOnce(nextContent, "const fastify = Fastify", initSnippet, "initLogger({");
 		if (fsDrain) nextContent = nextContent.replace(legacyEvlogMarker, evlogMarker);
@@ -2403,7 +2240,8 @@ function addEvlogServerSetup(content, backend, serviceName, fsDrain) {
 	let nextContent = prependMissingImports(content, [
 		"import { initLogger } from \"evlog\";",
 		"import { evlog } from \"evlog/elysia\";",
-		...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []
+		...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+		...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
 	]);
 	const elysiaMarker = nextContent.includes("const app = new Elysia") ? "const app = new Elysia" : "new Elysia";
 	nextContent = insertBeforeOnce(nextContent, elysiaMarker, initSnippet, "initLogger({");
@@ -2425,14 +2263,19 @@ function addSvelteViteEvlogSetup(content, serviceName) {
 	if (nextContent.includes("evlog({")) return nextContent;
 	return nextContent.replace("sveltekit(),", `sveltekit(),\n    evlog({ service: "${serviceName}" }),`);
 }
-function getSvelteEvlogHooksCall(fsDrain) {
+function getSvelteEvlogHooksCall(fsDrain, axiom = false) {
+	if (axiom) return "createEvlogHooks({ drain: createAxiomDrain() })";
 	return fsDrain ? `createEvlogHooks({ drain: ${SVELTE_DEV_FS_DRAIN_EXPRESSION} })` : "createEvlogHooks()";
 }
-function addSvelteHooksEvlogSetup(content, fsDrain) {
-	let nextContent = prependMissingImports(content, ["import { createEvlogHooks } from \"evlog/sveltekit\";", ...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []]);
+function addSvelteHooksEvlogSetup(content, fsDrain, axiom) {
+	let nextContent = prependMissingImports(content, [
+		"import { createEvlogHooks } from \"evlog/sveltekit\";",
+		...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+		...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
+	]);
 	if (fsDrain) nextContent = addNamedImport(nextContent, "$app/environment", ["dev"]);
-	const hooksCall = getSvelteEvlogHooksCall(fsDrain);
-	if (fsDrain) nextContent = nextContent.replaceAll("createEvlogHooks()", hooksCall);
+	const hooksCall = getSvelteEvlogHooksCall(fsDrain, axiom);
+	if (fsDrain || axiom) nextContent = nextContent.replaceAll("createEvlogHooks()", hooksCall);
 	if (!nextContent.includes("export const handle") && !nextContent.includes("const authHandle")) {
 		if (!nextContent.includes("createEvlogHooks(")) nextContent = `${nextContent.trimEnd()}\n\nexport const { handle, handleError } = ${hooksCall};\n`;
 		return nextContent;
@@ -2457,33 +2300,36 @@ function addTanstackStartRootEvlogSetup(content) {
 	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 getInitLoggerSnippet(serviceName, fsDrain, indent) {
-	return `initLogger({\n${indent}env: { service: "${serviceName}" },${fsDrain ? `\n${indent}drain: ${ASTRO_DEV_FS_DRAIN_EXPRESSION},` : ""}\n});\n\n`;
+function getInitLoggerSnippet(serviceName, fsDrain, indent, axiom = false) {
+	return `initLogger({\n${indent}env: { service: "${serviceName}" },${axiom ? `\n${indent}drain: createAxiomDrain(),` : fsDrain ? `\n${indent}drain: ${ASTRO_DEV_FS_DRAIN_EXPRESSION},` : ""}\n});\n\n`;
 }
-function addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain) {
-	let nextContent = prependMissingImports(content, ["import { createRequestLogger, initLogger } from \"evlog\";", ...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : []]);
-	const initSnippet = getInitLoggerSnippet(serviceName, fsDrain, "  ");
+function addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain, axiom, cloudflare) {
+	let nextContent = prependMissingImports(content, [
+		"import { createRequestLogger, initLogger } from \"evlog\";",
+		...fsDrain ? ["import { createFsDrain } from \"evlog/fs\";"] : [],
+		...axiom ? ["import { createAxiomDrain } from \"evlog/axiom\";"] : []
+	]);
+	const initSnippet = getInitLoggerSnippet(serviceName, fsDrain, "  ", axiom);
 	nextContent = insertBeforeOnce(nextContent, "export const onRequest", initSnippet, "initLogger({");
 	if (fsDrain && !nextContent.includes("drain:")) nextContent = nextContent.replace(/initLogger\(\{\n(\s+env: \{ service: "[^"]+" \},)/, `initLogger({\n$1\n  drain: ${ASTRO_DEV_FS_DRAIN_EXPRESSION},`);
 	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;");
+		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${cloudflare ? "    waitUntil: context.locals.cfContext.waitUntil.bind(context.locals.cfContext),\n" : ""}  });\n\n  context.locals.log = log;\n`, "const log = createRequestLogger({");
+		return nextContent.replace("return next();", "const response = await next();\n  log.set({ status: response.status });\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;");
+		nextContent = insertAfterOnce(nextContent, localsMarker, `\n  const url = new URL(request.url);\n  const log = createRequestLogger({\n    method: request.method,\n    path: url.pathname,\n${cloudflare ? "    waitUntil: locals.cfContext.waitUntil.bind(locals.cfContext),\n" : ""}  });\n\n  locals.log = log;\n`, "const log = createRequestLogger({");
+		return nextContent.replace("return next();", "const response = await next();\n  log.set({ status: response.status });\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`;
+	if (nextContent.includes("declare global {") && nextContent.includes("interface Locals {")) return nextContent.replace("interface Locals {", "interface Locals {\n      log: RequestLogger;");
+	return `${nextContent.trimEnd()}\n\ndeclare global {\n  namespace App {\n    interface Locals {\n      log: RequestLogger;\n    }\n  }\n}\n`;
 }
 function addNextRouteWrappers(content) {
 	let nextContent = prependMissingImports(content, ["import { withEvlog } from \"@/lib/evlog\";"]);
@@ -2534,11 +2380,11 @@ function addNextBetterAuthToRoute(content) {
 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";`]);
+	if (!nextContent.includes("from \"./services\"")) nextContent = prependMissingImports(nextContent, [getAuthImportLine(config, "./services")]);
+	if (usesCreateAuthFactory(config) && config.webDeploy === "cloudflare" && !nextContent.includes("from \"./env.server\"")) nextContent = prependMissingImports(nextContent, ["import { env as localEnv } from \"./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`;
+	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((await 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`;
 	const evlogHandleDeclaration = nextContent.match(/const \{ handle: evlogHandle, handleError \} = createEvlogHooks\([\s\S]*?\);\n\n/)?.[0];
 	if (evlogHandleDeclaration) nextContent = insertAfterOnce(nextContent, evlogHandleDeclaration, 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)");
@@ -2546,7 +2392,7 @@ function addSvelteBetterAuthEvlogSetup(content, config) {
 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)]);
+	if (!nextContent.includes("from \"./services\"")) nextContent = prependMissingImports(nextContent, [getAuthImportLine(config, "./services")]);
 	const authExpression = getAuthExpression(config);
 	const authOptions = "{ exclude: [\"/api/auth/**\"], maskEmail: true }";
 	const usesFactory = usesCreateAuthFactory(config);
@@ -2559,21 +2405,28 @@ function addAstroBetterAuthEvlogSetup(content, config) {
 	}
 	return nextContent;
 }
-function getNextEvlogFile(serviceName, fsDrain) {
+function getNextEvlogFile(serviceName, fsDrain, axiom) {
 	return `import { createEvlog } from "evlog/next";
 import { createInstrumentation } from "evlog/next/instrumentation/create";
 ${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
+${axiom ? "import { createAxiomDrain } from \"evlog/axiom\";\n" : ""}
 
 export const { withEvlog, useLogger, log, createError } = createEvlog({
   service: "${serviceName}",
-${fsDrain ? `  drain: ${NODE_DEV_FS_DRAIN_EXPRESSION},\n` : ""}});
+${axiom ? "  drain: createAxiomDrain(),\n" : fsDrain ? `  drain: ${NODE_DEV_FS_DRAIN_EXPRESSION},\n` : ""}});
 
 export const { register, onRequestError } = createInstrumentation({
   service: "${serviceName}",
 });
 `;
 }
-function getNitroEvlogDrainFile() {
+function getNitroEvlogDrainFile(axiom = false, nitroV3 = false) {
+	if (axiom) return `${nitroV3 ? "import { definePlugin as defineNitroPlugin } from \"nitro\";\n" : ""}import { createAxiomDrain } from "evlog/axiom";
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("evlog:drain", createAxiomDrain());
+});
+`;
 	return `import { createFsDrain } from "evlog/fs";
 
 export default defineNitroPlugin((nitroApp) => {
@@ -2599,7 +2452,7 @@ export const config = {
 `;
 }
 function getNextEvlogAuthFile(config) {
-	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config, "../services")}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 import { useLogger } from "@/lib/evlog";
 
@@ -2611,7 +2464,7 @@ export async function identifyEvlogUser(request: Request) {
   await identifyUser(useLogger(), request.headers, new URL(request.url).pathname);
 }
 `;
-	return `${getAuthImportLine(config)}
+	return `${getAuthImportLine(config, "../services")}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 import { useLogger } from "@/lib/evlog";
 
@@ -2626,7 +2479,7 @@ export async function identifyEvlogUser(request: Request) {
 `;
 }
 function getNitroEvlogAuthPluginFile(config) {
-	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config)}
+	if (usesCreateAuthFactory(config)) return `${getAuthImportLine(config, "../../src/services")}
 import { createAuthIdentifier, type BetterAuthInstance } from "evlog/better-auth";
 
 export default defineNitroPlugin((nitroApp) => {
@@ -2639,7 +2492,7 @@ export default defineNitroPlugin((nitroApp) => {
   });
 });
 `;
-	return `${getAuthImportLine(config)}
+	return `${getAuthImportLine(config, "../../src/services")}
 import { createAuthIdentifier, type BetterAuthInstance } from "evlog/better-auth";
 
 export default defineNitroPlugin((nitroApp) => {
@@ -2656,9 +2509,9 @@ export default defineNitroPlugin((nitroApp) => {
 function getNuxtEvlogAuthMiddlewareFile(config) {
 	if (usesCreateAuthFactory(config)) {
 		const usesCloudflareRequestEnv = config.backend === "self" && config.webDeploy === "cloudflare";
-		const authExpression = usesCloudflareRequestEnv ? "createAuth((event.context.cloudflare as { env: CloudflareEnv }).env)" : getAuthExpression(config);
-		return `${getAuthImportLine(config)}
-${usesCloudflareRequestEnv ? `import type { CloudflareEnv } from "@${config.projectName}/env/server";\n` : ""}
+		const authExpression = usesCloudflareRequestEnv ? "(await createAuth((event.context.cloudflare as { env: CloudflareEnv }).env))" : getAuthExpression(config);
+		return `${getAuthImportLine(config, "../../src/services")}
+${usesCloudflareRequestEnv ? `import type { CloudflareEnv } from "../../src/env.server";\n` : ""}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 
 export default defineEventHandler(async (event) => {
@@ -2671,7 +2524,7 @@ export default defineEventHandler(async (event) => {
 });
 `;
 	}
-	return `${getAuthImportLine(config)}
+	return `${getAuthImportLine(config, "../../src/services")}
 import { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";
 
 const identify = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
@@ -2690,6 +2543,7 @@ function getTanstackNitroConfigFile(serviceName) {
 import evlog from "evlog/nitro/v3";
 
 export default defineConfig({
+  serverDir: "./server",
   experimental: {
     asyncContext: true,
   },
@@ -2701,24 +2555,26 @@ export default defineConfig({
 });
 `;
 }
-function getAstroMiddlewareFile(serviceName, fsDrain) {
+function getAstroMiddlewareFile(serviceName, fsDrain, axiom, cloudflare) {
 	return `import { defineMiddleware } from "astro:middleware";
 import { createRequestLogger, initLogger } from "evlog";
 ${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
+${axiom ? "import { createAxiomDrain } from \"evlog/axiom\";\n" : ""}
 
-${getInitLoggerSnippet(serviceName, fsDrain, "  ").trimEnd()}
+${getInitLoggerSnippet(serviceName, fsDrain, "  ", axiom).trimEnd()}
 
 export const onRequest = defineMiddleware(async ({ request, locals }, next) => {
   const url = new URL(request.url);
   const log = createRequestLogger({
     method: request.method,
     path: url.pathname,
-  });
+${cloudflare ? "    waitUntil: locals.cfContext.waitUntil.bind(locals.cfContext),\n" : ""}  });
 
   locals.log = log;
 
   try {
     const response = await next();
+    log.set({ status: response.status });
     log.emit();
     return response;
   } catch (error) {
@@ -2734,9 +2590,11 @@ function getAstroEnvFile() {
 
 import type { RequestLogger } from "evlog";
 
-declare namespace App {
-  interface Locals {
-    log: RequestLogger;
+declare global {
+  namespace App {
+    interface Locals {
+      log: RequestLogger;
+    }
   }
 }
 `;
@@ -2744,8 +2602,9 @@ declare namespace App {
 async function setupNextEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
 	const fsDrain = shouldWireEvlogWebFsDrain(config);
+	const axiom = usesAxiom(config);
 	const evlogPath = path.join(webDir, "src/lib/evlog.ts");
-	if (!await fs.pathExists(evlogPath)) await writeFileIfChanged(evlogPath, getNextEvlogFile(serviceName, fsDrain));
+	if (!await fs.pathExists(evlogPath)) await writeFileIfChanged(evlogPath, getNextEvlogFile(serviceName, fsDrain, axiom));
 	const identifyWebAuth = shouldIdentifyWebAuth(config);
 	if (identifyWebAuth) {
 		const evlogAuthPath = path.join(webDir, "src/lib/evlog-auth.ts");
@@ -2773,9 +2632,9 @@ async function setupNuxtEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
 	const fsDrain = shouldWireEvlogWebFsDrain(config);
 	await updateFileIfExists(path.join(webDir, "nuxt.config.ts"), (content) => addNuxtEvlogSetup(content, serviceName));
-	if (fsDrain) {
+	if (fsDrain || usesAxiom(config)) {
 		const drainPath = path.join(webDir, "server/plugins/evlog-drain.ts");
-		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile());
+		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile(usesAxiom(config), config.frontend.includes("tanstack-start")));
 	}
 	if (shouldIdentifyWebAuth(config)) {
 		const oldAuthPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
@@ -2790,28 +2649,53 @@ async function setupNuxtEvlog(config, serviceName) {
 async function setupSvelteEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
 	const fsDrain = shouldWireEvlogWebFsDrain(config);
+	const axiom = usesAxiom(config);
 	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, (content) => addSvelteHooksEvlogSetup(content, fsDrain));
+	if (await fs.pathExists(hooksPath)) await updateFileIfExists(hooksPath, (content) => addSvelteHooksEvlogSetup(content, fsDrain, axiom));
 	else await writeFileIfChanged(hooksPath, `import { createEvlogHooks } from "evlog/sveltekit";
 ${fsDrain ? "import { createFsDrain } from \"evlog/fs\";\n" : ""}
+${axiom ? "import { createAxiomDrain } from \"evlog/axiom\";\n" : ""}
 ${fsDrain ? "import { dev } from \"$app/environment\";\n" : ""}
 
-export const { handle, handleError } = ${getSvelteEvlogHooksCall(fsDrain)};
+export const { handle, handleError } = ${getSvelteEvlogHooksCall(fsDrain, axiom)};
 `);
 	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);
 }
+function getTanstackWorkersEvlogFile(config, serviceName) {
+	const identify = shouldIdentifyWebAuth(config);
+	return `import handler from "@tanstack/react-start/server-entry";
+import { initWorkersLogger, withEvlog } from "evlog/workers";
+import { createAxiomDrain } from "evlog/axiom";
+${identify ? `${getAuthImportLine(config, "./services")}\nimport { createAuthMiddleware, type BetterAuthInstance } from "evlog/better-auth";\n` : ""}
+initWorkersLogger({ env: { service: "${serviceName}" } });
+
+export default withEvlog(async (request${identify ? ", _env, _ctx, log" : ""}) => {
+${identify ? `  const identifyUser = createAuthMiddleware(${getAuthExpression(config)} as BetterAuthInstance, {
+    exclude: ["/api/auth/**"],
+    maskEmail: true,
+  });
+  await identifyUser(log, request.headers, new URL(request.url).pathname);
+` : ""}  return handler.fetch(request);
+}, { drain: createAxiomDrain() });
+`;
+}
 async function setupTanstackStartEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
 	const fsDrain = shouldWireEvlogWebFsDrain(config);
+	if (usesAxiom(config) && config.webDeploy === "cloudflare") {
+		await writeFileIfChanged(path.join(webDir, "src/server.ts"), getTanstackWorkersEvlogFile(config, serviceName));
+		if (config.examples.includes("ai")) await updateFileIfExists(path.join(webDir, "src/routes/api/ai/$.ts"), (content) => addAiSdkEvlogTelemetry(addNamedImport(content, "evlog", ["useLogger"]), "useLogger()"));
+		return;
+	}
 	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 (fsDrain) {
+	if (fsDrain || usesAxiom(config)) {
 		const drainPath = path.join(webDir, "server/plugins/evlog-drain.ts");
-		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile());
+		if (!await fs.pathExists(drainPath)) await writeFileIfChanged(drainPath, getNitroEvlogDrainFile(usesAxiom(config), config.frontend.includes("tanstack-start")));
 	}
 	if (shouldIdentifyWebAuth(config)) {
 		const authPluginPath = path.join(webDir, "server/plugins/evlog-auth.ts");
@@ -2822,12 +2706,17 @@ async function setupTanstackStartEvlog(config, serviceName) {
 async function setupAstroEvlog(config, serviceName) {
 	const webDir = path.join(config.projectDir, "apps/web");
 	const fsDrain = shouldWireEvlogWebFsDrain(config);
+	const axiom = usesAxiom(config);
 	const middlewarePath = path.join(webDir, "src/middleware.ts");
-	if (!await fs.pathExists(middlewarePath)) await writeFileIfChanged(middlewarePath, getAstroMiddlewareFile(serviceName, fsDrain));
-	else await updateFileIfExists(middlewarePath, (content) => addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain));
-	const envPath = path.join(webDir, "src/env.d.ts");
+	if (!await fs.pathExists(middlewarePath)) await writeFileIfChanged(middlewarePath, getAstroMiddlewareFile(serviceName, fsDrain, axiom, config.webDeploy === "cloudflare"));
+	else await updateFileIfExists(middlewarePath, (content) => addAstroMiddlewareEvlogSetup(content, serviceName, fsDrain, axiom, config.webDeploy === "cloudflare"));
+	const envPath = path.join(webDir, "src/locals.d.ts");
 	if (!await fs.pathExists(envPath)) await writeFileIfChanged(envPath, getAstroEnvFile());
 	else await updateFileIfExists(envPath, addAstroLocalsType);
+	if (config.webDeploy === "cloudflare") await updateFileIfExists(envPath, (content) => {
+		if (content.includes("cfContext:")) return content;
+		return `/// <reference types="@cloudflare/workers-types" />\n${content.replace("interface Locals {", "interface Locals {\n      cfContext: ExecutionContext;")}`;
+	});
 	if (shouldIdentifyWebAuth(config)) await updateFileIfExists(middlewarePath, (content) => addAstroBetterAuthEvlogSetup(content, config));
 }
 async function setupEvlogWeb(config) {
@@ -2847,7 +2736,7 @@ async function setupEvlog(config) {
 				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`, shouldWireEvlogServerFsDrain(config));
+					let nextContent = addEvlogServerSetup(content, config.backend, `${config.projectName}-server`, shouldWireEvlogServerFsDrain(config), usesAxiom(config));
 					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);
@@ -4081,7 +3970,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");
+	if (addons.includes("evlog") || addons.includes("axiom")) sources.push("https://www.evlog.dev");
 	return sources;
 }
 const CURATED_SKILLS_BY_SOURCE = {
@@ -4597,7 +4486,7 @@ const HOOKS = {
 	claude: { label: "Claude Code" },
 	copilot: { label: "GitHub Copilot" }
 };
-const ULTRACITE_VERSION = "7.10.7";
+const ULTRACITE_VERSION = "7.11.0";
 const DEFAULT_LINTER = "biome";
 const DEFAULT_EDITORS = ["vscode"];
 const DEFAULT_AGENTS = ["universal"];
@@ -4657,73 +4546,75 @@ async function setupUltracite(config, gitHooks) {
 	let editors = configuredOptions?.editors;
 	let agents = configuredOptions?.agents;
 	let hooks = configuredOptions?.hooks;
-	if (!linter || !editors || !agents || !hooks) if (isSilent()) {
-		linter = linter ?? DEFAULT_LINTER;
-		editors = editors ?? [...DEFAULT_EDITORS];
-		agents = agents ?? [...DEFAULT_AGENTS];
-		hooks = hooks ?? [...DEFAULT_HOOKS];
-	} else {
-		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
-				});
-			},
-			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"
-						},
-						{
-							value: "universal",
-							label: "Universal (.vscode/settings.json)"
-						}
-					]
-				});
-			},
-			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 (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;
+	if (!linter || !editors || !agents || !hooks) {
+		if (isSilent()) {
+			linter = linter ?? DEFAULT_LINTER;
+			editors = editors ?? [...DEFAULT_EDITORS];
+			agents = agents ?? [...DEFAULT_AGENTS];
+			hooks = hooks ?? [...DEFAULT_HOOKS];
+		} else {
+			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
+					});
+				},
+				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"
+							},
+							{
+								value: "universal",
+								label: "Universal (.vscode/settings.json)"
+							}
+						]
+					});
+				},
+				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 (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({
@@ -4796,20 +4687,22 @@ async function setupWxt(config) {
 	cliLog.info("Setting up WXT...");
 	const configuredOptions = config.addonOptions?.wxt;
 	let template = configuredOptions?.template;
-	if (!template) if (isSilent()) template = DEFAULT_TEMPLATE;
-	else {
-		setIsFirstPrompt(true);
-		const selectedTemplate = await navigableSelect({
-			message: "Choose a template",
-			options: Object.entries(TEMPLATES).map(([key, templateOption]) => ({
-				value: key,
-				label: templateOption.label,
-				hint: templateOption.hint
-			})),
-			initialValue: DEFAULT_TEMPLATE
-		});
-		if (isCancel$1(selectedTemplate)) return userCancelled("Operation cancelled");
-		template = selectedTemplate;
+	if (!template) {
+		if (isSilent()) template = DEFAULT_TEMPLATE;
+		else {
+			setIsFirstPrompt(true);
+			const selectedTemplate = await navigableSelect({
+				message: "Choose a template",
+				options: Object.entries(TEMPLATES).map(([key, templateOption]) => ({
+					value: key,
+					label: templateOption.label,
+					hint: templateOption.hint
+				})),
+				initialValue: DEFAULT_TEMPLATE
+			});
+			if (isCancel$1(selectedTemplate)) return userCancelled("Operation cancelled");
+			template = selectedTemplate;
+		}
 	}
 	const devPort = configuredOptions?.devPort ?? DEFAULT_DEV_PORT;
 	const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
@@ -4909,7 +4802,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));
+	if (addons.includes("evlog") || addons.includes("axiom")) await runSetup(() => setupEvlog(config));
 }
 async function setupBiome(projectDir) {
 	await addPackageDependency({
@@ -4953,30 +4846,39 @@ async function setupLefthook(projectDir) {
 }
 //#endregion
 //#region src/helpers/core/detect-project-config.ts
+const packageIdentitySchema = z.object({ name: z.string().optional() });
 async function detectProjectConfig(projectDir) {
+	projectDir = path.resolve(projectDir);
 	const result = await Result.tryPromise({
 		try: async () => {
 			const btsConfig = await readBtsConfig(projectDir);
-			if (btsConfig) return {
-				projectDir,
-				projectName: path.basename(projectDir),
-				addonOptions: btsConfig.addonOptions,
-				dbSetupOptions: btsConfig.dbSetupOptions,
-				database: btsConfig.database,
-				orm: btsConfig.orm,
-				backend: btsConfig.backend,
-				runtime: btsConfig.runtime,
-				frontend: btsConfig.frontend,
-				addons: btsConfig.addons,
-				examples: btsConfig.examples,
-				auth: btsConfig.auth,
-				payments: btsConfig.payments,
-				packageManager: btsConfig.packageManager,
-				dbSetup: btsConfig.dbSetup,
-				api: btsConfig.api,
-				webDeploy: btsConfig.webDeploy,
-				serverDeploy: btsConfig.serverDeploy
-			};
+			if (btsConfig) {
+				const configPackagePath = path.join(projectDir, "packages/config/package.json");
+				const configPackage = await fs.pathExists(configPackagePath) ? packageIdentitySchema.parse(await fs.readJson(configPackagePath)) : void 0;
+				const rootPackagePath = path.join(projectDir, "package.json");
+				const rootPackage = await fs.pathExists(rootPackagePath) ? packageIdentitySchema.parse(await fs.readJson(rootPackagePath)) : void 0;
+				const scope = configPackage?.name ? /^@([^/]+)\/config$/.exec(configPackage.name)?.[1] : void 0;
+				return {
+					projectDir,
+					projectName: scope || rootPackage?.name || path.basename(projectDir),
+					addonOptions: btsConfig.addonOptions,
+					dbSetupOptions: btsConfig.dbSetupOptions,
+					database: btsConfig.database,
+					orm: btsConfig.orm,
+					backend: btsConfig.backend,
+					runtime: btsConfig.runtime,
+					frontend: btsConfig.frontend,
+					addons: btsConfig.addons,
+					examples: btsConfig.examples,
+					auth: btsConfig.auth,
+					payments: btsConfig.payments,
+					packageManager: btsConfig.packageManager,
+					dbSetup: btsConfig.dbSetup,
+					api: btsConfig.api,
+					webDeploy: btsConfig.webDeploy,
+					serverDeploy: btsConfig.serverDeploy
+				};
+			}
 			return null;
 		},
 		catch: () => null
@@ -4987,7 +4889,7 @@ async function detectProjectConfig(projectDir) {
 //#region src/helpers/core/install-dependencies.ts
 const FORCE_KILL_AFTER_MS = 2e3;
 async function installDependencies({ projectDir, packageManager }) {
-	if (shouldSkipExternalCommands()) return Result.ok("installed");
+	if (shouldSkipExternalCommands()) return Result.ok("skipped");
 	startInterruptibleStep();
 	const s = createSpinner();
 	s.start(`Running ${packageManager} install...`);
@@ -5036,7 +4938,14 @@ const ADD_PACKAGE_JSON_PATHS = [
 	"packages/infra/package.json",
 	"packages/ui/package.json"
 ];
-const ADD_TEXT_FILE_PATHS = ["apps/web/vite.config.ts", "lefthook.yml"];
+const ADD_TEXT_FILE_PATHS = [
+	"apps/web/vite.config.ts",
+	"apps/web/next.config.ts",
+	"apps/web/src/Document.tsx",
+	"apps/web/src/root.tsx",
+	"apps/web/src/app/layout.tsx",
+	"lefthook.yml"
+];
 const HOOK_ADDONS = ["husky", "lefthook"];
 const HOOK_LINTER_ADDONS = [
 	"biome",
@@ -5197,12 +5106,13 @@ async function reportAddOutcome(input, result) {
 	});
 }
 async function addHandlerInternal(input) {
-	const projectDir = input.projectDir || process.cwd();
-	const hardeningResult = validateAgentSafePathInput(projectDir, "projectDir");
+	const projectDirInput = input.projectDir || process.cwd();
+	const hardeningResult = validateAgentSafePathInput(projectDirInput, "projectDir");
 	if (hardeningResult.isErr()) return Result.err(new CLIError({
 		message: hardeningResult.error.message,
 		cause: hardeningResult.error
 	}));
+	const projectDir = path.resolve(projectDirInput);
 	if (!isSilent()) {
 		renderTitle();
 		intro(pc.magenta("Add to your project"));
@@ -5249,6 +5159,7 @@ async function addHandlerInternal(input) {
 		}
 		addonsToAdd = selectedAddons;
 	}
+	if (addonsToAdd.includes("axiom")) return Result.err(new CLIError({ message: "Axiom must be selected during project creation because it configures Alchemy infrastructure and deployment bindings." }));
 	const updatedAddons = [...existingConfig.addons, ...addonsToAdd];
 	const addonsValidationResult = validateAddonsAgainstConfig(updatedAddons, existingConfig);
 	if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
@@ -5311,10 +5222,21 @@ async function addHandlerInternal(input) {
 		}
 		await processAddonTemplates(vfs, EMBEDDED_TEMPLATES, config);
 		processAddonsDeps(vfs, config);
+		processPwaPlugins(vfs, config);
 		if (addonsToAdd.includes("turborepo")) processTurboConfig(vfs, updatedConfig);
 		if (addonsToAdd.includes("nx")) processNxConfig(vfs, updatedConfig);
 		if (addonsToAdd.includes("vite-plus")) processVitePlusConfig(vfs, updatedConfig);
-		if (updatedAddons.some((addon) => TASK_RUNNER_ADDONS.includes(addon))) processPackageConfigs(vfs, updatedConfig);
+		if (updatedAddons.some((addon) => TASK_RUNNER_ADDONS$1.includes(addon)) || addonsToAdd.includes("electrobun")) {
+			const existingNames = new Map(ADD_PACKAGE_JSON_PATHS.map((filePath) => [filePath, vfs.readJson(filePath)?.name]));
+			processPackageConfigs(vfs, updatedConfig);
+			for (const [filePath, name] of existingNames) if (name) {
+				const pkg = vfs.readJson(filePath);
+				if (pkg) vfs.writeJson(filePath, {
+					...pkg,
+					name
+				});
+			}
+		}
 		if (updatedAddons.includes("vite-plus")) updateViteConfigImportsForVitePlus(vfs);
 		if (shouldRefreshLefthook(addonsToAdd, updatedAddons)) refreshLefthookTemplate(vfs, updatedConfig);
 	}
@@ -5380,10 +5302,13 @@ async function addHandlerInternal(input) {
 		}
 	});
 	if (setupResult.isErr()) return Result.err(setupResult.error);
-	if (addonsToAdd.length > 0) await updateBtsConfig(projectDir, {
-		addons: updatedAddons,
-		addonOptions: updatedConfig.addonOptions
-	});
+	if (addonsToAdd.length > 0) {
+		const configResult = await updateBtsConfig(projectDir, {
+			addons: updatedAddons,
+			addonOptions: updatedConfig.addonOptions
+		});
+		if (configResult.isErr()) return Result.err(configResult.error);
+	}
 	if (input.install) await installDependencies({
 		projectDir,
 		packageManager: config.packageManager
@@ -5457,7 +5382,7 @@ function resolveProjectDbSetupOptions(config, cliOptions = {}) {
 //#region src/prompts/api.ts
 async function getApiChoice(Api, frontend, backend, previousValue) {
 	if (backend === "convex" || backend === "none") return "none";
-	const allowed = allowedApisForFrontends(frontend ?? []);
+	const allowed = allowedApisForFrontends$1(frontend ?? []);
 	if (Api) {
 		const compat = validateApiFrontendCompatibility(Api, frontend ?? []);
 		if (compat.isErr()) throw compat.error;
@@ -5488,20 +5413,11 @@ async function getApiChoice(Api, frontend, backend, previousValue) {
 //#region src/prompts/auth.ts
 function getAvailableAuthProviders(backend, frontend = []) {
 	if (backend === "none") return ["none"];
-	const hasClerkCompatibleFrontends = frontend.some((f) => [
-		"react-router",
-		"tanstack-router",
-		"tanstack-start",
-		"next",
-		"native-bare",
-		"native-uniwind",
-		"native-unistyles"
-	].includes(f));
 	const options = [];
 	if (backend === "convex") {
-		if (supportsConvexBetterAuth(frontend)) options.push("better-auth");
+		if (supportsConvexBetterAuth(frontend) && frontend.every((f) => isFrontendAllowedWithBackend(f, backend, "better-auth"))) options.push("better-auth");
 	} else options.push("better-auth");
-	if (hasClerkCompatibleFrontends) options.push("clerk");
+	if (supportsClerkFrontend(frontend) && supportsClerkBackend(backend, frontend)) options.push("clerk");
 	if (options.length === 0) return ["none"];
 	return [...options, "none"];
 }
@@ -5538,7 +5454,7 @@ async function getAuthChoice(auth, backend, frontend = [], previousValue) {
 }
 //#endregion
 //#region src/prompts/backend.ts
-const FULLSTACK_FRONTENDS = [
+const FULLSTACK_FRONTENDS$1 = [
 	"next",
 	"tanstack-start",
 	"nuxt",
@@ -5549,7 +5465,7 @@ const FULLSTACK_FRONTENDS = [
 async function getBackendFrameworkChoice(backendFramework, frontends, previousValue) {
 	if (backendFramework !== void 0) return backendFramework;
 	const hasIncompatibleFrontend = frontends?.some((f) => f === "solid" || f === "astro");
-	const hasFullstackFrontend = frontends?.some((f) => FULLSTACK_FRONTENDS.includes(f));
+	const hasFullstackFrontend = frontends?.some((f) => FULLSTACK_FRONTENDS$1.includes(f));
 	const backendOptions = [];
 	if (hasFullstackFrontend) backendOptions.push({
 		value: "self",
@@ -5618,7 +5534,7 @@ async function getDatabaseChoice(database, backend, runtime, previousValue) {
 			hint: "popular open-source relational database system"
 		}
 	];
-	if (runtime !== "workers") databaseOptions.push({
+	if (supportsRuntimeDatabase(runtime, "mongodb")) databaseOptions.push({
 		value: "mongodb",
 		label: "MongoDB",
 		hint: "open-source NoSQL database that stores data in JSON-like documents called BSON"
@@ -5637,25 +5553,17 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime, p
 	if (backend === "convex") return "none";
 	if (dbSetup !== void 0) return dbSetup;
 	if (databaseType === "none") return "none";
-	let options = [];
-	if (databaseType === "sqlite") options = [
+	const options = [
 		{
 			value: "turso",
 			label: "Turso",
 			hint: "SQLite for Production. Powered by libSQL"
 		},
-		...runtime === "workers" || backend === "self" ? [{
+		{
 			value: "d1",
 			label: "Cloudflare D1",
 			hint: "Cloudflare's managed, serverless database with SQLite's SQL semantics"
-		}] : [],
-		{
-			value: "none",
-			label: "None",
-			hint: "Manual setup"
-		}
-	];
-	else if (databaseType === "postgres") options = [
+		},
 		{
 			value: "neon",
 			label: "Neon Postgres",
@@ -5676,35 +5584,6 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime, p
 			label: "Prisma Postgres",
 			hint: "Instant Postgres for Global Applications"
 		},
-		{
-			value: "docker",
-			label: "Docker",
-			hint: "Run locally with docker compose"
-		},
-		{
-			value: "none",
-			label: "None",
-			hint: "Manual setup"
-		}
-	];
-	else if (databaseType === "mysql") options = [
-		{
-			value: "planetscale",
-			label: "PlanetScale",
-			hint: "MySQL on Vitess (NVMe, HA)"
-		},
-		{
-			value: "docker",
-			label: "Docker",
-			hint: "Run locally with docker compose"
-		},
-		{
-			value: "none",
-			label: "None",
-			hint: "Manual setup"
-		}
-	];
-	else if (databaseType === "mongodb") options = [
 		{
 			value: "mongodb-atlas",
 			label: "MongoDB Atlas",
@@ -5720,8 +5599,7 @@ async function getDBSetupChoice(databaseType, dbSetup, _orm, backend, runtime, p
 			label: "None",
 			hint: "Manual setup"
 		}
-	];
-	else return "none";
+	].filter(({ value }) => supportsDatabaseSetup(value, databaseType) && supportsDatabaseSetupRuntime(value, runtime, backend));
 	const response = await navigableSelect({
 		message: `Choose a ${databaseType} setup`,
 		options,
@@ -5744,8 +5622,8 @@ async function getDbProvisioningChoice(mode, dbSetup, backend, webDeploy, server
 		serverDeploy
 	})) return mode === "alchemy" ? void 0 : mode;
 	if (mode !== void 0) return mode;
+	if (dbSetup !== "neon" && dbSetup !== "planetscale" && dbSetup !== "prisma-postgres") return;
 	const provider = providerLabels[dbSetup];
-	if (!provider) return void 0;
 	const options = [
 		{
 			value: "alchemy",
@@ -5778,12 +5656,12 @@ async function getExamplesChoice(examples, database, frontends, backend, api, pr
 	if (backend === "none") return [];
 	let response = [];
 	const options = [];
-	if (isExampleTodoAllowed(backend, database, api)) options.push({
+	if (isExampleTodoAllowed$1(backend, database, api)) options.push({
 		value: "todo",
 		label: "Todo App",
 		hint: "A simple CRUD example app"
 	});
-	if (isExampleAIAllowed(backend, frontends ?? [])) options.push({
+	if (isExampleAIAllowed$1(backend, frontends ?? [])) options.push({
 		value: "ai",
 		label: "AI Chat",
 		hint: "A simple AI chat interface using AI SDK"
@@ -5877,7 +5755,7 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 					label: "TanStack Start",
 					hint: "SSR, Server Functions, API Routes and more with TanStack Router"
 				}
-			].filter((option) => isFrontendAllowedWithBackend(option.value, backend, auth));
+			].filter((option) => isFrontendAllowedWithBackend$1(option.value, backend, auth));
 			const webFramework = await navigableSelect({
 				message: "Choose a web framework",
 				options: webOptions,
@@ -5913,12 +5791,13 @@ async function getFrontendChoice(frontendOptions, backend, auth, previousValue)
 				],
 				initialValue: previousNative ?? "native-bare"
 			});
-			if (isGoBack(nativeFramework)) if (frontendTypes.includes("web")) shouldRestart = true;
-			else {
-				setIsFirstPrompt(wasFirstPrompt);
-				continue;
-			}
-			else if (isCancel$1(nativeFramework)) throw new UserCancelledError({ message: "Operation cancelled" });
+			if (isGoBack(nativeFramework)) {
+				if (frontendTypes.includes("web")) shouldRestart = true;
+				else {
+					setIsFirstPrompt(wasFirstPrompt);
+					continue;
+				}
+			} else if (isCancel$1(nativeFramework)) throw new UserCancelledError({ message: "Operation cancelled" });
 			else result.push(nativeFramework);
 		}
 		if (shouldRestart) {
@@ -5974,12 +5853,11 @@ function canResolveSelfCloudflareD1Target(config) {
 * prompt).
 */
 function validateOrmDatabaseCompat(orm, database) {
-	if (orm === "mongoose" && database && database !== "mongodb") return validationErr("Mongoose ORM requires MongoDB database. Please use '--database mongodb' or choose a different ORM.");
+	if (!orm || !database || supportsOrmDatabase(orm, database)) return Result.ok(void 0);
+	if (orm === "mongoose") return validationErr("Mongoose ORM requires MongoDB database. Please use '--database mongodb' or choose a different ORM.");
 	if (orm === "drizzle" && database === "mongodb") return validationErr("Drizzle ORM does not support MongoDB. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
-	if (database === "mongodb" && orm && orm !== "mongoose" && orm !== "prisma" && orm !== "none") return validationErr("MongoDB database requires Mongoose or Prisma ORM. Please use '--orm mongoose' or '--orm prisma' or choose a different database.");
-	if (database && database !== "none" && orm === "none") return validationErr("Database selection requires an ORM. Please choose '--orm drizzle', '--orm prisma', or '--orm mongoose'.");
-	if (orm && orm !== "none" && database === "none") return validationErr("ORM selection requires a database. Please choose a database or set '--orm none'.");
-	return Result.ok(void 0);
+	if (orm === "none") return validationErr("Database selection requires an ORM. Please choose '--orm drizzle', '--orm prisma', or '--orm mongoose'.");
+	return validationErr("ORM selection requires a database. Please choose a database or set '--orm none'.");
 }
 function validateDatabaseOrmAuth(cfg, flags) {
 	const has = (k) => flags ? flags.has(k) : true;
@@ -5990,40 +5868,19 @@ function validateDatabaseSetup(config, providedFlags) {
 	const { dbSetup, database, runtime } = config;
 	if (providedFlags.has("dbSetup") && providedFlags.has("database") && dbSetup && dbSetup !== "none" && database === "none") return validationErr("Database setup requires a database. Please choose a database or set '--db-setup none'.");
 	const setupValidations = {
-		turso: {
-			database: "sqlite",
-			errorMessage: "Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup."
-		},
-		neon: {
-			database: "postgres",
-			errorMessage: "Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
-		},
-		"prisma-postgres": {
-			database: "postgres",
-			errorMessage: "Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
-		},
+		turso: { errorMessage: "Turso setup requires SQLite database. Please use '--database sqlite' or choose a different setup." },
+		neon: { errorMessage: "Neon setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup." },
+		"prisma-postgres": { errorMessage: "Prisma PostgreSQL setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup." },
 		planetscale: { errorMessage: "PlanetScale setup requires PostgreSQL or MySQL database. Please use '--database postgres' or '--database mysql' or choose a different setup." },
-		"mongodb-atlas": {
-			database: "mongodb",
-			errorMessage: "MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup."
-		},
-		supabase: {
-			database: "postgres",
-			errorMessage: "Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup."
-		},
-		d1: {
-			database: "sqlite",
-			errorMessage: "Cloudflare D1 setup requires SQLite database."
-		},
+		"mongodb-atlas": { errorMessage: "MongoDB Atlas setup requires MongoDB database. Please use '--database mongodb' or choose a different setup." },
+		supabase: { errorMessage: "Supabase setup requires PostgreSQL database. Please use '--database postgres' or choose a different setup." },
+		d1: { errorMessage: "Cloudflare D1 setup requires SQLite database." },
 		docker: { errorMessage: "Docker setup is not compatible with SQLite database or Cloudflare Workers runtime." },
 		none: { errorMessage: "" }
 	};
 	if (dbSetup && dbSetup !== "none") {
 		const validation = setupValidations[dbSetup];
-		if (dbSetup === "planetscale") {
-			if (database !== "postgres" && database !== "mysql") return validationErr(validation.errorMessage);
-		} else if ("database" in validation && validation.database && database !== validation.database) return validationErr(validation.errorMessage);
-		if ("runtime" in validation && validation.runtime && runtime !== validation.runtime) return validationErr(validation.errorMessage);
+		if (dbSetup !== "docker" && !supportsDatabaseSetup(dbSetup, database)) return validationErr(validation.errorMessage);
 		if (dbSetup === "d1") {
 			const isWorkersTarget = hasResolvedWorkersD1Target(config);
 			const isSelfCloudflareTarget = hasResolvedSelfCloudflareD1Target(config);
@@ -6032,8 +5889,8 @@ function validateDatabaseSetup(config, providedFlags) {
 			if (!isWorkersTarget && !isSelfCloudflareTarget && !canResolveWorkersTarget && !canResolveSelfCloudflareTarget) return validationErr("Cloudflare D1 setup requires SQLite database and either Cloudflare Workers runtime with server deployment or backend 'self' with Cloudflare web deployment.");
 		}
 		if (dbSetup === "docker") {
-			if (database === "sqlite") return validationErr("Docker setup is not compatible with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
-			if (runtime === "workers") return validationErr("Docker setup is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
+			if (database && !supportsDatabaseSetup(dbSetup, database)) return validationErr("Docker setup is not compatible with SQLite database. SQLite is file-based and doesn't require Docker. Please use '--database postgres', '--database mysql', '--database mongodb', or choose a different setup.");
+			if (!supportsDatabaseSetupRuntime(dbSetup, runtime, config.backend)) return validationErr("Docker setup is not compatible with Cloudflare Workers runtime. Workers runtime uses serverless databases (D1) and doesn't support local Docker containers. Please use '--db-setup d1' for SQLite or choose a different runtime.");
 		}
 	}
 	return Result.ok(void 0);
@@ -6056,12 +5913,8 @@ function validateConvexConstraints(config, providedFlags) {
 	const { backend } = config;
 	if (backend !== "convex") return Result.ok(void 0);
 	const has = (k) => providedFlags.has(k);
-	if (has("runtime") && config.runtime !== "none") return validationErr("Convex backend requires '--runtime none'. Please remove the --runtime flag or set it to 'none'.");
-	if (has("database") && config.database !== "none") return validationErr("Convex backend requires '--database none'. Please remove the --database flag or set it to 'none'.");
-	if (has("orm") && config.orm !== "none") return validationErr("Convex backend requires '--orm none'. Please remove the --orm flag or set it to 'none'.");
-	if (has("api") && config.api !== "none") return validationErr("Convex backend requires '--api none'. Please remove the --api flag or set it to 'none'.");
-	if (has("dbSetup") && config.dbSetup !== "none") return validationErr("Convex backend requires '--db-setup none'. Please remove the --db-setup flag or set it to 'none'.");
-	if (has("serverDeploy") && config.serverDeploy !== "none") return validationErr("Convex backend requires '--server-deploy none'. Please remove the --server-deploy flag or set it to 'none'.");
+	const disabled = validateBackendDisabledOptions(config, providedFlags);
+	if (disabled.isErr()) return disabled;
 	if (has("auth") && config.auth === "better-auth") {
 		const incompatibleFrontends = config.frontend?.filter((f) => CONVEX_BETTER_AUTH_INCOMPATIBLE_FRONTENDS.includes(f)) ?? [];
 		const hasSupportedFrontend = supportsConvexBetterAuth(config.frontend);
@@ -6070,43 +5923,36 @@ function validateConvexConstraints(config, providedFlags) {
 	}
 	return Result.ok(void 0);
 }
-function validateBackendNoneConstraints(config, providedFlags) {
-	const { backend } = config;
-	if (backend !== "none") return Result.ok(void 0);
-	const has = (k) => providedFlags.has(k);
-	if (has("runtime") && config.runtime !== "none") return validationErr("Backend 'none' requires '--runtime none'. Please remove the --runtime flag or set it to 'none'.");
-	if (has("database") && config.database !== "none") return validationErr("Backend 'none' requires '--database none'. Please remove the --database flag or set it to 'none'.");
-	if (has("orm") && config.orm !== "none") return validationErr("Backend 'none' requires '--orm none'. Please remove the --orm flag or set it to 'none'.");
-	if (has("api") && config.api !== "none") return validationErr("Backend 'none' requires '--api none'. Please remove the --api flag or set it to 'none'.");
-	if (has("auth") && config.auth !== "none") return validationErr("Backend 'none' requires '--auth none'. Please remove the --auth flag or set it to 'none'.");
-	if (has("payments") && config.payments !== "none") return validationErr("Backend 'none' requires '--payments none'. Please remove the --payments flag or set it to 'none'.");
-	if (has("dbSetup") && config.dbSetup !== "none") return validationErr("Backend 'none' requires '--db-setup none'. Please remove the --db-setup flag or set it to 'none'.");
-	if (has("serverDeploy") && config.serverDeploy !== "none") return validationErr("Backend 'none' requires '--server-deploy none'. Please remove the --server-deploy flag or set it to 'none'.");
+function validateBackendDisabledOptions(config, providedFlags) {
+	if (!config.backend) return Result.ok(void 0);
+	for (const key of getBackendDisabledOptions(config.backend)) {
+		if (!providedFlags.has(key) || config[key] === "none") continue;
+		const flag = key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+		return validationErr(`${config.backend === "convex" ? "Convex backend" : `Backend '${config.backend}'${config.backend === "self" ? " (fullstack)" : ""}`} requires '--${flag} none'. Please remove the --${flag} flag or set it to 'none'.`);
+	}
 	return Result.ok(void 0);
 }
+function validateBackendNoneConstraints(config, providedFlags) {
+	return config.backend === "none" ? validateBackendDisabledOptions(config, providedFlags) : Result.ok(void 0);
+}
 function validateSelfBackendConstraints(config, providedFlags) {
-	const { backend } = config;
-	if (backend !== "self") return Result.ok(void 0);
-	const has = (k) => providedFlags.has(k);
-	if (has("runtime") && config.runtime !== "none") return validationErr("Backend 'self' (fullstack) requires '--runtime none'. Please remove the --runtime flag or set it to 'none'.");
-	return Result.ok(void 0);
+	return config.backend === "self" ? validateBackendDisabledOptions(config, providedFlags) : Result.ok(void 0);
 }
 function validateBackendConstraints(config, providedFlags, options) {
 	const { backend } = config;
 	if (config.auth === "clerk" && config.frontend) {
-		const incompatibleFrontends = config.frontend.filter((f) => [
-			"nuxt",
-			"svelte",
-			"solid",
-			"astro"
-		].includes(f));
+		const incompatibleFrontends = config.frontend.filter((f) => !isFrontendAllowedWithBackend(f, void 0, "clerk"));
 		if (incompatibleFrontends.length > 0) return validationErr(`Clerk authentication is not compatible with the following frontends: ${incompatibleFrontends.join(", ")}. Please choose a different frontend or auth provider.`);
 	}
-	if (providedFlags.has("backend") && backend && backend !== "convex" && backend !== "none" && backend !== "self") {
+	if (config.auth === "clerk") {
+		if (!supportsClerkBackend(backend, config.frontend)) return validationErr("Clerk requires Convex, a separate server, or backend self with Next.js or TanStack Start.");
+		if (config.frontend && !supportsClerkFrontend(config.frontend)) return validationErr("Clerk requires a React web or native frontend.");
+	}
+	if (providedFlags.has("backend") && backend && !supportsRuntimeBackend("none", backend)) {
 		if (providedFlags.has("runtime") && options.runtime === "none") return validationErr("'--runtime none' is only supported with '--backend convex', '--backend none', or '--backend self'. Please choose 'bun', 'node', or remove the --runtime flag.");
 	}
 	if (backend === "convex" && providedFlags.has("frontend") && options.frontend) {
-		const incompatibleFrontends = options.frontend.filter((f) => f === "solid" || f === "astro");
+		const incompatibleFrontends = options.frontend.filter((frontend) => !isFrontendAllowedWithBackend(frontend, "convex"));
 		if (incompatibleFrontends.length > 0) return validationErr(`The following frontends are not compatible with '--backend convex': ${incompatibleFrontends.join(", ")}. Please choose a different frontend or backend.`);
 	}
 	return Result.ok(void 0);
@@ -6154,7 +6000,7 @@ function validateFullConfig(config, providedFlags, options) {
 		yield* validateSelfBackendCompatibility(providedFlags, options, config);
 		yield* validateWorkersCompatibility(providedFlags, options, config);
 		if (config.runtime === "workers" && config.serverDeploy === "none") yield* validationErr("Cloudflare Workers runtime requires a server deployment. Please choose 'cloudflare' for --server-deploy.");
-		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 (providedFlags.has("serverDeploy") && config.serverDeploy === "cloudflare" && !supportsServerDeployRuntime(config.serverDeploy, config.runtime)) 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, config.backend, config.runtime);
 			config.addons = [...new Set(config.addons)];
@@ -6202,7 +6048,11 @@ async function getORMChoice(orm, hasDatabase, database, backend, runtime, previo
 		if (compat.isErr()) throw compat.error;
 		return orm;
 	}
-	const options = database === "mongodb" ? [ormOptions.prisma, ormOptions.mongoose] : [ormOptions.drizzle, ormOptions.prisma];
+	const options = [
+		ormOptions.drizzle,
+		ormOptions.prisma,
+		ormOptions.mongoose
+	].filter((option) => supportsOrmDatabase(option.value, database ?? "sqlite"));
 	const response = await navigableSelect({
 		message: "Choose an ORM",
 		options,
@@ -6266,7 +6116,7 @@ async function getPaymentsChoice(payments, auth, backend, _frontends, previousVa
 //#endregion
 //#region src/prompts/runtime.ts
 async function getRuntimeChoice(runtime, backend, previousValue) {
-	if (backend === "convex" || backend === "none" || backend === "self") return "none";
+	if (backend && supportsRuntimeBackend("none", backend)) return "none";
 	if (runtime !== void 0) return runtime;
 	const runtimeOptions = [{
 		value: "bun",
@@ -6277,7 +6127,7 @@ async function getRuntimeChoice(runtime, backend, previousValue) {
 		label: "Node.js",
 		hint: "Traditional Node.js runtime"
 	}];
-	if (backend === "hono") runtimeOptions.push({
+	if (backend && supportsRuntimeBackend("workers", backend)) runtimeOptions.push({
 		value: "workers",
 		label: "Cloudflare Workers",
 		hint: "Edge runtime on Cloudflare's global network"
@@ -6380,7 +6230,7 @@ async function getDeploymentChoice(deployment, _runtime, backend, frontend = [],
 	if (deployment !== void 0) return deployment;
 	if (!hasWebFrontend(frontend)) return "none";
 	if (backend === "self" && dbSetup === "d1") return "cloudflare";
-	const supportsPrismaCompute = supportsPrismaWebDeploy(frontend);
+	const supportsPrismaCompute = supportsPrismaWebDeploy$1(frontend);
 	const options = [
 		...validateCloudflareWebDeployKnownIssues({
 			webDeploy: "cloudflare",
@@ -6581,7 +6431,7 @@ async function getProjectName(initialName) {
 			}
 		});
 		if (isCancel(response)) throw new UserCancelledError({ message: "Operation cancelled." });
-		projectPath = response || defaultName;
+		projectPath = types_exports.ProjectNameSchema.parse(response || defaultName);
 		isValid = true;
 	}
 	return projectPath;
@@ -7400,6 +7250,21 @@ const formatOptions = {
 	experimentalSortPackageJson: true,
 	experimentalSortImports: { order: "asc" }
 };
+const ignoredDirectories = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".svelte-kit",
+	".astro",
+	".turbo",
+	".vercel",
+	".wrangler",
+	"dist",
+	"build",
+	"coverage"
+]);
 async function formatCode(filePath, content) {
 	const result = await Result.tryPromise({
 		try: async () => {
@@ -7420,8 +7285,10 @@ async function formatProject(projectDir, signal) {
 				await Promise.all(entries.map(async (entry) => {
 					if (signal?.aborted) return;
 					const fullPath = path.join(dir, entry.name);
-					if (entry.isDirectory()) await formatDirectory(fullPath);
-					else if (entry.isFile()) await Result.tryPromise({
+					if (entry.isDirectory()) {
+						if (ignoredDirectories.has(entry.name)) return;
+						await formatDirectory(fullPath);
+					} else if (entry.isFile()) await Result.tryPromise({
 						try: async () => {
 							const content = await fs.readFile(fullPath, "utf-8");
 							const formatted = await formatCode(fullPath, content);
@@ -7483,9 +7350,10 @@ async function setupCloudflareD1(config) {
 				condition: true
 			}]);
 			await fs.ensureFile(path.join(projectDir, "packages/db/local.db"));
+			const serverDir = path.join(projectDir, backend === "self" ? "apps/web" : "apps/server");
 			await addPackageDependency({
 				dependencies: ["@prisma/adapter-d1"],
-				projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
+				projectDir: serverDir
 			});
 		},
 		catch: (e) => new DatabaseSetupError({
@@ -7651,7 +7519,7 @@ async function setupMongoDBAtlas(config, cliInput) {
 			initialValue: "auto"
 		});
 		if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
-		mode = promptedMode;
+		mode = types_exports.DbSetupModeSchema.parse(promptedMode);
 	}
 	if (mode === "manual") {
 		cliLog.info("MongoDB Atlas manual setup selected");
@@ -7845,23 +7713,25 @@ async function setupNeonPostgres(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	let selectedMode = setupMode;
-	if (!selectedMode) if (isSilent()) selectedMode = "manual";
-	else {
-		const promptedMode = await select({
-			message: "Neon setup: choose mode",
-			options: [{
-				label: "Automatic",
-				value: "auto",
-				hint: "Automated setup with provider CLI, sets .env"
-			}, {
-				label: "Manual",
-				value: "manual",
-				hint: "Manual setup, add env vars yourself"
-			}],
-			initialValue: "auto"
-		});
-		if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
-		selectedMode = promptedMode;
+	if (!selectedMode) {
+		if (isSilent()) selectedMode = "manual";
+		else {
+			const promptedMode = await select({
+				message: "Neon setup: choose mode",
+				options: [{
+					label: "Automatic",
+					value: "auto",
+					hint: "Automated setup with provider CLI, sets .env"
+				}, {
+					label: "Manual",
+					value: "manual",
+					hint: "Manual setup, add env vars yourself"
+				}],
+				initialValue: "auto"
+			});
+			if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
+			selectedMode = types_exports.DbSetupModeSchema.parse(promptedMode);
+		}
 	}
 	if (selectedMode === "manual") {
 		const envResult = await writeEnvFile$2(projectDir, backend);
@@ -7870,23 +7740,25 @@ async function setupNeonPostgres(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	let setupMethod = cliInput?.dbSetupOptions?.neon?.method ?? config.dbSetupOptions?.neon?.method;
-	if (!setupMethod) if (isSilent()) setupMethod = "neon-new";
-	else {
-		const promptedSetupMethod = await select({
-			message: "Choose your Neon setup method:",
-			options: [{
-				label: "Quick setup with neon-new",
-				value: "neon-new",
-				hint: "fastest, no auth required"
-			}, {
-				label: "Custom setup with Neon CLI",
-				value: "neon",
-				hint: "More control - choose project name and region"
-			}],
-			initialValue: "neon-new"
-		});
-		if (isCancel(promptedSetupMethod)) return userCancelled("Operation cancelled");
-		setupMethod = promptedSetupMethod;
+	if (!setupMethod) {
+		if (isSilent()) setupMethod = "neon-new";
+		else {
+			const promptedSetupMethod = await select({
+				message: "Choose your Neon setup method:",
+				options: [{
+					label: "Quick setup with neon-new",
+					value: "neon-new",
+					hint: "fastest, no auth required"
+				}, {
+					label: "Custom setup with Neon CLI",
+					value: "neon",
+					hint: "More control - choose project name and region"
+				}],
+				initialValue: "neon-new"
+			});
+			if (isCancel(promptedSetupMethod)) return userCancelled("Operation cancelled");
+			setupMethod = types_exports.NeonSetupMethodSchema.parse(promptedSetupMethod);
+		}
 	}
 	if (setupMethod === "neon-new" || setupMethod === "neondb") {
 		const neonDbResult = await setupWithNeonDb(projectDir, packageManager, backend);
@@ -7902,26 +7774,30 @@ async function setupNeonPostgres(config, cliInput) {
 	}
 	const suggestedProjectName = path.basename(projectDir);
 	let projectName = cliInput?.dbSetupOptions?.neon?.projectName ?? config.dbSetupOptions?.neon?.projectName;
-	if (!projectName) if (isSilent()) projectName = suggestedProjectName;
-	else {
-		const promptedProjectName = await text({
-			message: "Enter a name for your Neon project:",
-			defaultValue: suggestedProjectName,
-			initialValue: suggestedProjectName
-		});
-		if (isCancel(promptedProjectName)) return userCancelled("Operation cancelled");
-		projectName = promptedProjectName;
+	if (!projectName) {
+		if (isSilent()) projectName = suggestedProjectName;
+		else {
+			const promptedProjectName = await text({
+				message: "Enter a name for your Neon project:",
+				defaultValue: suggestedProjectName,
+				initialValue: suggestedProjectName
+			});
+			if (isCancel(promptedProjectName)) return userCancelled("Operation cancelled");
+			projectName = promptedProjectName;
+		}
 	}
 	let regionId = cliInput?.dbSetupOptions?.neon?.regionId ?? config.dbSetupOptions?.neon?.regionId;
-	if (!regionId) if (isSilent()) regionId = NEON_REGIONS[0].value;
-	else {
-		const promptedRegionId = await select({
-			message: "Select a region for your Neon project:",
-			options: NEON_REGIONS,
-			initialValue: NEON_REGIONS[0].value
-		});
-		if (isCancel(promptedRegionId)) return userCancelled("Operation cancelled");
-		regionId = promptedRegionId;
+	if (!regionId) {
+		if (isSilent()) regionId = NEON_REGIONS[0].value;
+		else {
+			const promptedRegionId = await select({
+				message: "Select a region for your Neon project:",
+				options: NEON_REGIONS,
+				initialValue: NEON_REGIONS[0].value
+			});
+			if (isCancel(promptedRegionId)) return userCancelled("Operation cancelled");
+			regionId = z$1.string().parse(promptedRegionId);
+		}
 	}
 	const neonConfigResult = await createNeonProject(projectName, regionId, packageManager);
 	if (neonConfigResult.isErr()) {
@@ -8044,15 +7920,17 @@ const CREATE_DB_USER_AGENT = "aman/better-t-stack";
 async function setupWithCreateDb(serverDir, packageManager, regionId) {
 	cliLog.info("Starting Prisma Postgres setup with create-db.");
 	let selectedRegion = regionId;
-	if (!selectedRegion) if (isSilent()) selectedRegion = "ap-southeast-1";
-	else {
-		const promptedRegion = await select({
-			message: "Select your preferred region:",
-			options: AVAILABLE_REGIONS,
-			initialValue: "ap-southeast-1"
-		});
-		if (isCancel(promptedRegion)) return userCancelled("Operation cancelled");
-		selectedRegion = promptedRegion;
+	if (!selectedRegion) {
+		if (isSilent()) selectedRegion = "ap-southeast-1";
+		else {
+			const promptedRegion = await select({
+				message: "Select your preferred region:",
+				options: AVAILABLE_REGIONS,
+				initialValue: "ap-southeast-1"
+			});
+			if (isCancel(promptedRegion)) return userCancelled("Operation cancelled");
+			selectedRegion = z$1.string().parse(promptedRegion);
+		}
 	}
 	const createDbArgs = [
 		...getPackageRunnerPrefix(packageManager),
@@ -8155,23 +8033,25 @@ async function setupPrismaPostgres(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	let selectedSetupMode = setupMode;
-	if (!selectedSetupMode) if (isSilent()) selectedSetupMode = "manual";
-	else {
-		const promptedSetupMode = await select({
-			message: "Prisma Postgres setup: choose mode",
-			options: [{
-				label: "Automatic (create-db)",
-				value: "auto",
-				hint: "Provision a database via Prisma's create-db CLI"
-			}, {
-				label: "Manual",
-				value: "manual",
-				hint: "Add your own DATABASE_URL later"
-			}],
-			initialValue: "auto"
-		});
-		if (isCancel(promptedSetupMode)) return userCancelled("Operation cancelled");
-		selectedSetupMode = promptedSetupMode;
+	if (!selectedSetupMode) {
+		if (isSilent()) selectedSetupMode = "manual";
+		else {
+			const promptedSetupMode = await select({
+				message: "Prisma Postgres setup: choose mode",
+				options: [{
+					label: "Automatic (create-db)",
+					value: "auto",
+					hint: "Provision a database via Prisma's create-db CLI"
+				}, {
+					label: "Manual",
+					value: "manual",
+					hint: "Add your own DATABASE_URL later"
+				}],
+				initialValue: "auto"
+			});
+			if (isCancel(promptedSetupMode)) return userCancelled("Operation cancelled");
+			selectedSetupMode = types_exports.DbSetupModeSchema.parse(promptedSetupMode);
+		}
 	}
 	if (selectedSetupMode === "manual") {
 		const envResult = await writeEnvFile$1(projectDir, backend);
@@ -8316,23 +8196,25 @@ async function setupSupabase(config, cliInput) {
 		return writeSupabaseEnvFile(projectDir, backend, "");
 	}
 	let mode = setupMode;
-	if (!mode) if (isSilent()) mode = "manual";
-	else {
-		const promptedMode = await select({
-			message: "Supabase setup: choose mode",
-			options: [{
-				label: "Automatic",
-				value: "auto",
-				hint: "Automated setup with provider CLI, sets .env"
-			}, {
-				label: "Manual",
-				value: "manual",
-				hint: "Manual setup, add env vars yourself"
-			}],
-			initialValue: "auto"
-		});
-		if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
-		mode = promptedMode;
+	if (!mode) {
+		if (isSilent()) mode = "manual";
+		else {
+			const promptedMode = await select({
+				message: "Supabase setup: choose mode",
+				options: [{
+					label: "Automatic",
+					value: "auto",
+					hint: "Automated setup with provider CLI, sets .env"
+				}, {
+					label: "Manual",
+					value: "manual",
+					hint: "Manual setup, add env vars yourself"
+				}],
+				initialValue: "auto"
+			});
+			if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
+			mode = types_exports.DbSetupModeSchema.parse(promptedMode);
+		}
 	}
 	if (mode === "manual") {
 		displayManualSupabaseInstructions(targetApp);
@@ -8458,12 +8340,13 @@ async function selectTursoGroup() {
 		cliLog.info(`Using the only available group: ${pc.blue(groups[0].name)}`);
 		return Result.ok(groups[0].name);
 	}
+	const groupOptions = groups.map((group) => ({
+		value: group.name,
+		label: `${group.name} (${group.locations})`
+	}));
 	const selectedGroup = await select({
 		message: "Select a Turso database group:",
-		options: groups.map((group) => ({
-			value: group.name,
-			label: `${group.name} (${group.locations})`
-		}))
+		options: groupOptions
 	});
 	if (isCancel(selectedGroup)) return userCancelled("Operation cancelled");
 	return Result.ok(selectedGroup);
@@ -8561,23 +8444,25 @@ async function setupTurso(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	let mode = setupMode;
-	if (!mode) if (isSilent()) mode = "manual";
-	else {
-		const promptedMode = await select({
-			message: "Turso setup: choose mode",
-			options: [{
-				label: "Automatic",
-				value: "auto",
-				hint: "Automated setup with provider CLI, sets .env"
-			}, {
-				label: "Manual",
-				value: "manual",
-				hint: "Manual setup, add env vars yourself"
-			}],
-			initialValue: "auto"
-		});
-		if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
-		mode = promptedMode;
+	if (!mode) {
+		if (isSilent()) mode = "manual";
+		else {
+			const promptedMode = await select({
+				message: "Turso setup: choose mode",
+				options: [{
+					label: "Automatic",
+					value: "auto",
+					hint: "Automated setup with provider CLI, sets .env"
+				}, {
+					label: "Manual",
+					value: "manual",
+					hint: "Manual setup, add env vars yourself"
+				}],
+				initialValue: "auto"
+			});
+			if (isCancel(promptedMode)) return userCancelled("Operation cancelled");
+			mode = types_exports.DbSetupModeSchema.parse(promptedMode);
+		}
 	}
 	if (mode === "manual") {
 		const envResult = await writeEnvFile(projectDir, backend);
@@ -8586,7 +8471,7 @@ async function setupTurso(config, cliInput) {
 		return Result.ok(void 0);
 	}
 	setupSpinner.start("Checking Turso CLI availability...");
-	const platform = os.platform();
+	const platform = os$1.platform();
 	const isMac = platform === "darwin";
 	if (platform === "win32") {
 		setupSpinner.stop(pc.yellow("Turso setup not supported on Windows"));
@@ -8599,14 +8484,16 @@ async function setupTurso(config, cliInput) {
 	setupSpinner.stop("Turso CLI availability checked");
 	if (!await isTursoInstalled()) {
 		let shouldInstall = cliInput?.dbSetupOptions?.turso?.installCli;
-		if (shouldInstall === void 0) if (isSilent()) shouldInstall = false;
-		else {
-			const promptedInstall = await confirm({
-				message: "Would you like to install Turso CLI?",
-				initialValue: true
-			});
-			if (isCancel(promptedInstall)) return userCancelled("Operation cancelled");
-			shouldInstall = promptedInstall;
+		if (shouldInstall === void 0) {
+			if (isSilent()) shouldInstall = false;
+			else {
+				const promptedInstall = await confirm({
+					message: "Would you like to install Turso CLI?",
+					initialValue: true
+				});
+				if (isCancel(promptedInstall)) return userCancelled("Operation cancelled");
+				shouldInstall = z$1.boolean().parse(promptedInstall);
+			}
 		}
 		if (!shouldInstall) {
 			const envResult = await writeEnvFile(projectDir, backend);
@@ -8641,11 +8528,13 @@ async function setupTurso(config, cliInput) {
 		}
 	}
 	let selectedGroup = cliInput?.dbSetupOptions?.turso?.groupName ?? config.dbSetupOptions?.turso?.groupName ?? null;
-	if (!selectedGroup) if (isSilent()) selectedGroup = (await getTursoGroups())[0]?.name ?? null;
-	else {
-		const groupResult = await selectTursoGroup();
-		if (groupResult.isErr()) return Result.err(groupResult.error);
-		selectedGroup = groupResult.value;
+	if (!selectedGroup) {
+		if (isSilent()) selectedGroup = (await getTursoGroups())[0]?.name ?? null;
+		else {
+			const groupResult = await selectTursoGroup();
+			if (groupResult.isErr()) return Result.err(groupResult.error);
+			selectedGroup = groupResult.value;
+		}
 	}
 	let suggestedName = cliInput?.dbSetupOptions?.turso?.databaseName ?? config.dbSetupOptions?.turso?.databaseName ?? path.basename(projectDir);
 	if (isSilent()) {
@@ -8810,7 +8699,7 @@ function getDockerInstallInstructions(platform, database) {
 	return `${pc.yellow("IMPORTANT:")} Docker required for ${databaseName}. Install for ${platformName}:\n${pc.blue(installUrl)}`;
 }
 async function getDockerStatus(database) {
-	const platform = os.platform();
+	const platform = os$1.platform();
 	if (!await isDockerInstalled()) return {
 		installed: false,
 		running: false,
@@ -8862,7 +8751,7 @@ async function displayPostInstallInstructions(config) {
 	const pwaInstructions = addons?.includes("pwa") && frontend?.includes("react-router") ? getPwaInstructions() : "";
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
 	const clerkInstructions = config.auth === "clerk" ? getClerkInstructions(frontend || [], backend, api) : "";
-	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend, config.auth, frontend || []);
+	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend, config.auth, frontend || [], addons || []);
 	const hasWeb = frontend?.some((f) => types_exports.webFrontends.includes(f));
 	const hasNative = frontend?.includes("native-bare") || frontend?.includes("native-uniwind") || frontend?.includes("native-unistyles");
 	const hasReactRouter = frontend?.includes("react-router");
@@ -8879,6 +8768,7 @@ async function displayPostInstallInstructions(config) {
 	if (database === "sqlite" && dbSetup !== "d1") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (optional - starts local SQLite database)")}\n`;
 	const hasAlchemyD1 = dbSetup === "d1" && (serverDeploy === "cloudflare" || isBackendSelf && webDeploy === "cloudflare");
 	const hasWranglerLocalD1 = (0, types_exports.getLocalD1Owner)(config) === "wrangler";
+	if (orm === "prisma" && !hasAlchemyD1) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:generate\n`;
 	if (hasAlchemyD1 && orm !== "none") {
 		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:generate\n`;
 		if (orm === "prisma") output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:migrate\n`;
@@ -9077,7 +8967,7 @@ function getElectrobunInstructions(runCmd, frontend) {
 	return `\n${pc.bold("Desktop app with Electrobun:")}\n${pc.cyan("•")} Start desktop app with HMR (runs the whole stack): ${`${runCmd} dev:desktop`}\n${pc.cyan("•")} Build stable desktop app (DMG/App): ${`${runCmd} build:desktop`}\n${pc.cyan("•")} Build canary desktop app: ${`${runCmd} build:desktop:canary`}\n${pc.yellow("NOTE:")} Electrobun wraps your web frontend in a desktop shell.\n   The first desktop command downloads Hutch and the Electrobun toolchain.\n   Packaged builds bake the API URL from apps/web/.env, so point it at a reachable server first.\n   See: https://framework.blackboard.sh/electrobun/${staticBuildNote ? `\n${staticBuildNote}` : ""}`;
 }
 function getPwaInstructions() {
-	return `\n${pc.bold("PWA with React Router v7:")}\n${pc.yellow("NOTE:")} There is a known compatibility issue between VitePWA\n   and React Router v7. See:\n   https://github.com/vite-pwa/vite-plugin-pwa/issues/809`;
+	return `\n${pc.bold("PWA with React Router:")}\n${pc.yellow("NOTE:")} Verify PWA behavior with a production build on HTTPS or localhost.\n   Offline navigation shows a precached fallback page.\n   Server-rendered pages require a connection.`;
 }
 function getStarlightInstructions(runCmd) {
 	return `\n${pc.bold("Documentation with Starlight:")}\n${pc.cyan("•")} Start docs site: ${`cd apps/docs && ${runCmd} dev`}\n${pc.cyan("•")} Build docs site: ${`cd apps/docs && ${runCmd} build`}`;
@@ -9159,21 +9049,26 @@ function getPolarInstructions(backend, packageManager) {
 	const envPath = backend === "self" ? "apps/web/.env" : "apps/server/.env";
 	return `${pc.bold("Polar Payments Setup:")}\n${pc.cyan("•")} Get access token & product ID from ${pc.underline("https://sandbox.polar.sh/")}\n${pc.cyan("•")} Set POLAR_ACCESS_TOKEN in ${envPath}`;
 }
-function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend, auth, frontend) {
+function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend, auth, frontend, addons) {
 	const instructions = [];
 	const isBackendSelf = backend === "self";
 	const hasAlchemyWeb = (0, types_exports.isAlchemyDeployTarget)(webDeploy);
 	const hasAlchemyServer = (0, types_exports.isAlchemyDeployTarget)(serverDeploy);
+	const hasAxiom = addons.includes("axiom");
 	const alchemyExec = runCmd === "npm run" ? "npx" : runCmd === "pnpm run" ? "pnpm exec" : "bunx";
-	if (hasAlchemyWeb || hasAlchemyServer) {
-		const targetParts = [...hasAlchemyWeb ? [`web on ${webDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : [], ...hasAlchemyServer && !isBackendSelf ? [`server on ${serverDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : []];
-		const deployScript = webDeploy === "vercel" ? "deploy:server" : serverDeploy === "vercel" ? "deploy:web" : "deploy";
+	if (hasAlchemyWeb || hasAlchemyServer || hasAxiom) {
+		const targetParts = [
+			...hasAlchemyWeb ? [`web on ${webDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : [],
+			...hasAlchemyServer && !isBackendSelf ? [`server on ${serverDeploy === "cloudflare" ? "Cloudflare" : "Prisma"}`] : [],
+			...hasAxiom ? ["Axiom observability"] : []
+		];
+		const deployScript = !(hasAlchemyWeb || hasAlchemyServer) && (webDeploy === "vercel" || serverDeploy === "vercel" || webDeploy === "docker" || serverDeploy === "docker") ? "deploy:infra" : webDeploy === "vercel" ? "deploy:server" : serverDeploy === "vercel" ? "deploy:web" : "deploy";
 		const originSteps = [];
 		const hasWeb = frontend.some((value) => types_exports.webFrontends.includes(value));
 		if (!isBackendSelf && hasAlchemyServer && hasWeb) originSteps.push(`${pc.cyan("•")} Required after the first deploy: set CORS_ORIGIN in apps/server/.env to the deployed web origin, then deploy again`);
 		if (auth === "better-auth" && isBackendSelf && webDeploy === "prisma") originSteps.push(`${pc.cyan("•")} After the first deploy, set BETTER_AUTH_URL in apps/web/.env to the returned web URL, then deploy again`);
 		else if (auth === "better-auth" && !isBackendSelf && serverDeploy === "prisma") originSteps.push(`${pc.cyan("•")} After the first deploy, set BETTER_AUTH_URL in apps/server/.env to the returned server URL, then deploy again`);
-		instructions.push(`${pc.bold(`Deploy with Alchemy (${targetParts.join(" + ")}):`)}\n${pc.cyan("•")} Configure provider login: ${`cd packages/infra && ${alchemyExec} alchemy login --configure`}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} ${deployScript}`}\n${originSteps.join("\n")}${originSteps.length > 0 ? "\n" : ""}${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+		instructions.push(`${pc.bold(`Deploy with Alchemy (${targetParts.join(" + ")}):`)}\n${pc.cyan("•")} Configure provider accounts: ${`cd packages/infra && ${alchemyExec} alchemy profile edit`}\n${hasAxiom && (webDeploy === "vercel" || serverDeploy === "vercel") ? `${pc.cyan("•")} For Axiom, deploy from packages/infra with alchemy deploy --stage preview or --stage production. Link Vercel first: ${`${runCmd} deploy:setup`}\n` : ""}${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} ${deployScript}`}\n${originSteps.join("\n")}${originSteps.length > 0 ? "\n" : ""}${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	}
 	if (webDeploy === "docker" || serverDeploy === "docker") {
 		const dockerTargets = webDeploy === "docker" && serverDeploy === "docker" ? "web + server" : webDeploy === "docker" ? "web" : "server";
@@ -9693,7 +9588,7 @@ const CreateVirtualInputSchema = types_exports.ProjectConfigSchema.omit({
 	projectDir: true,
 	relativePath: true
 }).partial().strict();
-const t = initTRPC.meta().create();
+const command = os.$meta({});
 function getCliSchemaJson() {
 	return createCli({
 		router,
@@ -9710,8 +9605,8 @@ function getSchemaResult(name) {
 	if (name === "cli") return getCliSchemaJson();
 	return schemas[name];
 }
-const router = t.router({
-	create: t.procedure.meta({
+const router = os.router({
+	create: command.meta({
 		description: "Create a new Better-T-Stack project",
 		default: true,
 		negateBooleans: true
@@ -9743,7 +9638,7 @@ const router = t.router({
 		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"),
 		dbSetupOptions: types_exports.DbSetupOptionsSchema.optional().describe("Structured database setup options")
-	})])).mutation(async ({ input }) => {
+	})])).handler(async ({ input }) => {
 		const [projectName, options] = input;
 		const result = await createProjectHandler({
 			projectName,
@@ -9751,10 +9646,10 @@ const router = t.router({
 		});
 		if (options.verbose) return result;
 	}),
-	createJson: t.procedure.meta({
+	createJson: command.meta({
 		description: "Create a project from a raw JSON payload (agent-friendly)",
 		jsonInput: "always"
-	}).input(types_exports.CreateInputSchema).mutation(async ({ input }) => {
+	}).input(types_exports.CreateInputSchema).handler(async ({ input }) => {
 		const result = await createProjectHandler(input, {
 			silent: true,
 			mode: "json"
@@ -9763,11 +9658,11 @@ const router = t.router({
 		if (!result.success) throw new CLIError({ message: result.error || "Unknown error occurred" });
 		return result;
 	}),
-	schema: t.procedure.meta({ description: "Show runtime CLI and input schemas as JSON" }).input(z.object({ name: SchemaNameSchema.describe("Schema name to inspect") })).query(({ input }) => getSchemaResult(input.name)),
-	sponsors: t.procedure.meta({ description: "Show Better-T-Stack sponsors" }).mutation(() => showSponsorsCommand()),
-	docs: t.procedure.meta({ description: "Open Better-T-Stack documentation" }).mutation(() => openDocsCommand()),
-	builder: t.procedure.meta({ description: "Open the web-based stack builder" }).mutation(() => openBuilderCommand()),
-	add: t.procedure.meta({ description: "Add addons or a workspace package to an existing Better-T-Stack project" }).input(z.object({
+	schema: command.meta({ description: "Show runtime CLI and input schemas as JSON" }).input(z.object({ name: SchemaNameSchema.describe("Schema name to inspect") })).handler(({ input }) => getSchemaResult(input.name)),
+	sponsors: command.meta({ description: "Show Better-T-Stack sponsors" }).handler(() => showSponsorsCommand()),
+	docs: command.meta({ description: "Open Better-T-Stack documentation" }).handler(() => openDocsCommand()),
+	builder: command.meta({ description: "Open the web-based stack builder" }).handler(() => openBuilderCommand()),
+	add: command.meta({ description: "Add addons or a workspace package to an existing Better-T-Stack project" }).input(z.object({
 		addons: z.array(types_exports.AddonsSchema).optional().describe("Addons to add"),
 		package: types_exports.WorkspacePackageNameSchema.optional(),
 		install: z.boolean().optional().default(false).describe("Install dependencies after adding"),
@@ -9775,13 +9670,13 @@ const router = t.router({
 		projectDir: z.string().optional().describe("Project directory (defaults to current)"),
 		dryRun: z.boolean().optional().default(false).describe("Preview addon changes without writing files"),
 		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics")
-	})).mutation(async ({ input }) => {
+	})).handler(async ({ input }) => {
 		await addHandler(input);
 	}),
-	addJson: t.procedure.meta({
+	addJson: command.meta({
 		description: "Add addons or a workspace package from a raw JSON payload (agent-friendly)",
 		jsonInput: "always"
-	}).input(types_exports.AddInputSchema).mutation(async ({ input }) => {
+	}).input(types_exports.AddInputSchema).handler(async ({ input }) => {
 		const result = await addHandler(input, {
 			silent: true,
 			mode: "json"
@@ -9790,11 +9685,11 @@ const router = t.router({
 		if (!result.success) throw new CLIError({ message: result.error || "Unknown error occurred" });
 		return result;
 	}),
-	history: t.procedure.meta({ description: "Show project creation history" }).input(z.object({
+	history: command.meta({ description: "Show project creation history" }).input(z.object({
 		limit: z.number().optional().default(10).describe("Number of entries to show"),
 		clear: z.boolean().optional().default(false).describe("Clear all history"),
 		json: z.boolean().optional().default(false).describe("Output as JSON")
-	})).mutation(async ({ input }) => {
+	})).handler(async ({ input }) => {
 		await historyHandler(input);
 	})
 });