create-better-t-stack 3.4.1 → 3.4.2-canary.39d948b7

package/dist/{src-_EdtPnBT.js → src-BEzWAB2k.js}

@@ -72,6 +72,7 @@ const dependencyVersionMap = {
 	"drizzle-kit": "^0.31.2",
 	"@planetscale/database": "^1.19.0",
 	"@libsql/client": "^0.14.0",
+	libsql: "^0.5.22",
 	"@neondatabase/serverless": "^1.0.1",
 	pg: "^8.14.1",
 	"@types/pg": "^8.11.11",
@@ -81,7 +82,6 @@ const dependencyVersionMap = {
 	"@prisma/client": "^6.15.0",
 	prisma: "^6.15.0",
 	"@prisma/adapter-d1": "^6.15.0",
-	"@prisma/extension-accelerate": "^2.0.2",
 	"@prisma/adapter-libsql": "^6.15.0",
 	"@prisma/adapter-planetscale": "^6.15.0",
 	mongoose: "^8.14.0",
@@ -279,16 +279,8 @@ const ProjectNameSchema = z.string().min(1, "Project name cannot be empty").max(
 		"*"
 	].some((char) => name.includes(char));
 }, "Project name contains invalid characters").refine((name) => name.toLowerCase() !== "node_modules", "Project name is reserved").describe("Project name or path");
-const WebDeploySchema = z.enum([
-	"wrangler",
-	"alchemy",
-	"none"
-]).describe("Web deployment");
-const ServerDeploySchema = z.enum([
-	"wrangler",
-	"alchemy",
-	"none"
-]).describe("Server deployment");
+const WebDeploySchema = z.enum(["alchemy", "none"]).describe("Web deployment");
+const ServerDeploySchema = z.enum(["alchemy", "none"]).describe("Server deployment");
 const DirectoryConflictSchema = z.enum([
 	"merge",
 	"overwrite",
@@ -1132,10 +1124,6 @@ async function getRuntimeChoice(runtime, backend) {
 //#endregion
 //#region src/prompts/server-deploy.ts
 function getDeploymentDisplay$1(deployment) {
-	if (deployment === "wrangler") return {
-		label: "Wrangler",
-		hint: "Deploy to Cloudflare Workers using Wrangler"
-	};
 	if (deployment === "alchemy") return {
 		label: "Alchemy",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
@@ -1145,40 +1133,17 @@ function getDeploymentDisplay$1(deployment) {
 		hint: `Add ${deployment} deployment`
 	};
 }
-async function getServerDeploymentChoice(deployment, runtime, backend, webDeploy) {
+async function getServerDeploymentChoice(deployment, runtime, backend, _webDeploy) {
 	if (deployment !== void 0) return deployment;
 	if (backend === "none" || backend === "convex") return "none";
 	if (backend !== "hono") return "none";
-	const options = [];
-	if (runtime !== "workers") return "none";
-	["alchemy", "wrangler"].forEach((deploy) => {
-		const { label, hint } = getDeploymentDisplay$1(deploy);
-		options.unshift({
-			value: deploy,
-			label,
-			hint
-		});
-	});
-	const response = await select({
-		message: "Select server deployment",
-		options,
-		initialValue: webDeploy === "alchemy" ? "alchemy" : runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
-	});
-	if (isCancel(response)) return exitCancelled("Operation cancelled");
-	return response;
+	if (runtime === "workers") return "alchemy";
+	return "none";
 }
 async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	if (backend !== "hono") return "none";
 	const options = [];
 	if (runtime === "workers") {
-		if (existingDeployment !== "wrangler") {
-			const { label, hint } = getDeploymentDisplay$1("wrangler");
-			options.push({
-				value: "wrangler",
-				label,
-				hint
-			});
-		}
 		if (existingDeployment !== "alchemy") {
 			const { label, hint } = getDeploymentDisplay$1("alchemy");
 			options.push({
@@ -1194,7 +1159,7 @@ async function getServerDeploymentToAdd(runtime, existingDeployment, backend) {
 	const response = await select({
 		message: "Select server deployment",
 		options,
-		initialValue: runtime === "workers" ? "wrangler" : DEFAULT_CONFIG.serverDeploy
+		initialValue: DEFAULT_CONFIG.serverDeploy
 	});
 	if (isCancel(response)) return exitCancelled("Operation cancelled");
 	return response;
@@ -1206,10 +1171,6 @@ function hasWebFrontend(frontends) {
 	return frontends.some((f) => WEB_FRAMEWORKS.includes(f));
 }
 function getDeploymentDisplay(deployment) {
-	if (deployment === "wrangler") return {
-		label: "Wrangler",
-		hint: "Deploy to Cloudflare Workers using Wrangler"
-	};
 	if (deployment === "alchemy") return {
 		label: "Alchemy",
 		hint: "Deploy to Cloudflare Workers using Alchemy"
@@ -1224,11 +1185,7 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 	if (!hasWebFrontend(frontend)) return "none";
 	const response = await select({
 		message: "Select web deployment",
-		options: [
-			"wrangler",
-			"alchemy",
-			"none"
-		].map((deploy) => {
+		options: ["alchemy", "none"].map((deploy) => {
 			const { label, hint } = getDeploymentDisplay(deploy);
 			return {
 				value: deploy,
@@ -1244,14 +1201,6 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 async function getDeploymentToAdd(frontend, existingDeployment) {
 	if (!hasWebFrontend(frontend)) return "none";
 	const options = [];
-	if (existingDeployment !== "wrangler") {
-		const { label, hint } = getDeploymentDisplay("wrangler");
-		options.push({
-			value: "wrangler",
-			label,
-			hint
-		});
-	}
 	if (existingDeployment !== "alchemy") {
 		const { label, hint } = getDeploymentDisplay("alchemy");
 		options.push({
@@ -1387,7 +1336,7 @@ const getLatestCLIVersion = () => {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
+	const BTS_TELEMETRY = "0";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -1395,8 +1344,8 @@ function isTelemetryEnabled() {
 
 //#endregion
 //#region src/utils/analytics.ts
-const POSTHOG_API_KEY = "phc_8ZUxEwwfKMajJLvxz1daGd931dYbQrwKNficBmsdIrs";
-const POSTHOG_HOST = "https://us.i.posthog.com";
+const POSTHOG_API_KEY = "random";
+const POSTHOG_HOST = "random";
 function generateSessionId() {
 	const rand = Math.random().toString(36).slice(2);
 	return `cli_${Date.now().toString(36)}${rand}`;
@@ -1815,8 +1764,8 @@ function validateFullConfig(config, providedFlags, options) {
 	validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
 	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 'wrangler' or 'alchemy' for --server-deploy.");
-	if (providedFlags.has("serverDeploy") && (config.serverDeploy === "alchemy" || config.serverDeploy === "wrangler") && config.runtime !== "workers") exitWithError(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
+	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 (config.addons && config.addons.length > 0) {
 		validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
 		config.addons = [...new Set(config.addons)];
@@ -3227,14 +3176,14 @@ async function setupDeploymentTemplates(projectDir, context) {
 			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);
-				await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+				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);
-					await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
+					if (!isBackendSelf) await addEnvDtsToPackages(projectDir, context, alchemyTemplateSrc);
 				}
 			}
 			if (context.serverDeploy === "alchemy" && !isBackendSelf) {
@@ -3338,54 +3287,13 @@ async function addAddonsToProject(input) {
 //#region src/helpers/deployment/server-deploy-setup.ts
 async function setupServerDeploy(config) {
 	const { serverDeploy, webDeploy, projectDir } = config;
-	const { packageManager } = 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 === "wrangler") {
-		await setupWorkersServerDeploy(serverDir, packageManager);
-		await generateCloudflareWorkerTypes({
-			serverDir,
-			packageManager
-		});
-	} else if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, packageManager, projectDir);
+	if (serverDeploy === "alchemy") await setupAlchemyServerDeploy(serverDir, projectDir);
 }
-async function setupWorkersServerDeploy(serverDir, _packageManager) {
-	const packageJsonPath = path.join(serverDir, "package.json");
-	if (!await fs.pathExists(packageJsonPath)) return;
-	const packageJson = await fs.readJson(packageJsonPath);
-	packageJson.scripts = {
-		...packageJson.scripts,
-		dev: "wrangler dev --port=3000",
-		start: "wrangler dev",
-		deploy: "wrangler deploy",
-		build: "wrangler deploy --dry-run",
-		"cf-typegen": "wrangler types --env-interface CloudflareBindings"
-	};
-	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	await addPackageDependency({
-		devDependencies: ["wrangler", "@types/node"],
-		projectDir: serverDir
-	});
-}
-async function generateCloudflareWorkerTypes({ serverDir, packageManager }) {
-	if (!await fs.pathExists(serverDir)) return;
-	const s = spinner();
-	try {
-		s.start("Generating Cloudflare Workers types...");
-		await execa(getPackageExecutionCommand(packageManager, "wrangler types --env-interface CloudflareBindings"), {
-			cwd: serverDir,
-			shell: true
-		});
-		s.stop("Cloudflare Workers types generated successfully!");
-	} catch {
-		s.stop(pc.yellow("Failed to generate Cloudflare Workers types"));
-		const managerCmd = `${packageManager} run`;
-		log.warn(`Note: You can manually run 'cd apps/server && ${managerCmd} cf-typegen' in the project directory later`);
-	}
-}
-async function setupAlchemyServerDeploy(serverDir, _packageManager, projectDir) {
+async function setupAlchemyServerDeploy(serverDir, projectDir) {
 	if (!await fs.pathExists(serverDir)) return;
 	await addPackageDependency({
 		devDependencies: [
@@ -3720,7 +3628,7 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 		await fs.writeJson(rootPkgPath, pkg, { spaces: 2 });
 	}
 	const serverDir = path.join(projectDir, "apps/server");
-	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, packageManager, projectDir);
+	if (await fs.pathExists(serverDir)) await setupAlchemyServerDeploy(serverDir, projectDir);
 	const frontend = config.frontend;
 	const isNext = frontend.includes("next");
 	const isNuxt = frontend.includes("nuxt");
@@ -3738,219 +3646,13 @@ async function setupCombinedAlchemyDeploy(projectDir, packageManager, config) {
 	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager, { skipAppScripts: true });
 }
 
-//#endregion
-//#region src/helpers/deployment/workers/workers-next-setup.ts
-async function setupNextWorkersDeploy(projectDir, _packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		dependencies: ["@opennextjs/cloudflare"],
-		devDependencies: ["wrangler"],
-		projectDir: webAppDir
-	});
-	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const pkg = await fs.readJson(packageJsonPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
-			deploy: "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
-			upload: "opennextjs-cloudflare build && opennextjs-cloudflare upload",
-			"cf-typegen": "wrangler types --env-interface CloudflareEnv cloudflare-env.d.ts"
-		};
-		await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-nuxt-setup.ts
-async function setupNuxtWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["nitro-cloudflare-dev", "wrangler"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const nuxtConfigPath = path.join(webAppDir, "nuxt.config.ts");
-	if (!await fs.pathExists(nuxtConfigPath)) return;
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(nuxtConfigPath);
-	if (!sourceFile) return;
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineNuxtConfig";
-	});
-	if (!defineCall) return;
-	const configObj = defineCall.getArguments()[0];
-	if (!configObj) return;
-	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-	const compatProp = configObj.getProperty("compatibilityDate");
-	if (compatProp && compatProp.getKind() === SyntaxKind.PropertyAssignment) compatProp.setInitializer(`'${today}'`);
-	else configObj.addPropertyAssignment({
-		name: "compatibilityDate",
-		initializer: `'${today}'`
-	});
-	const nitroInitializer = `{
-    preset: "cloudflare_module",
-    cloudflare: {
-      deployConfig: true,
-      nodeCompat: true
-    }
-  }`;
-	const nitroProp = configObj.getProperty("nitro");
-	if (nitroProp && nitroProp.getKind() === SyntaxKind.PropertyAssignment) nitroProp.setInitializer(nitroInitializer);
-	else configObj.addPropertyAssignment({
-		name: "nitro",
-		initializer: nitroInitializer
-	});
-	const modulesProp = configObj.getProperty("modules");
-	if (modulesProp && modulesProp.getKind() === SyntaxKind.PropertyAssignment) {
-		const arrayExpr = modulesProp.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
-		if (arrayExpr) {
-			if (!arrayExpr.getElements().some((el) => el.getText().replace(/['"`]/g, "") === "nitro-cloudflare-dev")) arrayExpr.addElement("'nitro-cloudflare-dev'");
-		}
-	} else configObj.addPropertyAssignment({
-		name: "modules",
-		initializer: "['nitro-cloudflare-dev']"
-	});
-	await tsProject.save();
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-svelte-setup.ts
-async function setupSvelteWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["@sveltejs/adapter-cloudflare", "wrangler"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types ./src/worker-configuration.d.ts"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const possibleConfigFiles = [path.join(webAppDir, "svelte.config.js"), path.join(webAppDir, "svelte.config.ts")];
-	const existingConfigPath = (await Promise.all(possibleConfigFiles.map(async (p) => await fs.pathExists(p) ? p : ""))).find((p) => p);
-	if (existingConfigPath) {
-		const sourceFile = tsProject.addSourceFileAtPathIfExists(existingConfigPath);
-		if (!sourceFile) return;
-		const adapterImport = sourceFile.getImportDeclarations().find((imp) => ["@sveltejs/adapter-auto", "@sveltejs/adapter-node"].includes(imp.getModuleSpecifierValue()));
-		if (adapterImport) adapterImport.setModuleSpecifier("@sveltejs/adapter-cloudflare");
-		else if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@sveltejs/adapter-cloudflare")) sourceFile.insertImportDeclaration(0, {
-			defaultImport: "adapter",
-			moduleSpecifier: "@sveltejs/adapter-cloudflare"
-		});
-		await tsProject.save();
-	}
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-tanstack-start-setup.ts
-async function setupTanstackStartWorkersDeploy(projectDir, packageManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	await addPackageDependency({
-		devDependencies: ["wrangler", "@cloudflare/vite-plugin"],
-		projectDir: webAppDir
-	});
-	const pkgPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(pkgPath)) {
-		const pkg = await fs.readJson(pkgPath);
-		pkg.scripts = {
-			...pkg.scripts,
-			deploy: `${packageManager} run build && wrangler deploy`,
-			"cf-typegen": "wrangler types --env-interface Env"
-		};
-		await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-	}
-	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
-	if (!await fs.pathExists(viteConfigPath)) return;
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) return;
-	const cfImport = sourceFile.getImportDeclaration("@cloudflare/vite-plugin");
-	if (!cfImport) sourceFile.addImportDeclaration({
-		moduleSpecifier: "@cloudflare/vite-plugin",
-		namedImports: [{ name: "cloudflare" }]
-	});
-	else if (!cfImport.getNamedImports().some((ni) => ni.getName() === "cloudflare")) cfImport.addNamedImport({ name: "cloudflare" });
-	const reactImport = sourceFile.getImportDeclaration("@vitejs/plugin-react");
-	let reactPluginIdentifier = "viteReact";
-	if (!reactImport) sourceFile.addImportDeclaration({
-		moduleSpecifier: "@vitejs/plugin-react",
-		defaultImport: "viteReact"
-	});
-	else {
-		const defaultImport = reactImport.getDefaultImport();
-		if (defaultImport) reactPluginIdentifier = defaultImport.getText();
-		else reactImport.setDefaultImport("viteReact");
-	}
-	const defineCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((expr) => {
-		const expression = expr.getExpression();
-		return Node.isIdentifier(expression) && expression.getText() === "defineConfig";
-	});
-	if (!defineCall) return;
-	const configObj = defineCall.getArguments()[0];
-	if (!configObj) return;
-	const pluginsArray = ensureArrayProperty(configObj, "plugins");
-	if (!pluginsArray.getElements().some((el) => el.getText().includes("cloudflare("))) pluginsArray.insertElement(0, "cloudflare({ viteEnvironment: { name: 'ssr' } })");
-	if (!pluginsArray.getElements().some((el) => Node.isCallExpression(el) && el.getExpression().getText() === reactPluginIdentifier)) {
-		const nextIndex = pluginsArray.getElements().findIndex((el) => el.getText().includes("tanstackStart(")) + 1;
-		if (nextIndex > 0) pluginsArray.insertElement(nextIndex, `${reactPluginIdentifier}()`);
-		else pluginsArray.addElement(`${reactPluginIdentifier}()`);
-	}
-	await tsProject.save();
-}
-
-//#endregion
-//#region src/helpers/deployment/workers/workers-vite-setup.ts
-async function setupWorkersVitePlugin(projectDir) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	const viteConfigPath = path.join(webAppDir, "vite.config.ts");
-	if (!await fs.pathExists(viteConfigPath)) throw new Error("vite.config.ts not found in web app directory");
-	await addPackageDependency({
-		devDependencies: ["@cloudflare/vite-plugin", "wrangler"],
-		projectDir: webAppDir
-	});
-	const sourceFile = tsProject.addSourceFileAtPathIfExists(viteConfigPath);
-	if (!sourceFile) throw new Error("vite.config.ts not found in web app directory");
-	if (!sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === "@cloudflare/vite-plugin")) sourceFile.insertImportDeclaration(0, {
-		namedImports: ["cloudflare"],
-		moduleSpecifier: "@cloudflare/vite-plugin"
-	});
-	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().includes("cloudflare("))) pluginsArray.addElement("cloudflare()");
-	await tsProject.save();
-}
-
 //#endregion
 //#region src/helpers/deployment/web-deploy-setup.ts
 async function setupWebDeploy(config) {
 	const { webDeploy, serverDeploy, frontend, projectDir } = config;
 	const { packageManager } = config;
 	if (webDeploy === "none") return;
-	if (webDeploy !== "wrangler" && webDeploy !== "alchemy") return;
+	if (webDeploy !== "alchemy") return;
 	if (webDeploy === "alchemy" && serverDeploy === "alchemy") {
 		await setupCombinedAlchemyDeploy(projectDir, packageManager, config);
 		await addAlchemyPackagesDependencies(projectDir);
@@ -3963,37 +3665,14 @@ async function setupWebDeploy(config) {
 	const isTanstackStart = frontend.includes("tanstack-start");
 	const isReactRouter = frontend.includes("react-router");
 	const isSolid = frontend.includes("solid");
-	if (webDeploy === "wrangler") {
-		if (isNext) await setupNextWorkersDeploy(projectDir, packageManager);
-		else if (isNuxt) await setupNuxtWorkersDeploy(projectDir, packageManager);
-		else if (isSvelte) await setupSvelteWorkersDeploy(projectDir, packageManager);
-		else if (isTanstackStart) await setupTanstackStartWorkersDeploy(projectDir, packageManager);
-		else if (isTanstackRouter || isReactRouter || isSolid) await setupWorkersWebDeploy(projectDir, packageManager);
-	} else if (webDeploy === "alchemy") {
-		if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager);
-		else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager);
-		else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager);
-		else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
-		else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
-		else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
-		else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
-		await addAlchemyPackagesDependencies(projectDir);
-	}
-}
-async function setupWorkersWebDeploy(projectDir, pkgManager) {
-	const webAppDir = path.join(projectDir, "apps/web");
-	if (!await fs.pathExists(webAppDir)) return;
-	const packageJsonPath = path.join(webAppDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			"wrangler:dev": "wrangler dev --port=3001",
-			deploy: `${pkgManager} run build && wrangler deploy`
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-	await setupWorkersVitePlugin(projectDir);
+	if (isNext) await setupNextAlchemyDeploy(projectDir, packageManager);
+	else if (isNuxt) await setupNuxtAlchemyDeploy(projectDir, packageManager);
+	else if (isSvelte) await setupSvelteAlchemyDeploy(projectDir, packageManager);
+	else if (isTanstackStart) await setupTanStackStartAlchemyDeploy(projectDir, packageManager);
+	else if (isTanstackRouter) await setupTanStackRouterAlchemyDeploy(projectDir, packageManager);
+	else if (isReactRouter) await setupReactRouterAlchemyDeploy(projectDir, packageManager);
+	else if (isSolid) await setupSolidAlchemyDeploy(projectDir, packageManager);
+	await addAlchemyPackagesDependencies(projectDir);
 }
 async function addAlchemyPackagesDependencies(projectDir) {
 	await addPackageDependency({
@@ -4854,7 +4533,7 @@ ${hasWeb ? "# npx convex env set SITE_URL http://localhost:3001\n" : ""}
 			databaseUrl = "mongodb://localhost:27017/mydatabase";
 			break;
 		case "sqlite":
-			if (config.runtime === "workers" || webDeploy === "wrangler" || serverDeploy === "wrangler" || webDeploy === "alchemy" || serverDeploy === "alchemy") databaseUrl = "http://127.0.0.1:8080";
+			if (config.runtime === "workers" || webDeploy === "alchemy" || serverDeploy === "alchemy") 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")}`;
@@ -4936,31 +4615,7 @@ ${hasWeb ? "# 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 === "wrangler") {
-		const targetApp = backend === "self" ? "apps/web" : "apps/server";
-		const envPath = path.join(projectDir, targetApp, ".env");
-		const variables = [
-			{
-				key: "CLOUDFLARE_ACCOUNT_ID",
-				value: "",
-				condition: true
-			},
-			{
-				key: "CLOUDFLARE_DATABASE_ID",
-				value: "",
-				condition: true
-			},
-			{
-				key: "CLOUDFLARE_D1_TOKEN",
-				value: "",
-				condition: true
-			}
-		];
-		try {
-			await addEnvVariablesToFile(envPath, variables);
-		} catch (_err) {}
-	}
-	if ((serverDeploy === "wrangler" || serverDeploy === "alchemy") && orm === "prisma") {
+	if (serverDeploy === "alchemy" && orm === "prisma") {
 		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
 		const envPath = path.join(projectDir, targetApp2, ".env");
 		const variables = [{
@@ -5407,7 +5062,7 @@ const AVAILABLE_REGIONS = [
 		label: "US West (N. California)"
 	}
 ];
-async function setupWithCreateDb(serverDir, packageManager, orm) {
+async function setupWithCreateDb(serverDir, packageManager) {
 	try {
 		log.info("Starting Prisma Postgres setup with create-db.");
 		const selectedRegion = await select({
@@ -5432,7 +5087,7 @@ async function setupWithCreateDb(serverDir, packageManager, orm) {
 			return null;
 		}
 		return {
-			databaseUrl: orm === "drizzle" ? createDbResponse.directConnectionString : createDbResponse.connectionString,
+			databaseUrl: createDbResponse.connectionString,
 			claimUrl: createDbResponse.claimUrl
 		};
 	} catch (error) {
@@ -5450,12 +5105,12 @@ async function initPrismaDatabase(serverDir, packageManager) {
 			stdio: "inherit",
 			shell: true
 		});
-		log.info(pc.yellow("Please copy the Prisma Postgres URL from the output above.\nIt looks like: prisma+postgres://accelerate.prisma-data.net/?api_key=..."));
+		log.info(pc.yellow("Please copy the Prisma Postgres URL.\nIt looks like: postgresql://user:password@host:5432/db?sslmode=require"));
 		const databaseUrl = await text({
 			message: "Paste your Prisma Postgres database URL:",
 			validate(value) {
 				if (!value) return "Please enter a database URL";
-				if (!value.startsWith("prisma+postgres://")) return "URL should start with prisma+postgres://";
+				if (!value.startsWith("postgresql://")) return "URL should start with postgresql://";
 			}
 		});
 		if (isCancel(databaseUrl)) return null;
@@ -5504,18 +5159,6 @@ function displayManualSetupInstructions$1(target) {
 
 DATABASE_URL="your_database_url"`);
 }
-async function addPrismaAccelerateExtension(projectDir) {
-	try {
-		await addPackageDependency({
-			dependencies: ["@prisma/extension-accelerate"],
-			projectDir: path.join(projectDir, "packages/db")
-		});
-		return true;
-	} catch (_error) {
-		log.warn(pc.yellow("Could not add Prisma Accelerate extension automatically"));
-		return false;
-	}
-}
 async function setupPrismaPostgres(config, cliInput) {
 	const { packageManager, projectDir, orm, backend } = config;
 	const manualDb = cliInput?.manualDb ?? false;
@@ -5563,16 +5206,12 @@ async function setupPrismaPostgres(config, cliInput) {
 		});
 		if (isCancel(setupMethod)) return exitCancelled("Operation cancelled");
 		let prismaConfig = null;
-		if (setupMethod === "create-db") prismaConfig = await setupWithCreateDb(dbDir, packageManager, orm);
+		if (setupMethod === "create-db") prismaConfig = await setupWithCreateDb(dbDir, packageManager);
 		else prismaConfig = await initPrismaDatabase(dbDir, packageManager);
 		if (prismaConfig) {
 			await writeEnvFile$1(projectDir, backend, prismaConfig);
-			if (orm === "prisma") {
-				await addDotenvImportToPrismaConfig(projectDir, backend);
-				await addPrismaAccelerateExtension(projectDir);
-			}
-			const connectionType = orm === "drizzle" ? "direct connection" : "Prisma Accelerate";
-			log.success(pc.green(`Prisma Postgres database configured successfully with ${connectionType}!`));
+			if (orm === "prisma") await addDotenvImportToPrismaConfig(projectDir, backend);
+			log.success(pc.green("Prisma Postgres database configured successfully!"));
 			if (prismaConfig.claimUrl) log.info(pc.blue(`Claim URL saved to .env: ${prismaConfig.claimUrl}`));
 		} else {
 			await writeEnvFile$1(projectDir, backend);
@@ -5968,6 +5607,7 @@ async function setupDatabase(config, cliInput) {
 	}
 	const s = spinner();
 	const dbPackageDir = path.join(projectDir, "packages/db");
+	const webDir = path.join(projectDir, "apps/web");
 	if (!await fs.pathExists(dbPackageDir)) return;
 	try {
 		if (orm === "prisma") {
@@ -5990,18 +5630,26 @@ async function setupDatabase(config, cliInput) {
 				devDependencies: ["prisma"],
 				projectDir: dbPackageDir
 			});
-			const webDir = path.join(projectDir, "apps/web");
 			if (await fs.pathExists(webDir)) await addPackageDependency({
 				dependencies: ["@prisma/client"],
 				projectDir: webDir
 			});
 		} else if (orm === "drizzle") {
-			if (database === "sqlite") await addPackageDependency({
-				dependencies: ["drizzle-orm", "@libsql/client"],
-				devDependencies: ["drizzle-kit"],
-				projectDir: dbPackageDir
-			});
-			else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
+			if (database === "sqlite") {
+				await addPackageDependency({
+					dependencies: [
+						"drizzle-orm",
+						"@libsql/client",
+						"libsql"
+					],
+					devDependencies: ["drizzle-kit"],
+					projectDir: dbPackageDir
+				});
+				await addPackageDependency({
+					dependencies: ["@libsql/client", "libsql"],
+					projectDir: webDir
+				});
+			} else if (database === "postgres") if (dbSetup === "neon") await addPackageDependency({
 				dependencies: [
 					"drizzle-orm",
 					"@neondatabase/serverless",
@@ -6320,7 +5968,7 @@ function generateFeaturesList(database, auth, addons, orm, runtime, frontend, ba
 	else if (addon === "turborepo") addonsList.push("- **Turborepo** - Optimized monorepo build system");
 	return addonsList.join("\n");
 }
-function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSetup, serverDeploy, backend) {
+function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSetup, _serverDeploy, backend) {
 	if (database === "none") return "";
 	const isBackendSelf = backend === "self";
 	const envPath = isBackendSelf ? "apps/web/.env" : "apps/server/.env";
@@ -6329,7 +5977,7 @@ function generateDatabaseSetup(database, _auth, packageManagerRunCmd, orm, dbSet
 	if (database === "sqlite") setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : orm === "prisma" ? " with Prisma" : ` with ${orm}`}.
 
 1. Start the local SQLite database:
-${dbSetup === "d1" ? serverDeploy === "alchemy" ? "D1 local development and migrations are handled automatically by Alchemy during dev and deploy." : "Local development for a Cloudflare D1 database will already be running as part of the `wrangler dev` command." : `\`\`\`bash
+${dbSetup === "d1" ? "D1 local development and migrations are handled automatically by Alchemy during dev and deploy." : `\`\`\`bash
 cd ${dbLocalPath} && ${packageManagerRunCmd} db:local
 \`\`\`
 `}
@@ -6427,11 +6075,6 @@ function generateDeploymentCommands(packageManagerRunCmd, webDeploy, serverDeplo
 		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 === "wrangler" || serverDeploy === "wrangler") {
-		lines.push("\n## Deployment (Cloudflare Wrangler)");
-		if (webDeploy === "wrangler") lines.push(`- Web deploy: cd apps/web && ${packageManagerRunCmd} deploy`);
-		if (serverDeploy === "wrangler") lines.push(`- Server dev: cd apps/server && ${packageManagerRunCmd} dev`, `- Server deploy: cd apps/server && ${packageManagerRunCmd} deploy`);
-	}
 	return lines.length ? `\n${lines.join("\n")}\n` : "";
 }
 
@@ -6555,7 +6198,6 @@ async function displayPostInstallInstructions(config) {
 	const starlightInstructions = addons?.includes("starlight") ? getStarlightInstructions(runCmd) : "";
 	const clerkInstructions = isConvex && config.auth === "clerk" ? getClerkInstructions() : "";
 	const polarInstructions = config.payments === "polar" && config.auth === "better-auth" ? getPolarInstructions(backend) : "";
-	const wranglerDeployInstructions = getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy, backend);
 	const alchemyDeployInstructions = getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend);
 	const hasWeb = frontend?.some((f) => [
 		"tanstack-router",
@@ -6575,7 +6217,7 @@ async function displayPostInstallInstructions(config) {
 	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
 	let stepCounter = 2;
 	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
-	if (database === "sqlite" && dbSetup === "none" && (serverDeploy === "wrangler" || serverDeploy === "alchemy" || webDeploy === "wrangler" || webDeploy === "alchemy")) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (starts local SQLite server for Workers compatibility)")}\n`;
+	if (database === "sqlite" && dbSetup === "none" && (serverDeploy === "alchemy" || webDeploy === "alchemy")) output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} db:local\n${pc.dim("   (starts local SQLite server for Workers compatibility)")}\n`;
 	if (isConvex) {
 		output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev:setup\n${pc.dim("   (this will guide you through Convex project setup)")}\n`;
 		output += `${pc.cyan(`${stepCounter++}.`)} Copy environment variables from\n${pc.white("   packages/backend/.env.local")} to ${pc.white("apps/*/.env")}\n`;
@@ -6586,7 +6228,6 @@ async function displayPostInstallInstructions(config) {
 		if (runtime === "workers") {
 			if (dbSetup === "d1") output += `${pc.yellow("IMPORTANT:")} Complete D1 database setup first\n   (see Database commands below)\n`;
 			output += `${pc.cyan(`${stepCounter++}.`)} ${runCmd} dev\n`;
-			if (serverDeploy === "wrangler") output += `${pc.cyan(`${stepCounter++}.`)} cd apps/server && ${runCmd} cf-typegen\n`;
 		}
 	}
 	output += `${pc.bold("Your project will be available at:")}\n`;
@@ -6604,7 +6245,6 @@ async function displayPostInstallInstructions(config) {
 	if (tauriInstructions) output += `\n${tauriInstructions.trim()}\n`;
 	if (lintingInstructions) output += `\n${lintingInstructions.trim()}\n`;
 	if (pwaInstructions) output += `\n${pwaInstructions.trim()}\n`;
-	if (wranglerDeployInstructions) output += `\n${wranglerDeployInstructions.trim()}\n`;
 	if (alchemyDeployInstructions) output += `\n${alchemyDeployInstructions.trim()}\n`;
 	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
 	if (clerkInstructions) output += `\n${clerkInstructions.trim()}\n`;
@@ -6627,7 +6267,7 @@ function getNativeInstructions(isConvex, isBackendSelf, _frontend) {
 function getLintingInstructions(runCmd) {
 	return `${pc.bold("Linting and formatting:")}\n${pc.cyan("•")} Format and lint fix: ${`${runCmd} check`}\n`;
 }
-async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup, serverDeploy, backend) {
+async function getDatabaseInstructions(database, orm, runCmd, _runtime, dbSetup, serverDeploy, _backend) {
 	const instructions = [];
 	if (dbSetup === "docker") {
 		const dockerStatus = await getDockerStatus(database);
@@ -6636,17 +6276,6 @@ async function getDatabaseInstructions(database, orm, runCmd, runtime, dbSetup,
 			instructions.push("");
 		}
 	}
-	if (serverDeploy === "wrangler" && dbSetup === "d1") {
-		if (orm === "prisma" && runtime === "workers") instructions.push(`\n${pc.yellow("WARNING:")} Prisma + D1 on Workers with Wrangler has migration issues.\n   Consider using Alchemy deploy instead of Wrangler for D1 projects.\n`);
-		const packageManager = runCmd === "npm run" ? "npm" : runCmd || "npm";
-		instructions.push(`${pc.cyan("1.")} Login to Cloudflare: ${pc.white(`${packageManager} wrangler login`)}`);
-		instructions.push(`${pc.cyan("2.")} Create D1 database: ${pc.white(`${packageManager} wrangler d1 create your-database-name`)}`);
-		const wranglerPath = backend === "self" ? "apps/web" : "apps/server";
-		instructions.push(`${pc.cyan("3.")} Update ${wranglerPath}/wrangler.jsonc with database_id and database_name`);
-		instructions.push(`${pc.cyan("4.")} Generate migrations: ${pc.white(`cd ${wranglerPath} && ${runCmd} db:generate`)}`);
-		instructions.push(`${pc.cyan("5.")} Apply migrations locally: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME --local`)}`);
-		instructions.push(`${pc.cyan("6.")} Apply migrations to production: ${pc.white(`${packageManager} wrangler d1 migrations apply YOUR_DB_NAME`)}`);
-	}
 	if (dbSetup === "d1" && serverDeploy === "alchemy") {
 		if (orm === "drizzle") instructions.push(`${pc.yellow("NOTE:")} D1 migrations are automatically handled by Alchemy`);
 		else if (orm === "prisma") {
@@ -6687,15 +6316,6 @@ function getNoOrmWarning() {
 function getBunWebNativeWarning() {
 	return `\n${pc.yellow("WARNING:")} 'bun' might cause issues with web + native apps in a monorepo.\n   Use 'pnpm' if problems arise.`;
 }
-function getWranglerDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
-	const instructions = [];
-	if (webDeploy === "wrangler") {
-		const deployPath = backend === "self" ? "apps/web" : "apps/web";
-		instructions.push(`${pc.bold("Deploy web to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd ${deployPath} && ${runCmd} deploy`}`);
-	}
-	if (serverDeploy === "wrangler" && backend !== "self") instructions.push(`${pc.bold("Deploy server to Cloudflare Workers:")}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}`);
-	return instructions.length ? `\n${instructions.join("\n")}` : "";
-}
 function getClerkInstructions() {
 	return `${pc.bold("Clerk Authentication Setup:")}\n${pc.cyan("•")} Follow the guide: ${pc.underline("https://docs.convex.dev/auth/clerk")}\n${pc.cyan("•")} Set CLERK_JWT_ISSUER_DOMAIN in Convex Dashboard\n${pc.cyan("•")} Set CLERK_PUBLISHABLE_KEY in apps/*/.env`;
 }
@@ -6706,7 +6326,7 @@ 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} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
+	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`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";