create-better-t-stack 3.11.1 → 3.12.0

package/dist/{src-Dc2OdxbP.mjs → src-DBVnwTkj.mjs}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import { t as __reExport } from "./chunk-Dt3mZKp0.mjs";
 import { autocompleteMultiselect, cancel, confirm, group, groupMultiselect, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 import { createRouterClient, os } from "@orpc/server";
 import pc from "picocolors";
 import { createCli } from "trpc-cli";
 import z from "zod";
-import path from "node:path";
 import consola, { consola as consola$1 } from "consola";
 import fs from "fs-extra";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { APISchema, AddonsSchema, AuthSchema, BackendSchema, DatabaseSchema, DatabaseSetupSchema, DirectoryConflictSchema, ExamplesSchema, FrontendSchema, ORMSchema, PackageManagerSchema, PaymentsSchema, ProjectNameSchema, RuntimeSchema, ServerDeploySchema, TemplateSchema, WebDeploySchema } from "@better-t-stack/types";
 import gradient from "gradient-string";
 import * as JSONC from "jsonc-parser";
 import { $, execa } from "execa";
@@ -155,10 +155,13 @@ const dependencyVersionMap = {
 	"nitro-cloudflare-dev": "^0.2.2",
 	"@sveltejs/adapter-cloudflare": "^7.2.4",
 	"@cloudflare/workers-types": "^4.20251213.0",
-	alchemy: "^0.81.2",
+	alchemy: "^0.82.1",
 	dotenv: "^17.2.2",
 	tsdown: "^0.16.5",
 	zod: "^4.1.13",
+	"@t3-oss/env-core": "^0.13.1",
+	"@t3-oss/env-nextjs": "^0.13.1",
+	"@t3-oss/env-nuxt": "^0.13.1",
 	srvx: "0.8.15",
 	"@polar-sh/better-auth": "^1.1.3",
 	"@polar-sh/sdk": "^0.34.16"
@@ -191,6 +194,12 @@ const ADDON_COMPATIBILITY = {
 	none: []
 };
 
+//#endregion
+//#region src/types.ts
+var types_exports = {};
+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 = [
@@ -205,24 +214,18 @@ const WEB_FRAMEWORKS = [
 
 //#endregion
 //#region src/utils/errors.ts
-function isProgrammatic() {
-	return process.env.BTS_PROGRAMMATIC === "1";
-}
 function exitWithError(message) {
 	consola.error(pc.red(message));
-	if (isProgrammatic()) throw new Error(message);
-	process.exit(1);
+	throw new Error(message);
 }
 function exitCancelled(message = "Operation cancelled") {
 	cancel(pc.red(message));
-	if (isProgrammatic()) throw new Error(message);
-	process.exit(0);
+	throw new Error(message);
 }
 function handleError(error, fallbackMessage) {
 	const message = error instanceof Error ? error.message : fallbackMessage || String(error);
 	consola.error(pc.red(message));
-	if (isProgrammatic()) throw new Error(message);
-	process.exit(1);
+	throw new Error(message);
 }
 
 //#endregion
@@ -435,7 +438,7 @@ const ADDON_GROUPS = {
 };
 async function getAddonsChoice(addons, frontends, auth) {
 	if (addons !== void 0) return addons;
-	const allAddons = AddonsSchema.options.filter((addon) => addon !== "none");
+	const allAddons = types_exports.AddonsSchema.options.filter((addon) => addon !== "none");
 	const groupedOptions = {
 		Documentation: [],
 		Linting: [],
@@ -481,7 +484,7 @@ async function getAddonsToAdd(frontend, existingAddons = [], auth) {
 		Other: []
 	};
 	const frontendArray = frontend || [];
-	const compatibleAddons = getCompatibleAddons(AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, existingAddons, auth);
+	const compatibleAddons = getCompatibleAddons(types_exports.AddonsSchema.options.filter((addon) => addon !== "none"), frontendArray, existingAddons, auth);
 	for (const addon of compatibleAddons) {
 		const { label, hint } = getAddonDisplay(addon);
 		const option = {
@@ -1058,8 +1061,8 @@ async function getRuntimeChoice(runtime, backend) {
 //#endregion
 //#region src/prompts/server-deploy.ts
 function getDeploymentDisplay$1(deployment) {
-	if (deployment === "alchemy") return {
-		label: "Alchemy",
+	if (deployment === "cloudflare") return {
+		label: "Cloudflare",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
 	};
 	return {
@@ -1071,17 +1074,17 @@ async function getServerDeploymentChoice(deployment, runtime, backend, _webDeplo
 	if (deployment !== void 0) return deployment;
 	if (backend === "none" || backend === "convex") return "none";
 	if (backend !== "hono") return "none";
-	if (runtime === "workers") return "alchemy";
+	if (runtime === "workers") return "cloudflare";
 	return "none";
 }
 async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	if (backend !== "hono") return "none";
 	const options = [];
 	if (runtime === "workers") {
-		if (existingDeployment !== "alchemy") {
-			const { label, hint } = getDeploymentDisplay$1("alchemy");
+		if (existingDeployment !== "cloudflare") {
+			const { label, hint } = getDeploymentDisplay$1("cloudflare");
 			options.push({
-				value: "alchemy",
+				value: "cloudflare",
 				label,
 				hint
 			});
@@ -1104,8 +1107,8 @@ function hasWebFrontend(frontends) {
 	return frontends.some((f) => WEB_FRAMEWORKS.includes(f));
 }
 function getDeploymentDisplay(deployment) {
-	if (deployment === "alchemy") return {
-		label: "Alchemy",
+	if (deployment === "cloudflare") return {
+		label: "Cloudflare",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
 	};
 	return {
@@ -1118,7 +1121,7 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 	if (!hasWebFrontend(frontend)) return "none";
 	const response = await select({
 		message: "Select web deployment",
-		options: ["alchemy", "none"].map((deploy) => {
+		options: ["cloudflare", "none"].map((deploy) => {
 			const { label, hint } = getDeploymentDisplay(deploy);
 			return {
 				value: deploy,
@@ -1134,10 +1137,10 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 async function getDeploymentToAdd(frontend, existingDeployment) {
 	if (!hasWebFrontend(frontend)) return "none";
 	const options = [];
-	if (existingDeployment !== "alchemy") {
-		const { label, hint } = getDeploymentDisplay("alchemy");
+	if (existingDeployment !== "cloudflare") {
+		const { label, hint } = getDeploymentDisplay("cloudflare");
 		options.push({
-			value: "alchemy",
+			value: "cloudflare",
 			label,
 			hint
 		});
@@ -1211,7 +1214,7 @@ function isPathWithinCwd(targetPath) {
 }
 function validateDirectoryName(name) {
 	if (name === ".") return void 0;
-	const result = ProjectNameSchema.safeParse(name);
+	const result = types_exports.ProjectNameSchema.safeParse(name);
 	if (!result.success) return result.error.issues[0]?.message || "Invalid project name";
 }
 async function getProjectName(initialName) {
@@ -1771,7 +1774,7 @@ function validateFullConfig(config, providedFlags, options) {
 	validateSelfBackendCompatibility(providedFlags, options, config);
 	validateWorkersCompatibility(providedFlags, options, config);
 	if (config.runtime === "workers" && config.serverDeploy === "none") exitWithError("Cloudflare Workers runtime requires a server deployment. Please choose 'alchemy' for --server-deploy.");
-	if (providedFlags.has("serverDeploy") && config.serverDeploy === "alchemy" && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
+	if (providedFlags.has("serverDeploy") && config.serverDeploy === "cloudflare" && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
 	if (config.addons && config.addons.length > 0) {
 		validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
 		config.addons = [...new Set(config.addons)];
@@ -1796,11 +1799,11 @@ function validateConfigForProgrammaticUse(config) {
 //#endregion
 //#region src/utils/project-name-validation.ts
 function validateProjectName(name) {
-	const result = ProjectNameSchema.safeParse(name);
+	const result = types_exports.ProjectNameSchema.safeParse(name);
 	if (!result.success) exitWithError(`Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`);
 }
 function validateProjectNameThrow(name) {
-	const result = ProjectNameSchema.safeParse(name);
+	const result = types_exports.ProjectNameSchema.safeParse(name);
 	if (!result.success) throw new Error(`Invalid project name: ${result.error.issues[0]?.message}`);
 }
 function extractAndValidateProjectName(projectName, projectDirectory, throwOnError = false) {
@@ -1998,6 +2001,45 @@ function getPackageExecutionCommand(packageManager, commandWithArgs) {
 		default: return `npx ${commandWithArgs}`;
 	}
 }
+/**
+* Returns the command and arguments as an array for use with execa's $ template syntax.
+* This avoids the need for shell: true and provides better escaping.
+*
+* @param packageManager - The selected package manager (e.g., 'npm', 'yarn', 'pnpm', 'bun').
+* @param commandWithArgs - The command to run, including arguments (e.g., "prisma generate").
+* @returns An array of [command, ...args] (e.g., ["npx", "prisma", "generate"]).
+*/
+function getPackageExecutionArgs(packageManager, commandWithArgs) {
+	const args = commandWithArgs.split(" ");
+	switch (packageManager) {
+		case "pnpm": return [
+			"pnpm",
+			"dlx",
+			...args
+		];
+		case "bun": return ["bunx", ...args];
+		default: return ["npx", ...args];
+	}
+}
+/**
+* Returns just the runner prefix as an array, for when you already have args built.
+* Use this when you have complex arguments that shouldn't be split by spaces.
+*
+* @param packageManager - The selected package manager.
+* @returns The runner prefix as an array (e.g., ["npx"] or ["pnpm", "dlx"]).
+*
+* @example
+* const prefix = getPackageRunnerPrefix("bun");
+* const args = ["@tauri-apps/cli@latest", "init", "--app-name=foo"];
+* await $`${[...prefix, ...args]}`;
+*/
+function getPackageRunnerPrefix(packageManager) {
+	switch (packageManager) {
+		case "pnpm": return ["pnpm", "dlx"];
+		case "bun": return ["bunx"];
+		default: return ["npx"];
+	}
+}
 
 //#endregion
 //#region src/helpers/addons/fumadocs-setup.ts
@@ -2042,16 +2084,15 @@ async function setupFumadocs(config) {
 			initialValue: "next-mdx"
 		});
 		if (isCancel(template)) return exitCancelled("Operation cancelled");
-		const fumadocsInitCommand = getPackageExecutionCommand(packageManager, `create-fumadocs-app@latest fumadocs --template ${TEMPLATES$2[template].value} --src --pm ${packageManager} --no-git`);
+		const args = getPackageExecutionArgs(packageManager, `create-fumadocs-app@latest fumadocs --template ${TEMPLATES$2[template].value} --src --pm ${packageManager} --no-git`);
 		const appsDir = path.join(projectDir, "apps");
 		await fs.ensureDir(appsDir);
 		const s = spinner();
 		s.start("Running Fumadocs create command...");
-		await execa(fumadocsInitCommand, {
+		await $({
 			cwd: appsDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${args}`;
 		const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
 		const packageJsonPath = path.join(fumadocsDir, "package.json");
 		if (await fs.pathExists(packageJsonPath)) {
@@ -2084,18 +2125,17 @@ async function setupOxlint(projectDir, packageManager) {
 		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
 	}
 	const s = spinner();
-	const oxlintInitCommand = getPackageExecutionCommand(packageManager, "oxlint@latest --init");
+	const oxlintArgs = getPackageExecutionArgs(packageManager, "oxlint@latest --init");
 	s.start("Initializing oxlint and oxfmt...");
-	await execa(oxlintInitCommand, {
+	await $({
 		cwd: projectDir,
-		env: { CI: "true" },
-		shell: true
-	});
-	await execa(getPackageExecutionCommand(packageManager, "oxfmt@latest --init"), {
+		env: { CI: "true" }
+	})`${oxlintArgs}`;
+	const oxfmtArgs = getPackageExecutionArgs(packageManager, "oxfmt@latest --init");
+	await $({
 		cwd: projectDir,
-		env: { CI: "true" },
-		shell: true
-	});
+		env: { CI: "true" }
+	})`${oxfmtArgs}`;
 	s.stop("oxlint and oxfmt initialized successfully!");
 }
 
@@ -2160,11 +2200,11 @@ async function setupRuler(config) {
 		const s = spinner();
 		s.start("Applying rules with Ruler...");
 		try {
-			await execa(getPackageExecutionCommand(packageManager, `@intellectronica/ruler@latest apply --agents ${selectedEditors.join(",")} --local-only`), {
+			const rulerApplyArgs = getPackageExecutionArgs(packageManager, `@intellectronica/ruler@latest apply --agents ${selectedEditors.join(",")} --local-only`);
+			await $({
 				cwd: projectDir,
-				env: { CI: "true" },
-				shell: true
-			});
+				env: { CI: "true" }
+			})`${rulerApplyArgs}`;
 			s.stop("Applied rules with Ruler");
 		} catch {
 			s.stop(pc.red("Failed to apply rules"));
@@ -2194,7 +2234,7 @@ async function setupStarlight(config) {
 	const s = spinner();
 	try {
 		s.start("Setting up Starlight docs...");
-		const starlightInitCommand = getPackageExecutionCommand(packageManager, `create-astro@latest ${[
+		const args = getPackageExecutionArgs(packageManager, `create-astro@latest ${[
 			"docs",
 			"--template",
 			"starlight",
@@ -2206,11 +2246,10 @@ async function setupStarlight(config) {
 		].join(" ")}`);
 		const appsDir = path.join(projectDir, "apps");
 		await fs.ensureDir(appsDir);
-		await execa(starlightInitCommand, {
+		await $({
 			cwd: appsDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${args}`;
 		s.stop("Starlight docs setup successfully!");
 	} catch (error) {
 		s.stop(pc.red("Failed to set up Starlight docs"));
@@ -2250,19 +2289,21 @@ async function setupTauri(config) {
 		const hasNext = frontend.includes("next");
 		const devUrl = hasReactRouter || hasSvelte ? "http://localhost:5173" : hasNext ? "http://localhost:3001" : "http://localhost:3001";
 		const frontendDist = hasNuxt ? "../.output/public" : hasSvelte ? "../build" : hasNext ? "../.next" : hasReactRouter ? "../build/client" : "../dist";
-		await execa(getPackageExecutionCommand(packageManager, `@tauri-apps/cli@latest ${[
+		const tauriArgs = [
+			"@tauri-apps/cli@latest",
 			"init",
 			`--app-name=${path.basename(projectDir)}`,
 			`--window-title=${path.basename(projectDir)}`,
 			`--frontend-dist=${frontendDist}`,
 			`--dev-url=${devUrl}`,
-			`--before-dev-command="${packageManager} run dev"`,
-			`--before-build-command="${packageManager} run build"`
-		].join(" ")}`), {
+			`--before-dev-command=${packageManager} run dev`,
+			`--before-build-command=${packageManager} run build`
+		];
+		const prefix = getPackageRunnerPrefix(packageManager);
+		await $({
 			cwd: clientPackageDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${[...prefix, ...tauriArgs]}`;
 		s.stop("Tauri desktop app support configured successfully!");
 	} catch (error) {
 		s.stop(pc.red("Failed to set up Tauri"));
@@ -2300,16 +2341,15 @@ async function setupTui(config) {
 			initialValue: "core"
 		});
 		if (isCancel(template)) return exitCancelled("Operation cancelled");
-		const tuiInitCommand = getPackageExecutionCommand(packageManager, `create-tui@latest --template ${template} --no-git --no-install tui`);
+		const args = getPackageExecutionArgs(packageManager, `create-tui@latest --template ${template} --no-git --no-install tui`);
 		const appsDir = path.join(projectDir, "apps");
 		await fs.ensureDir(appsDir);
 		const s = spinner();
 		s.start("Running OpenTUI create command...");
-		await execa(tuiInitCommand, {
+		await $({
 			cwd: appsDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${args}`;
 		s.stop("OpenTUI setup complete!");
 	} catch (error) {
 		log.error(pc.red("Failed to set up OpenTUI"));
@@ -2410,14 +2450,13 @@ async function setupUltracite(config, hasHusky) {
 		if (agents.length > 0) ultraciteArgs.push("--agents", ...agents);
 		if (hooks.length > 0) ultraciteArgs.push("--hooks", ...hooks);
 		if (hasHusky) ultraciteArgs.push("--integrations", "husky", "lint-staged");
-		const ultraciteInitCommand = getPackageExecutionCommand(packageManager, `ultracite@latest ${ultraciteArgs.join(" ")} --skip-install`);
+		const args = getPackageExecutionArgs(packageManager, `ultracite@latest ${ultraciteArgs.join(" ")} --skip-install`);
 		const s = spinner();
 		s.start("Running Ultracite init command...");
-		await execa(ultraciteInitCommand, {
+		await $({
 			cwd: projectDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${args}`;
 		if (hasHusky) await addPackageDependency({
 			devDependencies: ["husky", "lint-staged"],
 			projectDir
@@ -2429,6 +2468,54 @@ async function setupUltracite(config, hasHusky) {
 	}
 }
 
+//#endregion
+//#region src/utils/ts-morph.ts
+const tsProject = new Project({
+	useInMemoryFileSystem: false,
+	skipAddingFilesFromTsConfig: true,
+	manipulationSettings: {
+		quoteKind: QuoteKind.Single,
+		indentationText: IndentationText.TwoSpaces
+	}
+});
+function ensureArrayProperty(obj, name) {
+	return obj.getProperty(name)?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) ?? obj.addPropertyAssignment({
+		name,
+		initializer: "[]"
+	}).getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+}
+
+//#endregion
+//#region src/helpers/addons/vite-pwa-setup.ts
+async function addPwaToViteConfig(viteConfigPath, projectName) {
+	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
+	if (!sourceFile) throw new Error("vite config not found");
+	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa")) sourceFile.insertImportDeclaration(0, {
+		namedImports: ["VitePWA"],
+		moduleSpecifier: "vite-plugin-pwa"
+	});
+	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
+		const expression = expr.getExpression();
+		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
+	});
+	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
+	const configObject = defineCall.getArguments()[0];
+	if (!configObject) throw new Error("defineConfig argument is not an object literal");
+	const pluginsArray = ensureArrayProperty(configObject, "plugins");
+	if (!pluginsArray.getElements().some((el) => el.getText().startsWith("VitePWA("))) pluginsArray.addElement(`VitePWA({
+  registerType: "autoUpdate",
+  manifest: {
+    name: "${projectName}",
+    short_name: "${projectName}",
+    description: "${projectName} - PWA Application",
+    theme_color: "#0c0c0c",
+  },
+  pwaAssets: { disabled: false, config: true },
+  devOptions: { enabled: true },
+})`);
+	await tsProject.save();
+}
+
 //#endregion
 //#region src/helpers/addons/wxt-setup.ts
 const TEMPLATES = {
@@ -2467,16 +2554,15 @@ async function setupWxt(config) {
 			initialValue: "react"
 		});
 		if (isCancel(template)) return exitCancelled("Operation cancelled");
-		const wxtInitCommand = getPackageExecutionCommand(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
+		const args = getPackageExecutionArgs(packageManager, `wxt@latest init extension --template ${template} --pm ${packageManager}`);
 		const appsDir = path.join(projectDir, "apps");
 		await fs.ensureDir(appsDir);
 		const s = spinner();
 		s.start("Running WXT init command...");
-		await execa(wxtInitCommand, {
+		await $({
 			cwd: appsDir,
-			env: { CI: "true" },
-			shell: true
-		});
+			env: { CI: "true" }
+		})`${args}`;
 		const extensionDir = path.join(projectDir, "apps", "extension");
 		const packageJsonPath = path.join(extensionDir, "package.json");
 		if (await fs.pathExists(packageJsonPath)) {
@@ -2492,54 +2578,6 @@ async function setupWxt(config) {
 	}
 }
 
-//#endregion
-//#region src/utils/ts-morph.ts
-const tsProject$1 = new Project({
-	useInMemoryFileSystem: false,
-	skipAddingFilesFromTsConfig: true,
-	manipulationSettings: {
-		quoteKind: QuoteKind.Single,
-		indentationText: IndentationText.TwoSpaces
-	}
-});
-function ensureArrayProperty(obj, name) {
-	return obj.getProperty(name)?.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression) ?? obj.addPropertyAssignment({
-		name,
-		initializer: "[]"
-	}).getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-}
-
-//#endregion
-//#region src/helpers/addons/vite-pwa-setup.ts
-async function addPwaToViteConfig(viteConfigPath, projectName) {
-	const sourceFile = tsProject$1.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) throw new Error("vite config not found");
-	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "vite-plugin-pwa")) sourceFile.insertImportDeclaration(0, {
-		namedImports: ["VitePWA"],
-		moduleSpecifier: "vite-plugin-pwa"
-	});
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) throw new Error("Could not find defineConfig call in vite config");
-	const configObject = defineCall.getArguments()[0];
-	if (!configObject) throw new Error("defineConfig argument is not an object literal");
-	const pluginsArray = ensureArrayProperty(configObject, "plugins");
-	if (!pluginsArray.getElements().some((el) => el.getText().startsWith("VitePWA("))) pluginsArray.addElement(`VitePWA({
-  registerType: "autoUpdate",
-  manifest: {
-    name: "${projectName}",
-    short_name: "${projectName}",
-    description: "${projectName} - PWA Application",
-    theme_color: "#0c0c0c",
-  },
-  pwaAssets: { disabled: false, config: true },
-  devOptions: { enabled: true },
-})`);
-	await tsProject$1.save();
-}
-
 //#endregion
 //#region src/helpers/addons/addons-setup.ts
 async function setupAddons(config, isAddCommand = false) {
@@ -2768,38 +2806,6 @@ handlebars.registerHelper("or", (...args) => {
 });
 handlebars.registerHelper("includes", (array, value) => Array.isArray(array) && array.includes(value));
 
-//#endregion
-//#region src/helpers/deployment/alchemy/env-dts-setup.ts
-const tsProject = new Project({
-	useInMemoryFileSystem: false,
-	skipAddingFilesFromTsConfig: true
-});
-function determineImportPath(envDtsPath, projectDir, config) {
-	const { webDeploy, serverDeploy, backend } = config;
-	const isBackendSelf = backend === "self";
-	let alchemyRunPath;
-	if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) if (isBackendSelf) alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
-	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
-	else if (webDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/web/alchemy.run.ts");
-	else if (serverDeploy === "alchemy") alchemyRunPath = path.join(projectDir, "apps/server/alchemy.run.ts");
-	else alchemyRunPath = path.join(projectDir, "alchemy.run.ts");
-	const relativePath = path.relative(path.dirname(envDtsPath), alchemyRunPath.replace(/\.ts$/, ""));
-	return (relativePath.startsWith(".") ? relativePath : `./${relativePath}`).replace(/\\/g, "/");
-}
-async function setupEnvDtsImport(envDtsPath, projectDir, config) {
-	if (!await fs.pathExists(envDtsPath)) return;
-	const importPath = determineImportPath(envDtsPath, projectDir, config);
-	const sourceFile = tsProject.addSourceFileAtPath(envDtsPath);
-	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === importPath && imp.getNamedImports().some((named) => named.getName() === "server"))) sourceFile.insertImportDeclaration(0, {
-		moduleSpecifier: importPath,
-		namedImports: [{
-			name: "server",
-			isTypeOnly: true
-		}]
-	});
-	await sourceFile.save();
-}
-
 //#endregion
 //#region src/helpers/core/template-manager.ts
 async function processAndCopyFiles(sourcePattern, baseSourceDir, destDir, context, overwrite = true, ignorePatterns) {
@@ -2904,7 +2910,7 @@ async function setupFrontendTemplates(projectDir, context) {
 		}
 	}
 }
-async function setupApiPackage(projectDir, context) {
+async function setupApiPackage$1(projectDir, context) {
 	if (context.api === "none") return;
 	const apiPackageDir = path.join(projectDir, "packages/api");
 	await fs.ensureDir(apiPackageDir);
@@ -2917,7 +2923,7 @@ async function setupConfigPackage(projectDir, context) {
 	const configBaseDir = path.join(PKG_ROOT, "templates/packages/config");
 	if (await fs.pathExists(configBaseDir)) await processAndCopyFiles("**/*", configBaseDir, configPackageDir, context);
 }
-async function setupDbPackage(projectDir, context) {
+async function setupDbPackage$1(projectDir, context) {
 	if (context.database === "none" || context.orm === "none") return;
 	const dbPackageDir = path.join(projectDir, "packages/db");
 	await fs.ensureDir(dbPackageDir);
@@ -2944,21 +2950,78 @@ async function setupServerApp(projectDir, context) {
 	const frameworkSrcDir = path.join(PKG_ROOT, `templates/backend/server/${context.backend}`);
 	if (await fs.pathExists(frameworkSrcDir)) await processAndCopyFiles("**/*", frameworkSrcDir, serverAppDir, context, true);
 }
+async function setupEnvPackage$1(projectDir, context) {
+	const hasWebFrontend$1 = context.frontend.some((f) => [
+		"tanstack-router",
+		"react-router",
+		"tanstack-start",
+		"next",
+		"nuxt",
+		"svelte",
+		"solid"
+	].includes(f));
+	const hasNative = context.frontend.some((f) => [
+		"native-bare",
+		"native-uniwind",
+		"native-unistyles"
+	].includes(f));
+	if (!hasWebFrontend$1 && !hasNative && context.backend === "none") return;
+	const envPackageDir = path.join(projectDir, "packages/env");
+	await fs.ensureDir(envPackageDir);
+	const envBaseDir = path.join(PKG_ROOT, "templates/packages/env");
+	const packageJsonSrc = path.join(envBaseDir, "package.json.hbs");
+	if (await fs.pathExists(packageJsonSrc)) await processAndCopyFiles("package.json.hbs", envBaseDir, envPackageDir, context);
+	const tsconfigSrc = path.join(envBaseDir, "tsconfig.json.hbs");
+	if (await fs.pathExists(tsconfigSrc)) await processAndCopyFiles("tsconfig.json.hbs", envBaseDir, envPackageDir, context);
+	const needsServerEnv = context.backend !== "none" && context.backend !== "convex";
+	if (needsServerEnv) {
+		const serverSrc = path.join(envBaseDir, "src/server.ts.hbs");
+		if (await fs.pathExists(serverSrc)) {
+			await fs.ensureDir(path.join(envPackageDir, "src"));
+			await processAndCopyFiles("src/server.ts.hbs", envBaseDir, envPackageDir, context);
+		}
+	}
+	if (hasWebFrontend$1) {
+		const webSrc = path.join(envBaseDir, "src/web.ts.hbs");
+		if (await fs.pathExists(webSrc)) {
+			await fs.ensureDir(path.join(envPackageDir, "src"));
+			await processAndCopyFiles("src/web.ts.hbs", envBaseDir, envPackageDir, context);
+		}
+	}
+	if (hasNative) {
+		const nativeSrc = path.join(envBaseDir, "src/native.ts.hbs");
+		if (await fs.pathExists(nativeSrc)) {
+			await fs.ensureDir(path.join(envPackageDir, "src"));
+			await processAndCopyFiles("src/native.ts.hbs", envBaseDir, envPackageDir, context);
+		}
+	}
+	const packageJsonPath = path.join(envPackageDir, "package.json");
+	if (await fs.pathExists(packageJsonPath)) {
+		const packageJson = await fs.readJson(packageJsonPath);
+		const exports = {};
+		if (needsServerEnv) exports["./server"] = "./src/server.ts";
+		if (hasWebFrontend$1) exports["./web"] = "./src/web.ts";
+		if (hasNative) exports["./native"] = "./src/native.ts";
+		packageJson.exports = exports;
+		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+	}
+}
 async function setupBackendFramework(projectDir, context) {
 	await setupConfigPackage(projectDir, context);
+	await setupEnvPackage$1(projectDir, context);
 	if (context.backend === "none") return;
 	if (context.backend === "convex") {
 		await setupConvexBackend(projectDir, context);
 		return;
 	}
 	if (context.backend === "self") {
-		await setupApiPackage(projectDir, context);
-		await setupDbPackage(projectDir, context);
+		await setupApiPackage$1(projectDir, context);
+		await setupDbPackage$1(projectDir, context);
 		return;
 	}
 	await setupServerApp(projectDir, context);
-	await setupApiPackage(projectDir, context);
-	await setupDbPackage(projectDir, context);
+	await setupApiPackage$1(projectDir, context);
+	await setupDbPackage$1(projectDir, context);
 }
 async function setupAuthTemplate(projectDir, context) {
 	if (!context.auth || context.auth === "none") return;
@@ -3287,35 +3350,22 @@ async function setupDockerComposeTemplates(projectDir, context) {
 }
 async function setupDeploymentTemplates(projectDir, context) {
 	const isBackendSelf = context.backend === "self";
-	if (context.webDeploy === "alchemy" || context.serverDeploy === "alchemy") {
-		const alchemyTemplateSrc = path.join(PKG_ROOT, "templates/deploy/alchemy");
-		if (context.webDeploy === "alchemy" && (context.serverDeploy === "alchemy" || isBackendSelf)) {
-			if (await fs.pathExists(alchemyTemplateSrc)) {
-				const webAppDir = path.join(projectDir, "apps/web");
-				await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, isBackendSelf && await fs.pathExists(webAppDir) ? webAppDir : projectDir, context);
-				if (!isBackendSelf) await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
-			}
-		} else {
-			if (context.webDeploy === "alchemy") {
-				const webAppDir = path.join(projectDir, "apps/web");
-				if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(webAppDir)) {
-					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, webAppDir, context);
-					if (!isBackendSelf) await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
-				}
-			}
-			if (context.serverDeploy === "alchemy" && !isBackendSelf) {
-				const serverAppDir = path.join(projectDir, "apps/server");
-				if (await fs.pathExists(alchemyTemplateSrc) && await fs.pathExists(serverAppDir)) {
-					await processAndCopyFiles("alchemy.run.ts.hbs", alchemyTemplateSrc, serverAppDir, context);
-					const envDtsPath = path.join(serverAppDir, "env.d.ts");
-					await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
-					await setupEnvDtsImport(envDtsPath, projectDir, context);
-					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
-				}
-			}
+	if (context.webDeploy === "cloudflare" || context.serverDeploy === "cloudflare") {
+		const infraTemplateSrc = path.join(PKG_ROOT, "templates/packages/infra");
+		const infraDir = path.join(projectDir, "packages/infra");
+		if (await fs.pathExists(infraTemplateSrc)) {
+			await fs.ensureDir(infraDir);
+			await processAndCopyFiles("package.json.hbs", infraTemplateSrc, infraDir, context);
+			await processAndCopyFiles("alchemy.run.ts.hbs", infraTemplateSrc, infraDir, context);
+		}
+		if (!isBackendSelf) {
+			const envTemplateSrc = path.join(PKG_ROOT, "templates/packages/env");
+			const envDir = path.join(projectDir, "packages/env");
+			const envDtsTemplatePath = path.join(envTemplateSrc, "env.d.ts.hbs");
+			if (await fs.pathExists(envDtsTemplatePath)) await processTemplate(envDtsTemplatePath, path.join(envDir, "env.d.ts"), context);
 		}
 	}
-	if (context.webDeploy !== "none" && context.webDeploy !== "alchemy") {
+	if (context.webDeploy !== "none" && context.webDeploy !== "cloudflare") {
 		const webAppDir = path.join(projectDir, "apps/web");
 		if (await fs.pathExists(webAppDir)) {
 			const frontends = context.frontend;
@@ -3334,7 +3384,7 @@ async function setupDeploymentTemplates(projectDir, context) {
 			}
 		}
 	}
-	if (context.serverDeploy !== "none" && context.serverDeploy !== "alchemy" && !isBackendSelf) {
+	if (context.serverDeploy !== "none" && context.serverDeploy !== "cloudflare" && !isBackendSelf) {
 		const serverAppDir = path.join(projectDir, "apps/server");
 		if (await fs.pathExists(serverAppDir)) {
 			const deployTemplateSrc = path.join(PKG_ROOT, `templates/deploy/${context.serverDeploy}/server`);
@@ -3342,26 +3392,6 @@ async function setupDeploymentTemplates(projectDir, context) {
 		}
 	}
 }
-async function addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc) {
-	for (const packageName of [
-		"packages/api",
-		"packages/auth",
-		"packages/db"
-	]) {
-		const packageDir = path.join(projectDir, packageName);
-		if (await fs.pathExists(packageDir)) {
-			const envDtsPath = path.join(packageDir, "env.d.ts");
-			await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
-			await setupEnvDtsImport(envDtsPath, projectDir, context);
-		}
-	}
-	const serverAppDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverAppDir)) {
-		const envDtsPath = path.join(serverAppDir, "env.d.ts");
-		await processTemplate(path.join(alchemyTemplateSrc, "env.d.ts.hbs"), envDtsPath, context);
-		await setupEnvDtsImport(envDtsPath, projectDir, context);
-	}
-}
 
 //#endregion
 //#region src/helpers/core/add-addons.ts
@@ -3410,50 +3440,9 @@ async function addAddonsToProject(input) {
 	}
 }
 
-//#endregion
-//#region src/helpers/deployment/server-deploy-setup.ts
-async function setupServerDeploy(config) {
-	const { serverDeploy, webDeploy, projectDir } = config;
-	if (serverDeploy === "none") return;
-	if (serverDeploy === "alchemy" && webDeploy === "alchemy") return;
-	const serverDir = path.join(projectDir, "apps/server");
-	if (!await fs.pathExists(serverDir)) return;
-	if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, projectDir);
-}
-async function setupAlchemyServerDeploy(serverDir, projectDir) {
-	if (!await fs.pathExists(serverDir)) return;
-	await addPackageDependency({
-		devDependencies: [
-			"alchemy",
-			"wrangler",
-			"@types/node",
-			"@cloudflare/workers-types"
-		],
-		projectDir: serverDir
-	});
-	if (projectDir) await addAlchemyPackagesDependencies$1(projectDir);
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-}
-async function addAlchemyPackagesDependencies$1(projectDir) {
-	await addPackageDependency({
-		devDependencies: ["@cloudflare/workers-types"],
-		projectDir
-	});
-}
-
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-next-setup.ts
-async function setupNextAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupNextAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
@@ -3465,17 +3454,6 @@ async function setupNextAlchemyDeploy(projectDir, _packageManager, options) {
 		],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 	const openNextConfigPath = path.join(webAppDir, "open-next.config.ts");
 	await fs.writeFile(openNextConfigPath, `import { defineCloudflareConfig } from "@opennextjs/cloudflare";
 
@@ -3489,7 +3467,7 @@ export default defineCloudflareConfig({});
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-nuxt-setup.ts
-async function setupNuxtAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupNuxtAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
@@ -3500,17 +3478,6 @@ async function setupNuxtAlchemyDeploy(projectDir, _packageManager, options) {
 		],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
 	if (!await fs.pathExists(nuxtConfigPath)) return;
 	try {
@@ -3555,68 +3522,35 @@ async function setupNuxtAlchemyDeploy(projectDir, _packageManager, options) {
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-react-router-setup.ts
-async function setupReactRouterAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupReactRouterAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 }
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-solid-setup.ts
-async function setupSolidAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupSolidAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 }
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-svelte-setup.ts
-async function setupSvelteAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupSvelteAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		devDependencies: ["alchemy", "@sveltejs/adapter-cloudflare"],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 	const svelteConfigPath = path.join(webAppDir, "svelte.config.js");
 	if (!await fs.pathExists(svelteConfigPath)) return;
 	try {
@@ -3665,46 +3599,24 @@ function updateAdapterInConfig(configObject) {
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-tanstack-router-setup.ts
-async function setupTanStackRouterAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupTanStackRouterAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		devDependencies: ["alchemy"],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 }
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-tanstack-start-setup.ts
-async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, options) {
+async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, _options) {
 	const webAppDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(webAppDir)) return;
 	await addPackageDependency({
 		devDependencies: ["alchemy", "@cloudflare/vite-plugin"],
 		projectDir: webAppDir
 	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		if (!options?.skipAppScripts) pkg.scripts = {
-			...pkg.scripts,
-			dev: "alchemy dev",
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
 	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
 	if (await fs.pathExists(viteConfigPath)) try {
 		const project = new Project({ manipulationSettings: {
@@ -3745,22 +3657,16 @@ async function setupTanStackStartAlchemyDeploy(projectDir, _packageManager, opti
 
 //#endregion
 //#region src/helpers/deployment/alchemy/alchemy-combined-setup.ts
-async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
-	await addPackageDependency({
-		devDependencies: ["alchemy"],
-		projectDir
-	});
-	const rootPkgPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(rootPkgPath)) {
-		const pkg = await fs.readJson(rootPkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: "alchemy deploy",
-			destroy: "alchemy destroy",
-			dev: "alchemy dev"
-		};
-		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
+function getInfraFilter(packageManager, hasTurborepo, infraWorkspace) {
+	if (hasTurborepo) return (script) => `turbo -F ${infraWorkspace} ${script}`;
+	switch (packageManager) {
+		case "pnpm": return (script) => `pnpm --filter ${infraWorkspace} ${script}`;
+		case "npm": return (script) => `npm run ${script} --workspace ${infraWorkspace}`;
+		case "bun": return (script) => `bun run --filter ${infraWorkspace} ${script}`;
 	}
+}
+async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
+	await setupInfraScripts(projectDir, packageManager, config);
 	const serverDir = path.join(projectDir, "apps/server");
 	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, projectDir);
 	const frontend = config.frontend;
@@ -3779,6 +3685,77 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 	else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
 	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
 }
+async function setupInfraScripts(projectDir, packageManager, config) {
+	const projectName = config.projectName;
+	const hasTurborepo = config.addons.includes("turborepo");
+	const infraWorkspace = `@${projectName}/infra`;
+	const rootPkgPath = path.join(projectDir, "package.json");
+	if (await fs.pathExists(rootPkgPath)) {
+		const pkg = await fs.readJson(rootPkgPath);
+		const filter = getInfraFilter(packageManager, hasTurborepo, infraWorkspace);
+		pkg.scripts = {
+			...pkg.scripts,
+			deploy: filter("deploy"),
+			destroy: filter("destroy")
+		};
+		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
+	}
+	if (config.serverDeploy === "cloudflare") {
+		const serverPkgPath = path.join(projectDir, "apps/server/package.json");
+		if (await fs.pathExists(serverPkgPath)) {
+			const serverPkg = await fs.readJson(serverPkgPath);
+			if (serverPkg.scripts?.dev) {
+				serverPkg.scripts["dev:bare"] = serverPkg.scripts.dev;
+				delete serverPkg.scripts.dev;
+				await fs.writeJson(serverPkgPath, serverPkg, { spaces: 2 });
+			}
+		}
+	}
+	if (config.webDeploy === "cloudflare") {
+		const webPkgPath = path.join(projectDir, "apps/web/package.json");
+		if (await fs.pathExists(webPkgPath)) {
+			const webPkg = await fs.readJson(webPkgPath);
+			if (webPkg.scripts?.dev) {
+				webPkg.scripts["dev:bare"] = webPkg.scripts.dev;
+				delete webPkg.scripts.dev;
+				await fs.writeJson(webPkgPath, webPkg, { spaces: 2 });
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/helpers/deployment/server-deploy-setup.ts
+async function setupServerDeploy(config) {
+	const { serverDeploy, webDeploy, projectDir, packageManager } = config;
+	if (serverDeploy === "none") return;
+	if (serverDeploy === "cloudflare" && webDeploy === "cloudflare") return;
+	const serverDir = path.join(projectDir, "apps/server");
+	if (!await fs.pathExists(serverDir)) return;
+	if (serverDeploy === "cloudflare") {
+		await setupInfraScripts(projectDir, packageManager, config);
+		await setupAlchemyServerDeploy(serverDir, projectDir);
+	}
+}
+async function setupAlchemyServerDeploy(serverDir, projectDir) {
+	if (!await fs.pathExists(serverDir)) return;
+	await addPackageDependency({
+		devDependencies: [
+			"alchemy",
+			"wrangler",
+			"@types/node",
+			"@cloudflare/workers-types"
+		],
+		projectDir: serverDir
+	});
+	if (projectDir) await addAlchemyPackagesDependencies$1(projectDir);
+}
+async function addAlchemyPackagesDependencies$1(projectDir) {
+	await addPackageDependency({
+		devDependencies: ["@cloudflare/workers-types"],
+		projectDir
+	});
+}
 
 //#endregion
 //#region src/helpers/deployment/web-deploy-setup.ts
@@ -3786,12 +3763,13 @@ async function setupWebDeploy(config) {
 	const { webDeploy, serverDeploy, frontend, projectDir } = config;
 	const { packageManager } = config;
 	if (webDeploy === "none") return;
-	if (webDeploy !== "alchemy") return;
-	if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
+	if (webDeploy !== "cloudflare") return;
+	if (webDeploy === "cloudflare" && serverDeploy === "cloudflare") {
 		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
 		await addAlchemyPackagesDependencies(projectDir);
 		return;
 	}
+	await setupInfraScripts(projectDir, packageManager, config);
 	const isNext = frontend.includes("next");
 	const isNuxt = frontend.includes("nuxt");
 	const isSvelte = frontend.includes("svelte");
@@ -3880,7 +3858,9 @@ async function setupCatalogs(projectDir, options) {
 		"packages/db",
 		"packages/auth",
 		"packages/backend",
-		"packages/config"
+		"packages/config",
+		"packages/env",
+		"packages/infra"
 	];
 	const packagesInfo = [];
 	for (const pkgPath of packagePaths) {
@@ -4298,7 +4278,7 @@ async function setupBackendDependencies(config) {
 //#region src/utils/better-auth-plugin-setup.ts
 async function setupBetterAuthPlugins(projectDir, config) {
 	const authIndexPath = `${projectDir}/packages/auth/src/index.ts`;
-	const authIndexFile = tsProject$1.addSourceFileAtPath(authIndexPath);
+	const authIndexFile = tsProject.addSourceFileAtPath(authIndexPath);
 	if (!authIndexFile) return;
 	const pluginsToAdd = [];
 	const importsToAdd = [];
@@ -4570,11 +4550,6 @@ async function setupEnvironmentVariables(config) {
 				value: backend === "convex" ? "https://<YOUR_CONVEX_URL>" : baseVar.value,
 				condition: backend === "convex" ? true : baseVar.write
 			}];
-			if (hasNextJs) clientVars.push({
-				key: "PORT",
-				value: "3001",
-				condition: true
-			});
 			if (backend === "convex" && auth === "clerk") {
 				if (hasNextJs) clientVars.push({
 					key: "NEXT_PUBLIC_CLERK_FRONTEND_API_URL",
@@ -4710,7 +4685,7 @@ ${hasWebFrontend$1 ? "# npx convex env set SITE_URL http://localhost:3001\n" : "
 			databaseUrl = "mongodb://localhost:27017/mydatabase";
 			break;
 		case "sqlite":
-			if (config.runtime === "workers" || webDeploy === "alchemy" || serverDeploy === "alchemy") databaseUrl = "http://127.0.0.1:8080";
+			if (config.runtime === "workers" || webDeploy === "cloudflare" || serverDeploy === "cloudflare") databaseUrl = "http://127.0.0.1:8080";
 			else {
 				const dbAppDir = backend === "self" ? "apps/web" : "apps/server";
 				databaseUrl = `file:${path.join(config.projectDir, dbAppDir, "local.db")}`;
@@ -4758,33 +4733,13 @@ ${hasWebFrontend$1 ? "# npx convex env set SITE_URL http://localhost:3001\n" : "
 		const webDir = path.join(projectDir, "apps/web");
 		if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverVars);
 	} else if (await fs.pathExists(serverDir)) await addEnvVariablesToFile(path.join(serverDir, ".env"), serverVars);
-	const isUnifiedAlchemy = webDeploy === "alchemy" && serverDeploy === "alchemy";
-	const isIndividualAlchemy = webDeploy === "alchemy" || serverDeploy === "alchemy";
-	if (isUnifiedAlchemy) await addEnvVariablesToFile(path.join(projectDir, ".env"), [{
-		key: "ALCHEMY_PASSWORD",
-		value: "please-change-this",
-		condition: true
-	}]);
-	else if (isIndividualAlchemy) {
-		if (webDeploy === "alchemy") {
-			const webDir = path.join(projectDir, "apps/web");
-			if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), [{
-				key: "ALCHEMY_PASSWORD",
-				value: "please-change-this",
-				condition: true
-			}]);
-		}
-		if (serverDeploy === "alchemy") {
-			const serverAlchemyVars = [{
-				key: "ALCHEMY_PASSWORD",
-				value: "please-change-this",
-				condition: true
-			}];
-			if (backend === "self") {
-				const webDir = path.join(projectDir, "apps/web");
-				if (await fs.pathExists(webDir)) await addEnvVariablesToFile(path.join(webDir, ".env"), serverAlchemyVars);
-			} else await addEnvVariablesToFile(path.join(serverDir, ".env"), serverAlchemyVars);
-		}
+	if (webDeploy === "cloudflare" && serverDeploy === "cloudflare" || webDeploy === "cloudflare" || serverDeploy === "cloudflare") {
+		const infraDir = path.join(projectDir, "packages/infra");
+		if (await fs.pathExists(infraDir)) await addEnvVariablesToFile(path.join(infraDir, ".env"), [{
+			key: "ALCHEMY_PASSWORD",
+			value: "please-change-this",
+			condition: true
+		}]);
 	}
 }
 
@@ -4792,7 +4747,7 @@ ${hasWebFrontend$1 ? "# npx convex env set SITE_URL http://localhost:3001\n" : "
 //#region src/helpers/database-providers/d1-setup.ts
 async function setupCloudflareD1(config) {
 	const { projectDir, serverDeploy, orm, backend } = config;
-	if (serverDeploy === "alchemy" && orm === "prisma") {
+	if (serverDeploy === "cloudflare" && orm === "prisma") {
 		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
 		await addEnvVariablesToFile(path.join(projectDir, targetApp2, ".env"), [{
 			key: "DATABASE_URL",
@@ -4838,8 +4793,8 @@ function getDatabaseUrl(database, projectName) {
 //#region src/utils/command-exists.ts
 async function commandExists(command) {
 	try {
-		if (process.platform === "win32") return (await execa("where", [command])).exitCode === 0;
-		return (await execa("which", [command])).exitCode === 0;
+		if (process.platform === "win32") return (await $({ reject: false })`where ${command}`).exitCode === 0;
+		return (await $({ reject: false })`which ${command}`).exitCode === 0;
 	} catch {
 		return false;
 	}
@@ -4866,11 +4821,10 @@ async function initMongoDBAtlas(serverDir) {
 			return null;
 		}
 		log.info("Running MongoDB Atlas setup...");
-		await execa("atlas", ["deployments", "setup"], {
+		await $({
 			cwd: serverDir,
-			shell: true,
 			stdio: "inherit"
-		});
+		})`atlas deployments setup`;
 		log.success("MongoDB Atlas deployment ready");
 		const connectionString = await text({
 			message: "Enter your MongoDB connection string:",
@@ -5008,9 +4962,9 @@ const NEON_REGIONS = [
 async function executeNeonCommand(packageManager, commandArgsString, spinnerText) {
 	const s = spinner();
 	try {
-		const fullCommand = getPackageExecutionCommand(packageManager, commandArgsString);
+		const args = getPackageExecutionArgs(packageManager, commandArgsString);
 		if (spinnerText) s.start(spinnerText);
-		const result = await execa(fullCommand, { shell: true });
+		const result = await $`${args}`;
 		if (spinnerText) s.stop(pc.green(spinnerText.replace("...", "").replace("ing ", "ed ").trim()));
 		return result;
 	} catch (error) {
@@ -5055,10 +5009,8 @@ async function setupWithNeonDb(projectDir, packageManager, backend) {
 		const targetApp = backend === "self" ? "apps/web" : "apps/server";
 		const targetDir = path.join(projectDir, targetApp);
 		await fs.ensureDir(targetDir);
-		await execa(getPackageExecutionCommand(packageManager, "get-db@latest --yes"), {
-			shell: true,
-			cwd: targetDir
-		});
+		const packageArgs = getPackageExecutionArgs(packageManager, "get-db@latest --yes");
+		await $({ cwd: targetDir })`${packageArgs}`;
 		s.stop(pc.green("Neon database created successfully!"));
 		return true;
 	} catch (error) {
@@ -5244,13 +5196,10 @@ async function setupWithCreateDb(serverDir, packageManager) {
 			initialValue: "ap-southeast-1"
 		});
 		if (isCancel(selectedRegion)) return null;
-		const createDbCommand = getPackageExecutionCommand(packageManager, `create-db@latest --json --region ${selectedRegion}`);
+		const createDbArgs = getPackageExecutionArgs(packageManager, `create-db@latest --json --region ${selectedRegion}`);
 		const s = spinner();
 		s.start("Creating Prisma Postgres database...");
-		const { stdout } = await execa(createDbCommand, {
-			cwd: serverDir,
-			shell: true
-		});
+		const { stdout } = await $({ cwd: serverDir })`${createDbArgs}`;
 		s.stop("Database created successfully!");
 		let createDbResponse;
 		try {
@@ -5377,11 +5326,11 @@ function extractDbUrl(output) {
 async function initializeSupabase(serverDir, packageManager) {
 	log.info("Initializing Supabase project...");
 	try {
-		await execa(getPackageExecutionCommand(packageManager, "supabase init"), {
+		const supabaseInitArgs = getPackageExecutionArgs(packageManager, "supabase init");
+		await $({
 			cwd: serverDir,
-			stdio: "inherit",
-			shell: true
-		});
+			stdio: "inherit"
+		})`${supabaseInitArgs}`;
 		log.success("Supabase project initialized");
 		return true;
 	} catch (error) {
@@ -5397,12 +5346,9 @@ async function initializeSupabase(serverDir, packageManager) {
 }
 async function startSupabase(serverDir, packageManager) {
 	log.info("Starting Supabase services (this may take a moment)...");
-	const supabaseStartCommand = getPackageExecutionCommand(packageManager, "supabase start");
+	const supabaseStartArgs = getPackageExecutionArgs(packageManager, "supabase start");
 	try {
-		const subprocess = execa(supabaseStartCommand, {
-			cwd: serverDir,
-			shell: true
-		});
+		const subprocess = execa(supabaseStartArgs[0], supabaseStartArgs.slice(1), { cwd: serverDir });
 		let stdoutData = "";
 		if (subprocess.stdout) subprocess.stdout.on("data", (data) => {
 			const text$1 = data.toString();
@@ -6200,15 +6146,35 @@ BETTER_AUTH_URL={your-production-server-domain}
 }
 function generateDeploymentCommands(packageManagerRunCmd, webDeploy, serverDeploy) {
 	const lines = [];
-	if (webDeploy === "alchemy" || serverDeploy === "alchemy") {
-		lines.push("## Deployment (Alchemy)");
-		if (webDeploy === "alchemy" && serverDeploy !== "alchemy") lines.push(`- Web dev: cd apps/web && ${packageManagerRunCmd} dev`, `- Web deploy: cd apps/web && ${packageManagerRunCmd} deploy`, `- Web destroy: cd apps/web && ${packageManagerRunCmd} destroy`);
-		if (serverDeploy === "alchemy" && webDeploy !== "alchemy") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`, `- Server destroy: cd apps/server && ${packageManagerRunCmd} destroy`);
-		if (webDeploy === "alchemy" && serverDeploy === "alchemy") lines.push(`- Dev: ${packageManagerRunCmd} dev`, `- Deploy: ${packageManagerRunCmd} deploy`, `- Destroy: ${packageManagerRunCmd} destroy`);
+	if (webDeploy === "cloudflare" || serverDeploy === "cloudflare") {
+		lines.push("## Deployment (Cloudflare via Alchemy)");
+		if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") lines.push(`- Web dev: cd apps/web && ${packageManagerRunCmd} dev`, `- Web deploy: cd apps/web && ${packageManagerRunCmd} deploy`, `- Web destroy: cd apps/web && ${packageManagerRunCmd} destroy`);
+		if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`, `- Server destroy: cd apps/server && ${packageManagerRunCmd} destroy`);
+		if (webDeploy === "cloudflare" && serverDeploy === "cloudflare") lines.push(`- Dev: ${packageManagerRunCmd} dev`, `- Deploy: ${packageManagerRunCmd} deploy`, `- Destroy: ${packageManagerRunCmd} destroy`);
 	}
 	return lines.length ? `\n${lines.join("\n")}\n` : "";
 }
 
+//#endregion
+//#region src/helpers/core/env-package-setup.ts
+async function setupEnvPackageDependencies(projectDir, options) {
+	const envDir = path.join(projectDir, "packages/env");
+	if (!await fs.pathExists(envDir)) return;
+	await addPackageDependency({
+		dependencies: getT3EnvDeps(options),
+		projectDir: envDir
+	});
+}
+function getT3EnvDeps(options) {
+	const deps = ["zod"];
+	const { frontend, backend, runtime } = options;
+	if (frontend.includes("next")) deps.push("@t3-oss/env-nextjs");
+	else if (frontend.includes("nuxt")) deps.push("@t3-oss/env-nuxt");
+	else deps.push("@t3-oss/env-core");
+	if (backend !== "convex" && backend !== "none" && runtime !== "workers" && !deps.includes("@t3-oss/env-core")) deps.push("@t3-oss/env-core");
+	return deps;
+}
+
 //#endregion
 //#region src/helpers/core/git.ts
 async function initializeGit(projectDir, useGit) {
@@ -6231,6 +6197,17 @@ async function initializeGit(projectDir, useGit) {
 	await $({ cwd: projectDir })`git commit -m ${"initial commit"}`;
 }
 
+//#endregion
+//#region src/helpers/core/infra-package-setup.ts
+async function setupInfraPackageDependencies(projectDir, _options) {
+	const infraDir = path.join(projectDir, "packages/infra");
+	if (!await fs.pathExists(infraDir)) return;
+	await addPackageDependency({
+		devDependencies: ["alchemy"],
+		projectDir: infraDir
+	});
+}
+
 //#endregion
 //#region src/helpers/core/payments-setup.ts
 async function setupPayments(config) {
@@ -6417,7 +6394,7 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 			instructions.push("");
 		}
 	}
-	if (dbSetup === "d1" && serverDeploy === "alchemy") {
+	if (dbSetup === "d1" && serverDeploy === "cloudflare") {
 		if (orm === "drizzle") instructions.push(`${pc.cyan("•")} Generate migrations: ${`${runCmd} db:generate`}`);
 		else if (orm === "prisma") {
 			instructions.push(`${pc.cyan("•")} Generate Prisma client: ${`${runCmd} db:generate`}`);
@@ -6432,15 +6409,15 @@ async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup,
 	if (orm === "prisma") {
 		if (database === "mongodb" && dbSetup === "docker") instructions.push(`${pc.yellow("WARNING:")} Prisma + MongoDB + Docker combination\n   may not work.`);
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
-		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) {
+		if (!(dbSetup === "d1" && serverDeploy === "cloudflare")) {
 			instructions.push(`${pc.cyan("•")} Generate Prisma Client: ${`${runCmd} db:generate`}`);
 			instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
 		}
-		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+		if (!(dbSetup === "d1" && serverDeploy === "cloudflare")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 	} else if (orm === "drizzle") {
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 		if (dbSetup !== "d1") instructions.push(`${pc.cyan("•")} Apply schema: ${`${runCmd} db:push`}`);
-		if (!(dbSetup === "d1" && serverDeploy === "alchemy")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
+		if (!(dbSetup === "d1" && serverDeploy === "cloudflare")) instructions.push(`${pc.cyan("•")} Database UI: ${`${runCmd} db:studio`}`);
 	} else if (orm === "mongoose") {
 		if (dbSetup === "docker") instructions.push(`${pc.cyan("•")} Start docker container: ${`${runCmd} db:start`}`);
 	} else if (orm === "none") instructions.push(`${pc.yellow("NOTE:")} Manual database schema setup\n   required.`);
@@ -6471,116 +6448,174 @@ function getPolarInstructions(backend) {
 function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
 	const isBackendSelf = backend === "self";
-	if (webDeploy === "alchemy" && serverDeploy !== "alchemy") instructions.push(`${pc.bold("Deploy web with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
-	else if (serverDeploy === "alchemy" && webDeploy !== "alchemy" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
-	else if (webDeploy === "alchemy" && (serverDeploy === "alchemy" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Alchemy:")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") instructions.push(`${pc.bold("Deploy web with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
+	else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
+	else if (webDeploy === "cloudflare" && (serverDeploy === "cloudflare" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Alchemy:")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
 //#endregion
 //#region src/helpers/core/workspace-setup.ts
 async function setupWorkspaceDependencies(projectDir, options) {
-	const { projectName, packageManager, database, auth, api, runtime, backend } = options;
+	const { projectName, packageManager, runtime, backend } = options;
 	const workspaceVersion = packageManager === "npm" ? "*" : "workspace:*";
-	const commonDeps = ["dotenv", "zod"];
-	const commonDevDeps = ["typescript"];
-	const configDir = path.join(projectDir, "packages/config");
-	const dbDir = path.join(projectDir, "packages/db");
-	const authDir = path.join(projectDir, "packages/auth");
-	const apiDir = path.join(projectDir, "packages/api");
-	const backendDir = path.join(projectDir, "packages/backend");
-	const serverDir = path.join(projectDir, "apps/server");
-	const webDir = path.join(projectDir, "apps/web");
-	const nativeDir = path.join(projectDir, "apps/native");
-	const [configExists, dbExists, authExists, apiExists, backendExists, serverExists, webExists, nativeExists] = await Promise.all([
-		fs.pathExists(configDir),
-		fs.pathExists(dbDir),
-		fs.pathExists(authDir),
-		fs.pathExists(apiDir),
-		fs.pathExists(backendDir),
-		fs.pathExists(serverDir),
-		fs.pathExists(webDir),
-		fs.pathExists(nativeDir)
+	const packages = await detectPackages(projectDir);
+	const configDep = packages.config.exists ? { [`@${projectName}/config`]: workspaceVersion } : {};
+	const envDep = packages.env.exists ? { [`@${projectName}/env`]: workspaceVersion } : {};
+	const ctx = {
+		projectName,
+		workspaceVersion,
+		options,
+		commonDeps: ["dotenv", "zod"],
+		commonDevDeps: ["typescript"],
+		configDep,
+		envDep
+	};
+	await Promise.all([
+		setupEnvPackage(packages.env, packages.infra, ctx),
+		setupInfraPackage(packages.infra, ctx),
+		setupDbPackage(packages.db, ctx),
+		setupAuthPackage(packages.auth, packages.db, ctx),
+		setupApiPackage(packages.api, packages.auth, packages.db, ctx),
+		setupBackendPackage(packages.backend, ctx),
+		setupServerPackage(packages.server, packages.api, packages.auth, packages.db, ctx),
+		setupWebPackage(packages.web, packages.api, packages.auth, packages.backend, ctx),
+		setupNativePackage(packages.native, packages.api, packages.backend, ctx)
 	]);
-	const configDep = configExists ? { [`@${projectName}/config`]: workspaceVersion } : {};
-	if (dbExists) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
+	const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: [...ctx.commonDevDeps, ...runtimeDevDeps],
+		customDependencies: envDep,
 		customDevDependencies: configDep,
-		projectDir: dbDir
+		projectDir
 	});
-	if (authExists) {
-		const authDeps = {};
-		if (database !== "none" && dbExists) authDeps[`@${projectName}/db`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
-			customDependencies: authDeps,
-			customDevDependencies: configDep,
-			projectDir: authDir
-		});
-	}
-	if (apiExists) {
-		const apiDeps = {};
-		if (auth !== "none" && authExists) apiDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (database !== "none" && dbExists) apiDeps[`@${projectName}/db`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
-			customDependencies: apiDeps,
-			customDevDependencies: configDep,
-			projectDir: apiDir
-		});
-	}
-	if (backendExists) await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: commonDevDeps,
-		customDevDependencies: configDep,
-		projectDir: backendDir
+}
+async function detectPackages(projectDir) {
+	const entries = await Promise.all(Object.entries({
+		config: "packages/config",
+		env: "packages/env",
+		infra: "packages/infra",
+		db: "packages/db",
+		auth: "packages/auth",
+		api: "packages/api",
+		backend: "packages/backend",
+		server: "apps/server",
+		web: "apps/web",
+		native: "apps/native"
+	}).map(async ([name, relativePath]) => {
+		const dir = path.join(projectDir, relativePath);
+		return [name, {
+			dir,
+			exists: await fs.pathExists(dir)
+		}];
+	}));
+	return Object.fromEntries(entries);
+}
+async function setupEnvPackage(pkg, infraPkg, ctx) {
+	if (!pkg.exists) return;
+	const runtimeDevDeps = getRuntimeDevDeps(ctx.options.runtime, ctx.options.backend);
+	const customDevDeps = { ...ctx.configDep };
+	if ((ctx.options.serverDeploy === "cloudflare" || ctx.options.webDeploy === "cloudflare") && infraPkg.exists) customDevDeps[`@${ctx.projectName}/infra`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: [...ctx.commonDevDeps, ...runtimeDevDeps],
+		customDevDependencies: customDevDeps,
+		projectDir: pkg.dir
 	});
-	if (serverExists) {
-		const serverDeps = {};
-		if (api !== "none" && apiExists) serverDeps[`@${projectName}/api`] = workspaceVersion;
-		if (auth !== "none" && authExists) serverDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (database !== "none" && dbExists) serverDeps[`@${projectName}/db`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: [...commonDevDeps, "tsdown"],
-			customDependencies: serverDeps,
-			customDevDependencies: configDep,
-			projectDir: serverDir
-		});
-	}
-	if (webExists) {
-		const webDeps = {};
-		if (api !== "none" && apiExists) webDeps[`@${projectName}/api`] = workspaceVersion;
-		if (auth !== "none" && authExists) webDeps[`@${projectName}/auth`] = workspaceVersion;
-		if (backend === "convex" && backendExists) webDeps[`@${projectName}/backend`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
-			customDependencies: webDeps,
-			customDevDependencies: configDep,
-			projectDir: webDir
-		});
-	}
-	if (nativeExists) {
-		const nativeDeps = {};
-		if (api !== "none" && apiExists) nativeDeps[`@${projectName}/api`] = workspaceVersion;
-		if (backend === "convex" && backendExists) nativeDeps[`@${projectName}/backend`] = workspaceVersion;
-		await addPackageDependency({
-			dependencies: commonDeps,
-			devDependencies: commonDevDeps,
-			customDependencies: nativeDeps,
-			customDevDependencies: configDep,
-			projectDir: nativeDir
-		});
-	}
-	const runtimeDevDeps = getRuntimeDevDeps(runtime, backend);
+}
+async function setupInfraPackage(pkg, ctx) {
+	if (!pkg.exists) return;
 	await addPackageDependency({
-		dependencies: commonDeps,
-		devDependencies: [...commonDevDeps, ...runtimeDevDeps],
-		projectDir
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupDbPackage(pkg, ctx) {
+	if (!pkg.exists) return;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDependencies: ctx.envDep,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupAuthPackage(pkg, dbPkg, ctx) {
+	if (!pkg.exists) return;
+	const deps = { ...ctx.envDep };
+	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDependencies: deps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupApiPackage(pkg, authPkg, dbPkg, ctx) {
+	if (!pkg.exists) return;
+	const deps = { ...ctx.envDep };
+	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
+	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDependencies: deps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupBackendPackage(pkg, ctx) {
+	if (!pkg.exists) return;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupServerPackage(pkg, apiPkg, authPkg, dbPkg, ctx) {
+	if (!pkg.exists) return;
+	const deps = { ...ctx.envDep };
+	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
+	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
+	if (ctx.options.database !== "none" && dbPkg.exists) deps[`@${ctx.projectName}/db`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: [...ctx.commonDevDeps, "tsdown"],
+		customDependencies: deps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupWebPackage(pkg, apiPkg, authPkg, backendPkg, ctx) {
+	if (!pkg.exists) return;
+	const deps = { ...ctx.envDep };
+	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
+	if (ctx.options.auth !== "none" && authPkg.exists) deps[`@${ctx.projectName}/auth`] = ctx.workspaceVersion;
+	if (ctx.options.backend === "convex" && backendPkg.exists) deps[`@${ctx.projectName}/backend`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDependencies: deps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
+	});
+}
+async function setupNativePackage(pkg, apiPkg, backendPkg, ctx) {
+	if (!pkg.exists) return;
+	const deps = { ...ctx.envDep };
+	if (ctx.options.api !== "none" && apiPkg.exists) deps[`@${ctx.projectName}/api`] = ctx.workspaceVersion;
+	if (ctx.options.backend === "convex" && backendPkg.exists) deps[`@${ctx.projectName}/backend`] = ctx.workspaceVersion;
+	await addPackageDependency({
+		dependencies: ctx.commonDeps,
+		devDependencies: ctx.commonDevDeps,
+		customDependencies: deps,
+		customDevDependencies: ctx.configDep,
+		projectDir: pkg.dir
 	});
 }
 function getRuntimeDevDeps(runtime, backend) {
@@ -6617,7 +6652,7 @@ async function updateRootPackageJson(projectDir, options) {
 	const dbPackageName = `@${projectName}/db`;
 	const hasTurborepo = addons.includes("turborepo");
 	const needsDbScripts = backend !== "convex" && database !== "none" && orm !== "none" && orm !== "mongoose";
-	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "alchemy";
+	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "cloudflare";
 	const pmConfig = getPackageManagerConfig(packageManager, hasTurborepo);
 	scripts.dev = pmConfig.dev;
 	scripts.build = pmConfig.build;
@@ -6645,7 +6680,7 @@ async function updateRootPackageJson(projectDir, options) {
 		scripts["db:down"] = pmConfig.filter(dbPackageName, "db:down");
 	}
 	try {
-		const { stdout } = await execa(packageManager, ["-v"], { cwd: projectDir });
+		const { stdout } = await $`${packageManager} -v`;
 		packageJson.packageManager = `${packageManager}@${stdout.trim()}`;
 	} catch {
 		log.warn(`Could not determine ${packageManager} version.`);
@@ -6702,7 +6737,7 @@ async function updateDbPackageJson(projectDir, options) {
 	dbPackageJson.scripts = dbPackageJson.scripts || {};
 	const scripts = dbPackageJson.scripts;
 	const { database, orm, dbSetup, serverDeploy } = options;
-	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "alchemy";
+	const isD1Alchemy = dbSetup === "d1" && serverDeploy === "cloudflare";
 	if (database !== "none") {
 		if (database === "sqlite" && dbSetup !== "d1") scripts["db:local"] = "turso dev --db-file local.db";
 		if (orm === "prisma") {
@@ -6752,7 +6787,8 @@ async function updateConvexPackageJson(projectDir, options) {
 
 //#endregion
 //#region src/helpers/core/create-project.ts
-async function createProject(options, cliInput) {
+async function createProject(options, cliInput = {}) {
+	const { silent = false } = cliInput;
 	const projectDir = options.projectDir;
 	const isConvex = options.backend === "convex";
 	const isSelfBackend = options.backend === "self";
@@ -6768,6 +6804,8 @@ async function createProject(options, cliInput) {
 		if (options.examples.length > 0 && options.examples[0] !== "none") await setupExamplesTemplate(projectDir, options);
 		await setupAddonsTemplate(projectDir, options);
 		await setupDeploymentTemplates(projectDir, options);
+		await setupEnvPackageDependencies(projectDir, options);
+		if (options.serverDeploy === "cloudflare" || options.webDeploy === "cloudflare") await setupInfraPackageDependencies(projectDir, options);
 		await setupApi(options);
 		if (isConvex || needsServerSetup) await setupBackendDependencies(options);
 		if (!isConvex) {
@@ -6786,23 +6824,23 @@ async function createProject(options, cliInput) {
 		await setupCatalogs(projectDir, options);
 		await createReadme(projectDir, options);
 		await writeBtsConfig(options);
-		log.success("Project template successfully scaffolded!");
+		if (!silent) log.success("Project template successfully scaffolded!");
 		if (options.install) await installDependencies({
 			projectDir,
 			packageManager: options.packageManager
 		});
 		await initializeGit(projectDir, options.git);
-		await displayPostInstallInstructions({
+		if (!silent) await displayPostInstallInstructions({
 			...options,
 			depsInstalled: options.install
 		});
 		return projectDir;
 	} catch (error) {
 		if (error instanceof Error) {
-			console.error(error.stack);
+			if (!silent) console.error(error.stack);
 			exitWithError(`Error during project creation: ${error.message}`);
 		} else {
-			console.error(error);
+			if (!silent) console.error(error);
 			exitWithError(`An unexpected error occurred: ${String(error)}`);
 		}
 	}
@@ -6810,12 +6848,13 @@ async function createProject(options, cliInput) {
 
 //#endregion
 //#region src/helpers/core/command-handlers.ts
-async function createProjectHandler(input) {
+async function createProjectHandler(input, options = {}) {
+	const { silent = false } = options;
 	const startTime = Date.now();
 	const timeScaffolded = (/* @__PURE__ */ new Date()).toISOString();
-	if (input.renderTitle !== false) renderTitle();
-	intro(pc.magenta("Creating a new Better-T-Stack project"));
-	if (input.yolo) consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
+	if (!silent && input.renderTitle !== false) renderTitle();
+	if (!silent) intro(pc.magenta("Creating a new Better-T-Stack project"));
+	if (!silent && input.yolo) consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
 	let currentPathInput;
 	if (input.yes && input.projectName) currentPathInput = input.projectName;
 	else if (input.yes) {
@@ -6884,8 +6923,10 @@ async function createProjectHandler(input) {
 		if (templateConfig) {
 			const templateName = input.template.toUpperCase();
 			const templateDescription = getTemplateDescription(input.template);
-			log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
-			log.message(pc.dim(`   ${templateDescription}`));
+			if (!silent) {
+				log.message(pc.bold(pc.cyan(`Using template: ${pc.white(templateName)}`)));
+				log.message(pc.dim(`   ${templateDescription}`));
+			}
 			const userOverrides = {};
 			for (const [key, value] of Object.entries(originalInput)) if (value !== void 0) userOverrides[key] = value;
 			cliInput = {
@@ -6907,25 +6948,32 @@ async function createProjectHandler(input) {
 			relativePath: finalPathInput
 		};
 		validateConfigCompatibility(config, providedFlags, cliInput);
-		log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
-		log.message(displayConfig(config));
+		if (!silent) {
+			log.info(pc.yellow("Using default/flag options (config prompts skipped):"));
+			log.message(displayConfig(config));
+		}
 	} else {
 		const flagConfig = processAndValidateFlags(cliInput, providedFlags, finalBaseName);
 		const { projectName: _projectNameFromFlags, ...otherFlags } = flagConfig;
-		if (Object.keys(otherFlags).length > 0) {
+		if (!silent && Object.keys(otherFlags).length > 0) {
 			log.info(pc.yellow("Using these pre-selected options:"));
 			log.message(displayConfig(otherFlags));
 			log.message("");
 		}
 		config = await gatherConfig(flagConfig, finalBaseName, finalResolvedPath, finalPathInput);
 	}
-	await createProject(config, { manualDb: cliInput.manualDb ?? input.manualDb });
+	await createProject(config, {
+		manualDb: cliInput.manualDb ?? input.manualDb,
+		silent
+	});
 	const reproducibleCommand = generateReproducibleCommand(config);
-	log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
+	if (!silent) log.success(pc.blue(`You can reproduce this setup with the following command:\n${reproducibleCommand}`));
 	await trackProjectCreation(config, input.disableAnalytics);
 	const elapsedTimeMs = Date.now() - startTime;
-	const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(2);
-	outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+	if (!silent) {
+		const elapsedTimeInSeconds = (elapsedTimeMs / 1e3).toFixed(2);
+		outro(pc.magenta(`Project created successfully in ${pc.bold(elapsedTimeInSeconds)} seconds!`));
+	}
 	return {
 		success: true,
 		projectConfig: config,
@@ -7037,25 +7085,12 @@ async function addAddonsHandler(input) {
 //#region src/utils/open-url.ts
 async function openUrl(url) {
 	const platform = process.platform;
-	let command;
-	let args = [];
-	if (platform === "darwin") {
-		command = "open";
-		args = [url];
-	} else if (platform === "win32") {
-		command = "cmd";
-		args = [
-			"/c",
-			"start",
-			"",
-			url.replace(/&/g, "^&")
-		];
-	} else {
-		command = "xdg-open";
-		args = [url];
-	}
 	try {
-		await execa(command, args, { stdio: "ignore" });
+		if (platform === "darwin") await $({ stdio: "ignore" })`open ${url}`;
+		else if (platform === "win32") {
+			const escapedUrl = url.replace(/&/g, "^&");
+			await $({ stdio: "ignore" })`cmd /c start "" ${escapedUrl}`;
+		} else await $({ stdio: "ignore" })`xdg-open ${url}`;
 	} catch {
 		log.message(`Please open ${url} in your browser.`);
 	}
@@ -7105,32 +7140,32 @@ function displaySponsorsBox(sponsors$1) {
 //#endregion
 //#region src/index.ts
 const router = os.router({
-	init: os.meta({
+	create: os.meta({
 		description: "Create a new Better-T-Stack project",
 		default: true,
 		negateBooleans: true
-	}).input(z.tuple([ProjectNameSchema.optional(), z.object({
-		template: TemplateSchema.optional().describe("Use a predefined template"),
+	}).input(z.tuple([types_exports.ProjectNameSchema.optional(), z.object({
+		template: types_exports.TemplateSchema.optional().describe("Use a predefined template"),
 		yes: z.boolean().optional().default(false).describe("Use default configuration"),
 		yolo: z.boolean().optional().default(false).describe("(WARNING - NOT RECOMMENDED) Bypass validations and compatibility checks"),
 		verbose: z.boolean().optional().default(false).describe("Show detailed result information"),
-		database: DatabaseSchema.optional(),
-		orm: ORMSchema.optional(),
-		auth: AuthSchema.optional(),
-		payments: PaymentsSchema.optional(),
-		frontend: z.array(FrontendSchema).optional(),
-		addons: z.array(AddonsSchema).optional(),
-		examples: z.array(ExamplesSchema).optional(),
+		database: types_exports.DatabaseSchema.optional(),
+		orm: types_exports.ORMSchema.optional(),
+		auth: types_exports.AuthSchema.optional(),
+		payments: types_exports.PaymentsSchema.optional(),
+		frontend: z.array(types_exports.FrontendSchema).optional(),
+		addons: z.array(types_exports.AddonsSchema).optional(),
+		examples: z.array(types_exports.ExamplesSchema).optional(),
 		git: z.boolean().optional(),
-		packageManager: PackageManagerSchema.optional(),
+		packageManager: types_exports.PackageManagerSchema.optional(),
 		install: z.boolean().optional(),
-		dbSetup: DatabaseSetupSchema.optional(),
-		backend: BackendSchema.optional(),
-		runtime: RuntimeSchema.optional(),
-		api: APISchema.optional(),
-		webDeploy: WebDeploySchema.optional(),
-		serverDeploy: ServerDeploySchema.optional(),
-		directoryConflict: DirectoryConflictSchema.optional(),
+		dbSetup: types_exports.DatabaseSetupSchema.optional(),
+		backend: types_exports.BackendSchema.optional(),
+		runtime: types_exports.RuntimeSchema.optional(),
+		api: types_exports.APISchema.optional(),
+		webDeploy: types_exports.WebDeploySchema.optional(),
+		serverDeploy: types_exports.ServerDeploySchema.optional(),
+		directoryConflict: types_exports.DirectoryConflictSchema.optional(),
 		renderTitle: z.boolean().optional(),
 		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
 		manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup")
@@ -7143,12 +7178,12 @@ const router = os.router({
 		if (options.verbose) return result;
 	}),
 	add: os.meta({ description: "Add addons or deployment configurations to an existing Better-T-Stack project" }).input(z.tuple([z.object({
-		addons: z.array(AddonsSchema).optional().default([]),
-		webDeploy: WebDeploySchema.optional(),
-		serverDeploy: ServerDeploySchema.optional(),
+		addons: z.array(types_exports.AddonsSchema).optional().default([]),
+		webDeploy: types_exports.WebDeploySchema.optional(),
+		serverDeploy: types_exports.ServerDeploySchema.optional(),
 		projectDir: z.string().optional(),
 		install: z.boolean().optional().default(false).describe("Install dependencies after adding addons or deployment"),
-		packageManager: PackageManagerSchema.optional()
+		packageManager: types_exports.PackageManagerSchema.optional()
 	})])).handler(async ({ input }) => {
 		const [options] = input;
 		await addAddonsHandler(options);
@@ -7190,49 +7225,49 @@ function createBtsCli() {
 	});
 }
 /**
-* Initialize a new Better-T-Stack project
+* Programmatic API to create a new Better-T-Stack project.
+* Returns pure JSON - no console output, no interactive prompts.
 *
-* @example CLI usage:
-* ```bash
-* npx create-better-t-stack my-app --yes
-* ```
-*
-* @example Programmatic usage (always returns structured data):
+* @example
 * ```typescript
-* import { init } from "create-better-t-stack";
+* import { create } from "create-better-t-stack";
 *
-* const result = await init("my-app", {
-*   yes: true,
+* const result = await create("my-app", {
 *   frontend: ["tanstack-router"],
 *   backend: "hono",
+*   runtime: "bun",
 *   database: "sqlite",
 *   orm: "drizzle",
-*   auth: "better-auth",
-*   addons: ["biome", "turborepo"],
-*   packageManager: "bun",
-*   install: false,
-*   directoryConflict: "increment", // auto-handle conflicts
-*   disableAnalytics: true, // disable analytics
 * });
 *
 * if (result.success) {
 *   console.log(`Project created at: ${result.projectDirectory}`);
-*   console.log(`Reproducible command: ${result.reproducibleCommand}`);
-*   console.log(`Time taken: ${result.elapsedTimeMs}ms`);
 * }
 * ```
 */
-async function init(projectName, options) {
-	const programmaticOpts = {
-		...options ?? {},
-		verbose: true
+async function create(projectName, options) {
+	const input = {
+		...options,
+		projectName,
+		renderTitle: false,
+		verbose: true,
+		disableAnalytics: options?.disableAnalytics ?? true,
+		directoryConflict: options?.directoryConflict ?? "error"
 	};
-	const prev = process.env.BTS_PROGRAMMATIC;
-	process.env.BTS_PROGRAMMATIC = "1";
-	const result = await caller.init([projectName, programmaticOpts]);
-	if (prev === void 0) delete process.env.BTS_PROGRAMMATIC;
-	else process.env.BTS_PROGRAMMATIC = prev;
-	return result;
+	try {
+		return await createProjectHandler(input, { silent: true });
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : String(error),
+			projectConfig: {},
+			reproducibleCommand: "",
+			timeScaffolded: (/* @__PURE__ */ new Date()).toISOString(),
+			elapsedTimeMs: 0,
+			projectDirectory: "",
+			relativePath: ""
+		};
+	}
 }
 async function sponsors() {
 	return caller.sponsors();
@@ -7245,4 +7280,4 @@ async function builder() {
 }
 
 //#endregion
-export { router as a, init as i, createBtsCli as n, sponsors as o, docs as r, builder as t };
+export { router as a, docs as i, create as n, sponsors as o, createBtsCli as r, builder as t };