create-prisma 0.7.1-pr.52.181.1 → 0.7.2

package/dist/src-B3hRLZ0U.mjs

@@ -0,0 +1,2527 @@
+#!/usr/bin/env node
+import { os } from "@orpc/server";
+import { createCli } from "trpc-cli";
+import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import fs from "fs-extra";
+import path from "node:path";
+import Handlebars from "handlebars";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { execa } from "execa";
+import { randomUUID } from "node:crypto";
+import os$1 from "node:os";
+import { PostHog } from "posthog-node";
+import { styleText } from "node:util";
+//#region src/utils/runtime.ts
+function usesNodeStyleRuntime(packageManager) {
+	return packageManager !== void 0 && packageManager !== "bun" && packageManager !== "deno";
+}
+function requiresDotenvConfigImport(packageManager) {
+	return usesNodeStyleRuntime(packageManager);
+}
+function requiresPrismaConfigDotenvImport(packageManager) {
+	return packageManager !== "deno";
+}
+//#endregion
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@elysiajs/node": "^1.4.5",
+	"@libsql/client": "^0.17.4",
+	"@prisma/client": "^7.8.0",
+	"@prisma/adapter-pg": "^7.8.0",
+	"@prisma/adapter-libsql": "^7.8.0",
+	"@prisma/adapter-mariadb": "^7.8.0",
+	"@prisma/adapter-mssql": "^7.8.0",
+	"@prisma/compute-sdk": "latest",
+	"@types/node": "^26.0.0",
+	dotenv: "^17.4.2",
+	prisma: "^7.8.0",
+	tsx: "^4.22.4"
+};
+const computeConfigTemplates = /* @__PURE__ */ new Set([
+	"hono",
+	"elysia",
+	"nest",
+	"next",
+	"astro",
+	"nuxt",
+	"tanstack-start",
+	"turborepo"
+]);
+function getWorkspaceDependencyVersion(packageManager) {
+	return packageManager === "npm" ? "*" : "workspace:*";
+}
+function getCreateTemplateDependencies(template, packageManager) {
+	const targets = [];
+	if (template === "hono" || template === "elysia" || template === "nest") {
+		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
+		if (template === "elysia" && packageManager !== "deno") targets.push({
+			packageJsonPath: "package.json",
+			dependencies: ["@elysiajs/node"],
+			devDependencies: ["@types/node", ...runtimeDevDependencies]
+		});
+		else if (runtimeDevDependencies.length > 0) targets.push({
+			packageJsonPath: "package.json",
+			dependencies: [],
+			devDependencies: runtimeDevDependencies
+		});
+	}
+	if (template === "turborepo") targets.push({
+		packageJsonPath: "apps/api/package.json",
+		dependencies: ["dotenv"],
+		devDependencies: ["tsx"],
+		customDependencies: { "@repo/db": getWorkspaceDependencyVersion(packageManager) }
+	});
+	if (computeConfigTemplates.has(template)) targets.push({
+		packageJsonPath: "package.json",
+		dependencies: [],
+		devDependencies: ["@prisma/compute-sdk"]
+	});
+	return targets;
+}
+//#endregion
+//#region src/types.ts
+const databaseProviders = [
+	"postgresql",
+	"mysql",
+	"sqlite",
+	"sqlserver",
+	"cockroachdb"
+];
+const packageManagers = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun",
+	"deno"
+];
+const schemaPresets = ["empty", "basic"];
+const createTemplates = [
+	"hono",
+	"elysia",
+	"nest",
+	"next",
+	"svelte",
+	"astro",
+	"nuxt",
+	"tanstack-start",
+	"turborepo"
+];
+const createAddons = [
+	"skills",
+	"mcp",
+	"extension"
+];
+const addonInstallScopes = ["project", "global"];
+const extensionTargets = [
+	"vscode",
+	"cursor",
+	"windsurf"
+];
+const prismaSkillNames = [
+	"prisma-cli",
+	"prisma-client-api",
+	"prisma-compute",
+	"prisma-database-setup",
+	"prisma-upgrade-v7",
+	"prisma-postgres"
+];
+const DatabaseProviderSchema = z.enum(databaseProviders);
+const PackageManagerSchema = z.enum(packageManagers);
+const SchemaPresetSchema = z.enum(schemaPresets);
+const CreateTemplateSchema = z.enum(createTemplates);
+z.enum(createAddons);
+z.enum(addonInstallScopes);
+z.enum(extensionTargets);
+z.enum(prismaSkillNames);
+const DatabaseUrlSchema = z.string().trim().min(1, "Please enter a valid database URL");
+const CommonCommandOptionsSchema = z.object({
+	yes: z.boolean().optional().describe("Skip prompts and accept default choices"),
+	verbose: z.boolean().optional().describe("Show verbose command output during setup")
+});
+const PrismaSetupOptionsSchema = z.object({
+	provider: DatabaseProviderSchema.optional().describe("Database provider"),
+	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
+	prismaPostgres: z.boolean().optional().describe("Use Prisma Postgres when provider is postgresql"),
+	databaseUrl: DatabaseUrlSchema.optional().describe("DATABASE_URL value"),
+	install: z.boolean().optional().describe("Install dependencies with selected package manager"),
+	generate: z.boolean().optional().describe("Generate Prisma Client after scaffolding"),
+	migrateAndSeed: z.boolean().optional().describe("Run an initial migration and seed after Prisma Client generation"),
+	schemaPreset: SchemaPresetSchema.optional().describe("Schema preset to scaffold in prisma/schema.prisma")
+});
+const PrismaSetupCommandInputSchema = CommonCommandOptionsSchema.extend(PrismaSetupOptionsSchema.shape);
+const CreateScaffoldOptionsSchema = z.object({
+	name: z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"),
+	template: CreateTemplateSchema.optional().describe("Project template"),
+	skills: z.boolean().optional().describe("Enable skills addon"),
+	mcp: z.boolean().optional().describe("Enable MCP addon"),
+	extension: z.boolean().optional().describe("Enable extension addon"),
+	deploy: z.boolean().optional().describe("Deploy the scaffolded project to Prisma Compute"),
+	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
+});
+const COMPUTE_DEPLOYABLE_TEMPLATES = /* @__PURE__ */ new Set([
+	"hono",
+	"elysia",
+	"nest",
+	"next",
+	"astro",
+	"nuxt",
+	"tanstack-start",
+	"turborepo"
+]);
+function isComputeDeployableTemplate(template) {
+	return COMPUTE_DEPLOYABLE_TEMPLATES.has(template);
+}
+const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
+//#endregion
+//#region src/utils/package-manager.ts
+const packageManagerManifestValues = {
+	npm: "npm@11.17.0",
+	pnpm: "pnpm@11.8.0",
+	yarn: "yarn@4.17.0",
+	bun: "bun@1.3.14"
+};
+function parseUserAgent(userAgent) {
+	if (userAgent?.startsWith("pnpm")) return "pnpm";
+	if (userAgent?.startsWith("yarn")) return "yarn";
+	if (userAgent?.startsWith("bun")) return "bun";
+	if (userAgent?.startsWith("deno")) return "deno";
+	if (userAgent?.startsWith("npm")) return "npm";
+	return null;
+}
+function parsePackageManagerField(packageManagerField) {
+	if (typeof packageManagerField !== "string" || packageManagerField.length === 0) return null;
+	const managerName = packageManagerField.split("@")[0];
+	const parsed = PackageManagerSchema.safeParse(managerName);
+	return parsed.success ? parsed.data : null;
+}
+async function detectFromPackageJson(projectDir) {
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return null;
+	return parsePackageManagerField((await fs.readJson(packageJsonPath)).packageManager);
+}
+async function detectFromDenoConfig(projectDir) {
+	for (const configFile of ["deno.json", "deno.jsonc"]) if (await fs.pathExists(path.join(projectDir, configFile))) return "deno";
+	return null;
+}
+async function detectFromLockfile(projectDir) {
+	for (const check of [
+		{
+			manager: "pnpm",
+			lockfile: "pnpm-lock.yaml"
+		},
+		{
+			manager: "yarn",
+			lockfile: "yarn.lock"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lockb"
+		},
+		{
+			manager: "bun",
+			lockfile: "bun.lock"
+		},
+		{
+			manager: "npm",
+			lockfile: "package-lock.json"
+		},
+		{
+			manager: "npm",
+			lockfile: "npm-shrinkwrap.json"
+		},
+		{
+			manager: "deno",
+			lockfile: "deno.lock"
+		}
+	]) if (await fs.pathExists(path.join(projectDir, check.lockfile))) return check.manager;
+	return null;
+}
+async function detectPackageManager(projectDir = process.cwd()) {
+	const fromPackageJson = await detectFromPackageJson(projectDir);
+	if (fromPackageJson) return fromPackageJson;
+	const fromLockfile = await detectFromLockfile(projectDir);
+	if (fromLockfile) return fromLockfile;
+	const fromDenoConfig = await detectFromDenoConfig(projectDir);
+	if (fromDenoConfig) return fromDenoConfig;
+	const fromUserAgent = parseUserAgent(process.env.npm_config_user_agent);
+	if (fromUserAgent) return fromUserAgent;
+	return "npm";
+}
+function getPackageManagerManifestValue(packageManager) {
+	if (!packageManager || packageManager === "deno") return;
+	return packageManagerManifestValues[packageManager];
+}
+function getDenoPrismaSpecifier() {
+	return `npm:prisma@${dependencyVersionMap.prisma}`;
+}
+function getDenoAllowedScriptSpecifiers() {
+	return [
+		`npm:prisma@${dependencyVersionMap.prisma}`,
+		`npm:@prisma/client@${dependencyVersionMap["@prisma/client"]}`,
+		`npm:@prisma/engines@${dependencyVersionMap.prisma}`
+	].join(",");
+}
+function getInstallCommand(packageManager) {
+	if (packageManager === "deno") return `deno install --allow-scripts=${getDenoAllowedScriptSpecifiers()}`;
+	return `${packageManager} install`;
+}
+function getRunScriptCommand(packageManager, scriptName) {
+	switch (packageManager) {
+		case "deno": return `deno task ${scriptName}`;
+		case "bun": return `bun run ${scriptName}`;
+		case "pnpm": return `pnpm run ${scriptName}`;
+		case "yarn": return `yarn run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+function getRunScriptInDirectoryCommand(packageManager, directory, scriptName) {
+	switch (packageManager) {
+		case "deno": return `deno task --cwd ${directory} ${scriptName}`;
+		case "bun": return `bun run --cwd ${directory} ${scriptName}`;
+		case "pnpm": return `pnpm --dir ${directory} run ${scriptName}`;
+		case "yarn": return `yarn --cwd ${directory} run ${scriptName}`;
+		default: return `npm --prefix ${directory} run ${scriptName}`;
+	}
+}
+function joinCommandParts(parts) {
+	return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+function getRuntimeScriptCommand(packageManager, kind, options) {
+	const { sourceEntrypoint, builtEntrypoint, denoFlags = [], emit = false } = options;
+	if (packageManager === "deno") switch (kind) {
+		case "dev": return joinCommandParts([
+			"deno",
+			"run",
+			"-A",
+			"--env-file=.env",
+			...denoFlags,
+			"--watch",
+			sourceEntrypoint
+		]);
+		case "build": return `deno check ${sourceEntrypoint}`;
+		case "start": return joinCommandParts([
+			"deno",
+			"run",
+			"-A",
+			"--env-file=.env",
+			...denoFlags,
+			sourceEntrypoint
+		]);
+	}
+	if (packageManager === "bun") switch (kind) {
+		case "dev": return `bun --watch ${sourceEntrypoint}`;
+		case "build": return emit ? "tsc" : "tsc --noEmit";
+		case "start": return `bun ${sourceEntrypoint}`;
+	}
+	switch (kind) {
+		case "dev": return `tsx watch ${sourceEntrypoint}`;
+		case "build": return "tsc";
+		case "start": return builtEntrypoint ? `node ${builtEntrypoint}` : `tsx ${sourceEntrypoint}`;
+	}
+}
+function getInstallArgs(packageManager) {
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: ["install", `--allow-scripts=${getDenoAllowedScriptSpecifiers()}`]
+	};
+	return {
+		command: packageManager,
+		args: ["install"]
+	};
+}
+function getPackageExecutionArgs(packageManager, commandArgs, options = {}) {
+	switch (packageManager) {
+		case "pnpm": return {
+			command: "pnpm",
+			args: [
+				...options.silent ? ["--silent"] : [],
+				"dlx",
+				...commandArgs
+			]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: [
+				"dlx",
+				...options.silent ? ["--quiet"] : [],
+				...commandArgs
+			]
+		};
+		case "bun": return {
+			command: "bunx",
+			args: [...options.silent ? ["--silent"] : [], ...commandArgs]
+		};
+		case "deno": {
+			const [packageName, ...args] = commandArgs;
+			if (!packageName) throw new Error("Package execution requires a package name.");
+			return {
+				command: "deno",
+				args: [
+					"run",
+					"-A",
+					`npm:${packageName}`,
+					...args
+				]
+			};
+		}
+		default: return {
+			command: "npx",
+			args: [...options.silent ? ["--yes", "--no-update-notifier"] : [], ...commandArgs]
+		};
+	}
+}
+function getPackageExecutionCommand(packageManager, commandArgs, options = {}) {
+	const execution = getPackageExecutionArgs(packageManager, commandArgs, options);
+	return [execution.command, ...execution.args].join(" ");
+}
+function getPrismaCliArgs(packageManager, prismaArgs) {
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: [
+			"run",
+			"-A",
+			"--env-file=.env",
+			getDenoPrismaSpecifier(),
+			...prismaArgs
+		]
+	};
+	if (packageManager === "bun") return {
+		command: "bun",
+		args: [
+			"--env-file=.env",
+			"./node_modules/.bin/prisma",
+			...prismaArgs
+		]
+	};
+	if (packageManager === "pnpm") return {
+		command: "pnpm",
+		args: [
+			"exec",
+			"prisma",
+			...prismaArgs
+		]
+	};
+	if (packageManager === "yarn") return {
+		command: "yarn",
+		args: [
+			"exec",
+			"prisma",
+			...prismaArgs
+		]
+	};
+	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
+}
+function getPrismaCliCommand$1(packageManager, prismaArgs) {
+	const execution = getPrismaCliArgs(packageManager, prismaArgs);
+	return [execution.command, ...execution.args].join(" ");
+}
+//#endregion
+//#region src/templates/shared.ts
+function getOptionalHashString(hash, key) {
+	const value = hash[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function getOptionalHashStringList(hash, key) {
+	return getOptionalHashString(hash, key)?.split(" ") ?? [];
+}
+function getSeedCommand(packageManager) {
+	if (packageManager === "deno") return "deno run -A --env-file=.env ./prisma/seed.ts";
+	if (packageManager === "bun") return "bun ./prisma/seed.ts";
+	return "tsx ./prisma/seed.ts";
+}
+function getPrismaCommand(packageManager, subcommand) {
+	if (packageManager === "deno") return `deno run -A --env-file=.env npm:prisma@${dependencyVersionMap.prisma} ${subcommand}`;
+	if (packageManager === "bun") return `bun --env-file=.env ./node_modules/.bin/prisma ${subcommand}`;
+	return `prisma ${subcommand}`;
+}
+Handlebars.registerHelper("eq", (left, right) => left === right);
+Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
+Handlebars.registerHelper("runScriptInDirectoryCommand", (packageManager, directory, scriptName) => packageManager ? getRunScriptInDirectoryCommand(packageManager, directory, scriptName) : "");
+Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
+Handlebars.registerHelper("requiresDotenvConfigImport", (packageManager) => requiresDotenvConfigImport(packageManager));
+Handlebars.registerHelper("requiresPrismaConfigDotenvImport", (packageManager) => requiresPrismaConfigDotenvImport(packageManager));
+Handlebars.registerHelper("sqliteAdapterPackage", () => "@prisma/adapter-libsql");
+Handlebars.registerHelper("sqliteAdapterClass", () => "PrismaLibSql");
+Handlebars.registerHelper("seedCommand", (packageManager) => getSeedCommand(packageManager));
+Handlebars.registerHelper("prismaCommand", (packageManager, subcommand) => getPrismaCommand(packageManager, subcommand));
+Handlebars.registerHelper("runtimeScript", (packageManager, kind, sourceEntrypoint, builtEntrypoint, options) => {
+	if (!packageManager) return "";
+	const hash = options.hash;
+	return getRuntimeScriptCommand(packageManager, kind, {
+		sourceEntrypoint,
+		builtEntrypoint,
+		denoFlags: getOptionalHashStringList(hash, "denoFlags"),
+		emit: hash.emit === true
+	});
+});
+function findPackageRoot(startDir) {
+	let currentDir = startDir;
+	while (true) {
+		if (existsSync(path.join(currentDir, "package.json"))) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	throw new Error(`Unable to locate package root from: ${startDir}`);
+}
+function resolveTemplatesDir(relativeTemplatesDir) {
+	const currentFilePath = fileURLToPath(import.meta.url);
+	const packageRoot = findPackageRoot(path.dirname(currentFilePath));
+	const templatePath = path.join(packageRoot, relativeTemplatesDir);
+	if (!existsSync(templatePath)) throw new Error(`Template directory not found at: ${templatePath}`);
+	return templatePath;
+}
+async function getTemplateFilesRecursively(dir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) return getTemplateFilesRecursively(entryPath);
+		if (!entry.isFile()) return [];
+		return [entryPath];
+	}))).flat();
+}
+function stripHbsExtension(filePath) {
+	return filePath.endsWith(".hbs") ? filePath.slice(0, -4) : filePath;
+}
+function ensureTrailingNewline(content) {
+	return content.endsWith("\n") ? content : `${content}\n`;
+}
+async function renderTemplateFile(opts) {
+	const { templateFilePath, outputPath, context } = opts;
+	const templateContent = await fs.readFile(templateFilePath, "utf8");
+	const outputContent = templateFilePath.endsWith(".hbs") ? Handlebars.compile(templateContent, {
+		noEscape: true,
+		strict: true
+	})(context) : templateContent;
+	if (templateFilePath.endsWith(".hbs") && outputContent.trim().length === 0) return;
+	await fs.outputFile(outputPath, ensureTrailingNewline(outputContent), "utf8");
+}
+async function renderTemplateTree(opts) {
+	const { templateRoot, outputDir, context } = opts;
+	const templateFiles = await getTemplateFilesRecursively(templateRoot);
+	for (const templateFilePath of templateFiles) {
+		const relativeOutputPath = stripHbsExtension(path.relative(templateRoot, templateFilePath));
+		await renderTemplateFile({
+			templateFilePath,
+			outputPath: path.join(outputDir, relativeOutputPath),
+			context
+		});
+	}
+}
+//#endregion
+//#region src/templates/render-create-template.ts
+function getCreateTemplateDir(template) {
+	return resolveTemplatesDir(`templates/create/${template}`);
+}
+function createTemplateContext(projectName, provider, schemaPreset, packageManager, compute) {
+	return {
+		projectName,
+		provider,
+		schemaPreset,
+		packageManager,
+		compute
+	};
+}
+async function scaffoldCreateTemplate(opts) {
+	const { projectDir, projectName, template, provider, schemaPreset, packageManager } = opts;
+	await renderTemplateTree({
+		templateRoot: getCreateTemplateDir(template),
+		outputDir: projectDir,
+		context: createTemplateContext(projectName, provider, schemaPreset, packageManager, opts.compute === true)
+	});
+}
+//#endregion
+//#region src/constants/db-packages.ts
+function getDbPackages(provider, _packageManager) {
+	switch (provider) {
+		case "postgresql":
+		case "cockroachdb": return "@prisma/adapter-pg";
+		case "mysql": return "@prisma/adapter-mariadb";
+		case "sqlite": return "@prisma/adapter-libsql";
+		case "sqlserver": return "@prisma/adapter-mssql";
+		default: throw new Error(`Unsupported database provider: ${String(provider)}`);
+	}
+}
+//#endregion
+//#region src/tasks/install.ts
+function getPrismaScriptMap(packageManager) {
+	if (packageManager === "deno") {
+		const prismaCli = `deno run -A --env-file=.env ${getDenoPrismaSpecifier()}`;
+		return {
+			"db:generate": `${prismaCli} generate`,
+			"db:push": `${prismaCli} db push`,
+			"db:migrate": `${prismaCli} migrate dev`,
+			"db:seed": `${prismaCli} db seed`
+		};
+	}
+	if (packageManager === "bun") {
+		const prismaCli = "bun --env-file=.env ./node_modules/.bin/prisma";
+		return {
+			"db:generate": `${prismaCli} generate`,
+			"db:push": `${prismaCli} db push`,
+			"db:migrate": `${prismaCli} migrate dev`,
+			"db:seed": `${prismaCli} db seed`
+		};
+	}
+	return {
+		"db:generate": "prisma generate",
+		"db:push": "prisma db push",
+		"db:migrate": "prisma migrate dev",
+		"db:seed": "prisma db seed"
+	};
+}
+function getVersion(packageName) {
+	return dependencyVersionMap[packageName];
+}
+function unique(items) {
+	return [...new Set(items)];
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+async function projectContainsText(projectDir, text) {
+	const directories = [projectDir];
+	while (directories.length > 0) {
+		const currentDirectory = directories.pop();
+		if (!currentDirectory) continue;
+		const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+		for (const entry of entries) {
+			if (entry.name === "node_modules" || entry.name === ".git") continue;
+			const entryPath = path.join(currentDirectory, entry.name);
+			if (entry.isDirectory()) {
+				directories.push(entryPath);
+				continue;
+			}
+			if (!entry.isFile() || !/\.(c|m)?[jt]sx?$/.test(entry.name)) continue;
+			if ((await fs.readFile(entryPath, "utf8")).includes(text)) return true;
+		}
+	}
+	return false;
+}
+async function addPackageDependency(opts) {
+	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir } = opts;
+	const pkgJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(pkgJsonPath)) throw new Error(`No package.json found in ${projectDir}. Run this command inside an existing JavaScript/TypeScript project.`);
+	const pkgJson = await fs.readJson(pkgJsonPath);
+	if (!pkgJson.dependencies) pkgJson.dependencies = {};
+	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+	if (!pkgJson.scripts) pkgJson.scripts = {};
+	for (const pkgName of unique(dependencies)) {
+		const version = getVersion(pkgName);
+		if (version) pkgJson.dependencies[pkgName] = version;
+		else console.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+	}
+	for (const pkgName of unique(devDependencies)) {
+		const version = getVersion(pkgName);
+		if (version) pkgJson.devDependencies[pkgName] = version;
+		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+	}
+	for (const [pkgName, version] of Object.entries(customDependencies)) pkgJson.dependencies[pkgName] = version;
+	for (const [scriptName, command] of Object.entries(scripts)) {
+		if (scriptMode === "if-missing") {
+			if (typeof pkgJson.scripts[scriptName] !== "string" || pkgJson.scripts[scriptName].trim().length === 0) pkgJson.scripts[scriptName] = command;
+			continue;
+		}
+		pkgJson.scripts[scriptName] = command;
+	}
+	pkgJson.dependencies = sortRecord(pkgJson.dependencies);
+	pkgJson.devDependencies = sortRecord(pkgJson.devDependencies);
+	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+}
+async function writePrismaDependencies(provider, packageManager, projectDir = process.cwd()) {
+	const dependencies = ["@prisma/client"];
+	const devDependencies = ["prisma"];
+	dependencies.push(getDbPackages(provider, packageManager));
+	if (provider === "sqlite") dependencies.push("@libsql/client");
+	if (requiresDotenvConfigImport(packageManager) || await projectContainsText(projectDir, "dotenv/config")) dependencies.push("dotenv");
+	await addPackageDependency({
+		dependencies,
+		devDependencies,
+		scripts: getPrismaScriptMap(packageManager),
+		scriptMode: "if-missing",
+		projectDir
+	});
+}
+async function writeCreateTemplateDependencies(opts) {
+	const { template, packageManager, projectDir = process.cwd() } = opts;
+	const targets = getCreateTemplateDependencies(template, packageManager);
+	for (const dependencyTarget of targets) {
+		const targetDirectory = path.join(projectDir, path.dirname(dependencyTarget.packageJsonPath));
+		await addPackageDependency({
+			dependencies: dependencyTarget.dependencies,
+			devDependencies: dependencyTarget.devDependencies,
+			customDependencies: dependencyTarget.customDependencies,
+			projectDir: targetDirectory
+		});
+	}
+}
+async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
+	const verbose = options.verbose === true;
+	const installCommand = getInstallArgs(packageManager);
+	await execa(installCommand.command, installCommand.args, {
+		cwd: projectDir,
+		stdio: verbose ? "inherit" : "pipe"
+	});
+}
+//#endregion
+//#region src/tasks/prisma-postgres.ts
+const PRISMA_POSTGRES_TEMPORARY_NOTICE = "Prisma Postgres is temporary for 24 hours. Claim this database before it expires using CLAIM_URL.";
+const CREATE_DB_COMMAND_ARGS = ["create-db@latest", "--json"];
+function parseCreateDbJson(rawOutput) {
+	const trimmed = rawOutput.trim();
+	if (!trimmed) throw new Error("create-db returned empty output.");
+	const jsonCandidates = [trimmed];
+	const firstBrace = trimmed.indexOf("{");
+	const lastBrace = trimmed.lastIndexOf("}");
+	if (firstBrace !== -1 && lastBrace > firstBrace) jsonCandidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+	for (const candidate of jsonCandidates) try {
+		return JSON.parse(candidate);
+	} catch {}
+	throw new Error(`Unable to parse create-db JSON output: ${trimmed}`);
+}
+function pickConnectionString(payload) {
+	if (typeof payload.connectionString === "string" && payload.connectionString.length > 0) return payload.connectionString;
+	if (typeof payload.databaseUrl === "string" && payload.databaseUrl.length > 0) return payload.databaseUrl;
+}
+function extractErrorMessage(payload, fallback) {
+	if (typeof payload.message === "string" && payload.message.length > 0) return payload.message;
+	if (typeof payload.error === "string" && payload.error.length > 0) return payload.error;
+	return fallback;
+}
+async function provisionPrismaPostgres(packageManager, projectDir = process.cwd()) {
+	const command = getPackageExecutionArgs(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+	const commandString = getCreateDbCommand(packageManager);
+	let stdout;
+	try {
+		stdout = (await execa(command.command, command.args, {
+			cwd: projectDir,
+			stdio: "pipe"
+		})).stdout;
+	} catch (error) {
+		if (error instanceof Error && "stderr" in error) {
+			const stderr = String(error.stderr ?? "").trim();
+			const message = stderr.length > 0 ? stderr : error.message;
+			throw new Error(`Failed to run ${commandString}: ${message}`);
+		}
+		throw error;
+	}
+	const payload = parseCreateDbJson(stdout);
+	if (payload.success === false) throw new Error(extractErrorMessage(payload, "create-db reported failure."));
+	const databaseUrl = pickConnectionString(payload);
+	if (!databaseUrl) throw new Error("create-db did not return a connection string.");
+	return {
+		databaseUrl,
+		claimUrl: typeof payload.claimUrl === "string" && payload.claimUrl.length > 0 ? payload.claimUrl : typeof payload.claimURL === "string" && payload.claimURL.length > 0 ? payload.claimURL : void 0
+	};
+}
+function getCreateDbCommand(packageManager) {
+	return getPackageExecutionCommand(packageManager, [...CREATE_DB_COMMAND_ARGS]);
+}
+//#endregion
+//#region src/tasks/setup-prisma.ts
+const DEFAULT_DATABASE_PROVIDER = "postgresql";
+const DEFAULT_SCHEMA_PRESET$1 = "empty";
+const DEFAULT_PRISMA_POSTGRES = true;
+const DEFAULT_INSTALL = true;
+const DEFAULT_GENERATE = true;
+const DEFAULT_MIGRATE_AND_SEED = true;
+const PRISMA_POSTGRES_MIGRATION_DELAY_MS = 2e3;
+const requiredPrismaFileGroups = [
+	["prisma/schema.prisma", "packages/db/prisma/schema.prisma"],
+	["prisma/seed.ts", "packages/db/prisma/seed.ts"],
+	["prisma.config.ts", "packages/db/prisma.config.ts"],
+	[
+		"src/lib/prisma.ts",
+		"src/lib/prisma.server.ts",
+		"src/lib/server/prisma.ts",
+		"server/utils/prisma.ts",
+		"packages/db/src/client.ts"
+	]
+];
+async function resolvePrismaProjectDir(projectDir) {
+	const monorepoDbDir = path.join(projectDir, "packages/db");
+	if (await fs.pathExists(path.join(monorepoDbDir, "prisma/schema.prisma"))) return monorepoDbDir;
+	return projectDir;
+}
+async function promptForDatabaseProvider() {
+	const databaseProvider = await select({
+		message: "Select your database",
+		initialValue: DEFAULT_DATABASE_PROVIDER,
+		options: [
+			{
+				value: "postgresql",
+				label: "PostgreSQL",
+				hint: "Default"
+			},
+			{
+				value: "mysql",
+				label: "MySQL"
+			},
+			{
+				value: "sqlite",
+				label: "SQLite"
+			},
+			{
+				value: "sqlserver",
+				label: "SQL Server"
+			},
+			{
+				value: "cockroachdb",
+				label: "CockroachDB"
+			}
+		]
+	});
+	if (isCancel(databaseProvider)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return DatabaseProviderSchema.parse(databaseProvider);
+}
+function getPackageManagerHint(option, detected) {
+	if (option === detected) return "Detected";
+	if (option === "bun") return "Fast runtime + package manager";
+	if (option === "deno") return "Runtime + package manager";
+}
+async function promptForPackageManager(detectedPackageManager) {
+	const packageManager = await select({
+		message: "Choose package manager",
+		initialValue: detectedPackageManager,
+		options: [
+			{
+				value: "npm",
+				label: "npm",
+				hint: getPackageManagerHint("npm", detectedPackageManager)
+			},
+			{
+				value: "pnpm",
+				label: "pnpm",
+				hint: getPackageManagerHint("pnpm", detectedPackageManager)
+			},
+			{
+				value: "yarn",
+				label: "yarn",
+				hint: getPackageManagerHint("yarn", detectedPackageManager)
+			},
+			{
+				value: "bun",
+				label: "bun",
+				hint: getPackageManagerHint("bun", detectedPackageManager)
+			},
+			{
+				value: "deno",
+				label: "deno",
+				hint: getPackageManagerHint("deno", detectedPackageManager)
+			}
+		]
+	});
+	if (isCancel(packageManager)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return PackageManagerSchema.parse(packageManager);
+}
+async function promptForDependencyInstall(packageManager) {
+	const shouldInstall = await confirm({
+		message: `Install dependencies now with ${getInstallCommand(packageManager)}?`,
+		initialValue: true
+	});
+	if (isCancel(shouldInstall)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldInstall);
+}
+async function promptForMigrateAndSeed() {
+	const shouldMigrateAndSeed = await confirm({
+		message: "Run an initial migration and seed your database now?",
+		initialValue: DEFAULT_MIGRATE_AND_SEED
+	});
+	if (isCancel(shouldMigrateAndSeed)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldMigrateAndSeed);
+}
+async function promptForPrismaPostgres() {
+	const shouldUsePrismaPostgres = await confirm({
+		message: "Use Prisma Postgres and write DATABASE_URL automatically?",
+		initialValue: true
+	});
+	if (isCancel(shouldUsePrismaPostgres)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldUsePrismaPostgres);
+}
+function getCommandErrorMessage(error) {
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr ?? "").trim();
+		if (stderr.length > 0) return stderr;
+	}
+	return error instanceof Error ? error.message : String(error);
+}
+async function collectPrismaSetupInitialContext(input, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? process.cwd());
+	const useDefaults = input.yes === true;
+	const verbose = input.verbose === true;
+	const shouldGenerate = input.generate ?? DEFAULT_GENERATE;
+	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
+	if (!databaseProvider) return;
+	const schemaPreset = input.schemaPreset ?? options.defaultSchemaPreset ?? DEFAULT_SCHEMA_PRESET$1;
+	const databaseUrl = input.databaseUrl;
+	const detectedPackageManager = await detectPackageManager(projectDir);
+	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
+	if (!packageManager) return;
+	const shouldInstall = input.install ?? (useDefaults ? DEFAULT_INSTALL : await promptForDependencyInstall(packageManager));
+	if (shouldInstall === void 0) return;
+	return {
+		projectDir,
+		verbose,
+		shouldGenerate,
+		databaseProvider,
+		schemaPreset,
+		databaseUrl,
+		packageManager,
+		shouldInstall
+	};
+}
+async function completePrismaSetupContext(input, context, options = {}) {
+	const useDefaults = input.yes === true;
+	let shouldUsePrismaPostgres = false;
+	const shouldUseComputePostgres = context.databaseProvider === "postgresql" && !context.databaseUrl && options.useComputePostgres === true;
+	if (context.databaseProvider === "postgresql" && !context.databaseUrl && !shouldUseComputePostgres) {
+		const prismaPostgresChoice = input.prismaPostgres ?? (useDefaults ? DEFAULT_PRISMA_POSTGRES : await promptForPrismaPostgres());
+		if (prismaPostgresChoice === void 0) return;
+		shouldUsePrismaPostgres = prismaPostgresChoice;
+	}
+	const shouldMigrateAndSeed = !(context.shouldInstall && context.shouldGenerate && !(shouldUseComputePostgres && options.skipMigrateAndSeedPrompt)) ? false : input.migrateAndSeed ?? (useDefaults ? DEFAULT_MIGRATE_AND_SEED : await promptForMigrateAndSeed());
+	if (shouldMigrateAndSeed === void 0) return;
+	return {
+		...context,
+		shouldUsePrismaPostgres,
+		shouldMigrateAndSeed
+	};
+}
+function getDefaultDatabaseUrl(provider) {
+	switch (provider) {
+		case "postgresql": return "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+		case "cockroachdb": return "postgresql://johndoe:randompassword@localhost:26257/mydb?schema=public";
+		case "mysql": return "mysql://johndoe:randompassword@localhost:3306/mydb";
+		case "sqlite": return "file:./dev.db";
+		case "sqlserver": return "sqlserver://localhost:1433;database=mydb;user=SA;password=randompassword;";
+		default: throw new Error(`Unsupported provider: ${String(provider)}`);
+	}
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeEnvValue(value) {
+	if (/[\r\n]/.test(value)) throw new Error("Environment variable values must be single-line.");
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function hasEnvVar(content, envVarName) {
+	const escapedName = escapeRegExp(envVarName);
+	return new RegExp(`(^|\\n)\\s*${escapedName}\\s*=`).test(content);
+}
+function hasEnvComment(content, comment) {
+	const escapedComment = escapeRegExp(comment);
+	return new RegExp(`(^|\\n)\\s*#\\s*${escapedComment}\\s*(?=\\n|$)`).test(content);
+}
+async function ensureEnvVarInEnv(projectDir, envVarName, envVarValue, opts) {
+	const envPath = path.join(projectDir, ".env");
+	const envLine = `${envVarName}="${escapeEnvValue(envVarValue)}"`;
+	if (!await fs.pathExists(envPath)) {
+		const content = opts.comment ? `# ${opts.comment}\n${envLine}\n` : `${envLine}\n`;
+		await fs.writeFile(envPath, content, "utf8");
+		return;
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvVar(existingContent, envVarName)) {
+		if (opts.mode === "keep-existing") return;
+		const escapedName = escapeRegExp(envVarName);
+		const lineRegex = new RegExp(`(^|\\n)\\s*${escapedName}\\s*=.*(?=\\n|$)`, "gm");
+		const updatedContent = existingContent.replace(lineRegex, `$1${envLine}`);
+		if (updatedContent === existingContent) return;
+		await fs.writeFile(envPath, updatedContent, "utf8");
+		return;
+	}
+	const insertion = `${existingContent.endsWith("\n") ? "" : "\n"}${opts.comment ? `\n# ${opts.comment}\n` : "\n"}${envLine}\n`;
+	await fs.appendFile(envPath, insertion, "utf8");
+}
+async function ensureEnvComment(projectDir, comment) {
+	const envPath = path.join(projectDir, ".env");
+	const commentLine = `# ${comment}`;
+	if (!await fs.pathExists(envPath)) {
+		await fs.writeFile(envPath, `${commentLine}\n`, "utf8");
+		return;
+	}
+	const existingContent = await fs.readFile(envPath, "utf8");
+	if (hasEnvComment(existingContent, comment)) return;
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(envPath, `${separator}${commentLine}\n`, "utf8");
+}
+function hasGitignoreEntry(content, entry) {
+	const escapedEntry = escapeRegExp(entry);
+	const escapedWithLeadingSlash = escapeRegExp(`/${entry}`);
+	const escapedWithTrailingSlash = escapeRegExp(`${entry}/`);
+	const escapedWithLeadingAndTrailingSlash = escapeRegExp(`/${entry}/`);
+	return new RegExp(`(^|\\n)\\s*(?:${escapedEntry}|${escapedWithLeadingSlash}|${escapedWithTrailingSlash}|${escapedWithLeadingAndTrailingSlash})\\s*(?=\\n|$)`).test(content);
+}
+async function ensureGitignoreEntry(projectDir, entry) {
+	const gitignorePath = path.join(projectDir, ".gitignore");
+	if (!await fs.pathExists(gitignorePath)) {
+		await fs.writeFile(gitignorePath, `${entry}\n`, "utf8");
+		return;
+	}
+	const existingContent = await fs.readFile(gitignorePath, "utf8");
+	if (hasGitignoreEntry(existingContent, entry)) return;
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
+}
+async function ensureRequiredPrismaFiles(projectDir) {
+	const missingFiles = [];
+	for (const candidates of requiredPrismaFileGroups) {
+		let foundCandidate = false;
+		for (const relativePath of candidates) {
+			const absolutePath = path.join(projectDir, relativePath);
+			if (await fs.pathExists(absolutePath)) {
+				foundCandidate = true;
+				break;
+			}
+		}
+		if (!foundCandidate) missingFiles.push(candidates.join(" or "));
+	}
+	if (missingFiles.length > 0) throw new Error(`Template is missing required Prisma files: ${missingFiles.join(", ")}`);
+}
+async function finalizePrismaFiles(options) {
+	const projectDir = options.projectDir ?? process.cwd();
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
+	await ensureRequiredPrismaFiles(projectDir);
+	const generatedDir = await fs.pathExists(path.join(prismaProjectDir, "server/utils/prisma.ts")) ? "server/generated" : "src/generated";
+	await ensureEnvVarInEnv(prismaProjectDir, "DATABASE_URL", options.databaseUrl ?? getDefaultDatabaseUrl(options.provider), {
+		mode: options.databaseUrl ? "upsert" : "keep-existing",
+		comment: "Added by create-prisma"
+	});
+	if (options.claimUrl) {
+		await ensureEnvVarInEnv(prismaProjectDir, "CLAIM_URL", options.claimUrl, {
+			mode: "upsert",
+			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
+		});
+		await ensureEnvComment(prismaProjectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
+	}
+	await ensureGitignoreEntry(prismaProjectDir, generatedDir);
+}
+async function provisionPrismaPostgresIfNeeded(context, projectDir) {
+	if (!context.shouldUsePrismaPostgres) return { databaseUrl: context.databaseUrl };
+	const createDbCommand = getCreateDbCommand(context.packageManager);
+	const prismaPostgresSpinner = spinner();
+	prismaPostgresSpinner.start(`Provisioning Prisma Postgres with ${createDbCommand}...`);
+	try {
+		const prismaPostgresResult = await provisionPrismaPostgres(context.packageManager, projectDir);
+		prismaPostgresSpinner.stop("Prisma Postgres database provisioned.");
+		return {
+			databaseUrl: prismaPostgresResult.databaseUrl,
+			claimUrl: prismaPostgresResult.claimUrl
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		prismaPostgresSpinner.stop("Could not provision Prisma Postgres.");
+		return {
+			databaseUrl: context.databaseUrl,
+			warning: `Prisma Postgres provisioning failed: ${errorMessage}`
+		};
+	}
+}
+async function writeDependenciesForContext(context, projectDir) {
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
+	try {
+		await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
+		return true;
+	} catch (error) {
+		cancel(getCommandErrorMessage(error));
+		return false;
+	}
+}
+async function installDependenciesForContext(context, projectDir) {
+	if (!context.shouldInstall) return true;
+	const installCommand = getInstallCommand(context.packageManager);
+	if (context.verbose) {
+		log.step(`Running ${installCommand}`);
+		try {
+			await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+			log.success("Dependencies installed.");
+			return true;
+		} catch (error) {
+			cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
+			return false;
+		}
+	}
+	const installSpinner = spinner();
+	installSpinner.start(`Running ${installCommand}...`);
+	try {
+		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+		installSpinner.stop("Dependencies installed.");
+		return true;
+	} catch (error) {
+		installSpinner.stop("Could not install dependencies.");
+		cancel(`Failed to run ${installCommand}: ${getCommandErrorMessage(error)}`);
+		return false;
+	}
+}
+async function finalizePrismaFilesForContext(context, projectDir, provisionResult) {
+	const initSpinner = spinner();
+	initSpinner.start("Preparing Prisma files...");
+	try {
+		await finalizePrismaFiles({
+			provider: context.databaseProvider,
+			databaseUrl: provisionResult.databaseUrl,
+			claimUrl: provisionResult.claimUrl,
+			projectDir
+		});
+		initSpinner.stop("Prisma files ready.");
+		return true;
+	} catch (error) {
+		initSpinner.stop("Could not prepare Prisma files.");
+		cancel(getCommandErrorMessage(error));
+		return false;
+	}
+}
+async function generatePrismaClientForContext(context, projectDir) {
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
+	if (!context.shouldGenerate) return { didGenerateClient: false };
+	const generateCommand = getPrismaCliCommand$1(context.packageManager, ["generate"]);
+	if (context.verbose) log.step(`Running ${generateCommand}`);
+	const generateSpinner = context.verbose ? void 0 : spinner();
+	generateSpinner?.start("Generating Prisma Client...");
+	try {
+		const generateArgs = getPrismaCliArgs(context.packageManager, ["generate"]);
+		await execa(generateArgs.command, generateArgs.args, {
+			cwd: prismaProjectDir,
+			stdio: context.verbose ? "inherit" : "pipe"
+		});
+		if (context.verbose) log.success("Prisma Client generated.");
+		else generateSpinner?.stop("Prisma Client generated.");
+		return { didGenerateClient: true };
+	} catch (error) {
+		if (context.verbose) log.warn("Could not generate Prisma Client.");
+		else generateSpinner?.stop("Could not generate Prisma Client.");
+		return {
+			didGenerateClient: false,
+			warning: `Prisma generate failed: ${getCommandErrorMessage(error)}`
+		};
+	}
+}
+function buildWarningLines(provisionWarning, generateWarning, migrateAndSeedWarning) {
+	const warningLines = [];
+	if (provisionWarning) warningLines.push(`- ${provisionWarning}`);
+	if (generateWarning) warningLines.push(`- ${generateWarning}`);
+	if (migrateAndSeedWarning) warningLines.push(`- ${migrateAndSeedWarning}`);
+	return warningLines;
+}
+function buildNextStepsForContext(opts) {
+	const { context, options, didGenerateClient, didMigrate, didSeed } = opts;
+	const nextSteps = [...options.prependNextSteps ?? []];
+	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
+	if (!didGenerateClient || !context.shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
+	if (options.includeMigrationAndSeedNextSteps !== false && !didMigrate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
+	if (options.includeMigrationAndSeedNextSteps !== false && !didSeed) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:seed")}`);
+	if (options.includeDevNextStep) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "dev")}`);
+	return nextSteps;
+}
+async function executePrismaSetupContext(context, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
+	const provisionResult = await provisionPrismaPostgresIfNeeded(context, projectDir);
+	if (!provisionResult) return { ok: false };
+	if (!await writeDependenciesForContext(context, projectDir)) return { ok: false };
+	if (!await installDependenciesForContext(context, projectDir)) return { ok: false };
+	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) return { ok: false };
+	const databaseUrl = provisionResult.databaseUrl ?? context.databaseUrl ?? getDefaultDatabaseUrl(context.databaseProvider);
+	const generateResult = await generatePrismaClientForContext(context, projectDir);
+	const migrateAndSeedResult = await migrateAndSeedIfRequested(context, projectDir, {
+		databaseUrl,
+		didGenerateClient: generateResult.didGenerateClient
+	});
+	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning, migrateAndSeedResult.warning);
+	return {
+		ok: true,
+		nextSteps: buildNextStepsForContext({
+			context,
+			options,
+			didGenerateClient: generateResult.didGenerateClient,
+			didMigrate: migrateAndSeedResult.didMigrate,
+			didSeed: migrateAndSeedResult.didSeed
+		}),
+		warningSection: warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : "",
+		databaseUrl: provisionResult.databaseUrl ?? context.databaseUrl
+	};
+}
+async function migrateAndSeedIfRequested(context, projectDir, options) {
+	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
+	if (!context.shouldMigrateAndSeed) return {
+		didMigrate: false,
+		didSeed: false
+	};
+	if (!options.didGenerateClient) return {
+		didMigrate: false,
+		didSeed: false,
+		warning: "Skipped migrate + seed because the Prisma Client was not generated."
+	};
+	if (!options.databaseUrl) return {
+		didMigrate: false,
+		didSeed: false,
+		warning: "Skipped migrate + seed because no DATABASE_URL is available."
+	};
+	const migrateInvocation = getPrismaCliArgs(context.packageManager, [
+		"migrate",
+		"dev",
+		"--name",
+		"init"
+	]);
+	const seedInvocation = getPrismaCliArgs(context.packageManager, ["db", "seed"]);
+	const migrateSpinner = spinner();
+	migrateSpinner.start("Creating and applying initial migration...");
+	let didMigrate = false;
+	try {
+		if (context.shouldUsePrismaPostgres) await new Promise((resolve) => setTimeout(resolve, PRISMA_POSTGRES_MIGRATION_DELAY_MS));
+		await execa(migrateInvocation.command, migrateInvocation.args, {
+			cwd: prismaProjectDir,
+			stdio: context.verbose ? "inherit" : "pipe"
+		});
+		migrateSpinner.stop("Initial migration applied.");
+		didMigrate = true;
+	} catch (error) {
+		migrateSpinner.stop(`Migration failed${error instanceof Error ? `: ${error.message}` : "."}`);
+		return {
+			didMigrate: false,
+			didSeed: false,
+			warning: `Migration failed; run \`${getRunScriptCommand(context.packageManager, "db:migrate")}\` manually.`
+		};
+	}
+	const seedSpinner = spinner();
+	seedSpinner.start("Seeding database...");
+	let didSeed = false;
+	try {
+		await execa(seedInvocation.command, seedInvocation.args, {
+			cwd: prismaProjectDir,
+			stdio: context.verbose ? "inherit" : "pipe"
+		});
+		seedSpinner.stop("Database seeded.");
+		didSeed = true;
+	} catch (error) {
+		seedSpinner.stop(`Seed failed${error instanceof Error ? `: ${error.message}` : "."}`);
+		return {
+			didMigrate,
+			didSeed: false,
+			warning: `Seed failed; run \`${getRunScriptCommand(context.packageManager, "db:seed")}\` manually.`
+		};
+	}
+	return {
+		didMigrate,
+		didSeed
+	};
+}
+//#endregion
+//#region src/tasks/setup-addons.ts
+const DEFAULT_ADDON_SCOPE = "project";
+const DEFAULT_SKILLS_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const DEFAULT_MCP_AGENTS = [
+	"claude-code",
+	"codex",
+	"cursor"
+];
+const DEFAULT_EXTENSION_TARGETS = ["vscode", "cursor"];
+const PRISMA_MCP_SERVER = "https://mcp.prisma.io/mcp";
+const ADDON_OPTIONS = [
+	{
+		value: "skills",
+		label: "Skills",
+		hint: "Install curated Prisma skills to your selected coding agents"
+	},
+	{
+		value: "mcp",
+		label: "MCP",
+		hint: "Configure Prisma MCP server in agent MCP config files"
+	},
+	{
+		value: "extension",
+		label: "IDE Extension",
+		hint: "Install Prisma extension in selected IDEs (VS Code, Cursor, Windsurf)"
+	}
+];
+const SKILLS_AGENT_OPTIONS = [
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "cline",
+		label: "Cline"
+	},
+	{
+		value: "github-copilot",
+		label: "GitHub Copilot"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf"
+	},
+	{
+		value: "goose",
+		label: "Goose"
+	},
+	{
+		value: "roo",
+		label: "Roo Code"
+	},
+	{
+		value: "kilo",
+		label: "Kilo Code"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "openhands",
+		label: "OpenHands"
+	},
+	{
+		value: "trae",
+		label: "Trae"
+	},
+	{
+		value: "amp",
+		label: "Amp"
+	},
+	{
+		value: "pi",
+		label: "Pi"
+	},
+	{
+		value: "qoder",
+		label: "Qoder"
+	},
+	{
+		value: "qwen-code",
+		label: "Qwen Code"
+	},
+	{
+		value: "kiro-cli",
+		label: "Kiro CLI"
+	},
+	{
+		value: "droid",
+		label: "Droid"
+	},
+	{
+		value: "command-code",
+		label: "Command Code"
+	},
+	{
+		value: "clawdbot",
+		label: "Clawdbot"
+	},
+	{
+		value: "zencoder",
+		label: "Zencoder"
+	},
+	{
+		value: "neovate",
+		label: "Neovate"
+	},
+	{
+		value: "mcpjam",
+		label: "MCPJam"
+	}
+];
+const MCP_AGENT_OPTIONS = [
+	{
+		value: "claude-code",
+		label: "Claude Code"
+	},
+	{
+		value: "codex",
+		label: "Codex"
+	},
+	{
+		value: "cursor",
+		label: "Cursor"
+	},
+	{
+		value: "vscode",
+		label: "VS Code"
+	},
+	{
+		value: "github-copilot-cli",
+		label: "GitHub Copilot CLI"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI"
+	},
+	{
+		value: "goose",
+		label: "Goose"
+	},
+	{
+		value: "zed",
+		label: "Zed"
+	},
+	{
+		value: "antigravity",
+		label: "Antigravity"
+	},
+	{
+		value: "cline",
+		label: "Cline VS Code Extension"
+	},
+	{
+		value: "cline-cli",
+		label: "Cline CLI"
+	},
+	{
+		value: "claude-desktop",
+		label: "Claude Desktop"
+	},
+	{
+		value: "mcporter",
+		label: "MCPorter"
+	}
+];
+const SHARED_PRISMA_SKILLS = [
+	"prisma-cli",
+	"prisma-client-api",
+	"prisma-database-setup",
+	"prisma-upgrade-v7"
+];
+function getAvailablePrismaSkills(provider) {
+	const skills = [...SHARED_PRISMA_SKILLS, "prisma-compute"];
+	if (provider === "postgresql") return [...skills, "prisma-postgres"];
+	return skills;
+}
+function getSkillOptions(provider) {
+	const available = getAvailablePrismaSkills(provider);
+	const options = {
+		"prisma-cli": {
+			value: "prisma-cli",
+			label: "prisma-cli",
+			hint: "Prisma CLI reference"
+		},
+		"prisma-client-api": {
+			value: "prisma-client-api",
+			label: "prisma-client-api",
+			hint: "Prisma Client query patterns"
+		},
+		"prisma-compute": {
+			value: "prisma-compute",
+			label: "prisma-compute",
+			hint: "Prisma Compute deploy and hosting workflows"
+		},
+		"prisma-database-setup": {
+			value: "prisma-database-setup",
+			label: "prisma-database-setup",
+			hint: "Database provider setup guides"
+		},
+		"prisma-upgrade-v7": {
+			value: "prisma-upgrade-v7",
+			label: "prisma-upgrade-v7",
+			hint: "v6 to v7 migration guide"
+		},
+		"prisma-postgres": {
+			value: "prisma-postgres",
+			label: "prisma-postgres",
+			hint: "Prisma Postgres workflows"
+		}
+	};
+	return available.map((skill) => options[skill]);
+}
+function collectAddonsFromInput(input) {
+	const addons = [];
+	if (input.skills === true) addons.push("skills");
+	if (input.mcp === true) addons.push("mcp");
+	if (input.extension === true) addons.push("extension");
+	return uniqueValues(addons);
+}
+const EXTENSION_TARGET_OPTIONS = [
+	{
+		value: "vscode",
+		label: "VS Code",
+		hint: "Uses the `code` CLI"
+	},
+	{
+		value: "cursor",
+		label: "Cursor",
+		hint: "Uses the `cursor` CLI"
+	},
+	{
+		value: "windsurf",
+		label: "Windsurf",
+		hint: "Uses the `windsurf` CLI"
+	}
+];
+function uniqueValues(values) {
+	return Array.from(new Set(values));
+}
+function getRecommendedPrismaSkills(provider, shouldUsePrismaPostgres, shouldUseComputeDeploy) {
+	const skills = [...SHARED_PRISMA_SKILLS];
+	if (provider === "postgresql" && shouldUsePrismaPostgres) skills.push("prisma-postgres");
+	if (shouldUseComputeDeploy) skills.push("prisma-compute");
+	return uniqueValues(skills);
+}
+async function promptForAddons() {
+	const selectedAddons = await multiselect({
+		message: "Select add-ons (optional)",
+		options: ADDON_OPTIONS,
+		required: false
+	});
+	if (isCancel(selectedAddons)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAddons);
+}
+async function promptForAddonScope() {
+	const selectedScope = await select({
+		message: "Where should add-ons write config?",
+		initialValue: DEFAULT_ADDON_SCOPE,
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Recommended for teams (checked into the project when applicable)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Personal machine-level setup"
+		}]
+	});
+	if (isCancel(selectedScope)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return selectedScope;
+}
+async function promptForPrismaSkills(provider, recommendedSkills) {
+	const options = getSkillOptions(provider);
+	const optionValues = new Set(options.map((option) => option.value));
+	const selectedSkills = await multiselect({
+		message: "Select Prisma skills",
+		options,
+		required: false,
+		initialValues: recommendedSkills.filter((skill) => optionValues.has(skill))
+	});
+	if (isCancel(selectedSkills)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedSkills);
+}
+async function promptForSkillsAgents() {
+	const selectedAgents = await multiselect({
+		message: "Select agents for skills",
+		options: SKILLS_AGENT_OPTIONS,
+		required: false,
+		initialValues: [...DEFAULT_SKILLS_AGENTS]
+	});
+	if (isCancel(selectedAgents)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAgents);
+}
+async function promptForMcpAgents() {
+	const selectedAgents = await multiselect({
+		message: "Select agents for MCP",
+		options: MCP_AGENT_OPTIONS,
+		required: false,
+		initialValues: [...DEFAULT_MCP_AGENTS]
+	});
+	if (isCancel(selectedAgents)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedAgents);
+}
+async function promptForExtensionTargets() {
+	const selectedTargets = await multiselect({
+		message: "Select IDEs for extension install",
+		options: EXTENSION_TARGET_OPTIONS,
+		required: false,
+		initialValues: DEFAULT_EXTENSION_TARGETS
+	});
+	if (isCancel(selectedTargets)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return uniqueValues(selectedTargets);
+}
+async function collectCreateAddonSetupContext(input, options) {
+	const hasExplicitAddonSelection = input.skills !== void 0 || input.mcp !== void 0 || input.extension !== void 0;
+	const selectedFromInput = collectAddonsFromInput(input);
+	const selectedAddons = selectedFromInput.length > 0 ? selectedFromInput : hasExplicitAddonSelection ? [] : options.useDefaults ? [] : await promptForAddons();
+	if (!selectedAddons) return;
+	const addons = uniqueValues(selectedAddons);
+	if (addons.length === 0) return null;
+	const scope = addons.includes("skills") || addons.includes("mcp") ? options.useDefaults ? DEFAULT_ADDON_SCOPE : await promptForAddonScope() : DEFAULT_ADDON_SCOPE;
+	if (!scope) return;
+	const recommendedSkills = getRecommendedPrismaSkills(options.provider, options.shouldUsePrismaPostgres, options.shouldUseComputeDeploy);
+	const skills = !addons.includes("skills") ? [] : options.useDefaults ? recommendedSkills : await promptForPrismaSkills(options.provider, recommendedSkills);
+	if (!skills) return;
+	const skillsAgents = !addons.includes("skills") ? [] : options.useDefaults ? [...DEFAULT_SKILLS_AGENTS] : await promptForSkillsAgents();
+	if (!skillsAgents) return;
+	const mcpAgents = !addons.includes("mcp") ? [] : options.useDefaults ? [...DEFAULT_MCP_AGENTS] : await promptForMcpAgents();
+	if (!mcpAgents) return;
+	const extensionTargets = !addons.includes("extension") ? [] : options.useDefaults ? [...DEFAULT_EXTENSION_TARGETS] : await promptForExtensionTargets();
+	if (!extensionTargets) return;
+	return {
+		addons,
+		scope,
+		skills,
+		skillsAgents: uniqueValues(skillsAgents),
+		mcpAgents: uniqueValues(mcpAgents),
+		extensionTargets: uniqueValues(extensionTargets)
+	};
+}
+async function executeExternalCommand(params) {
+	await execa(params.command, params.args, {
+		cwd: params.cwd,
+		stdio: params.verbose ? "inherit" : "pipe",
+		env: {
+			...process.env,
+			CI: "true"
+		}
+	});
+}
+async function installSkillsAddon(params) {
+	if (params.agents.length === 0 || params.skills.length === 0) return "Skipped skills addon because no skills or agents were selected.";
+	const scopeArgs = params.scope === "global" ? ["-g"] : [];
+	const skillArgs = params.skills.flatMap((skill) => ["-s", skill]);
+	const agentArgs = params.agents.flatMap((agent) => ["-a", agent]);
+	const commandArgs = [
+		"skills@latest",
+		"add",
+		"prisma/skills",
+		...scopeArgs,
+		...skillArgs,
+		...agentArgs,
+		"-y"
+	];
+	const execution = getPackageExecutionArgs(params.packageManager, commandArgs);
+	try {
+		await executeExternalCommand({
+			command: execution.command,
+			args: execution.args,
+			cwd: params.projectDir,
+			verbose: params.verbose
+		});
+		return;
+	} catch (error) {
+		return `Skills addon failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+async function installMcpAddon(params) {
+	if (params.agents.length === 0) return "Skipped MCP addon because no agents were selected.";
+	const scopeArgs = params.scope === "global" ? ["-g"] : [];
+	const agentArgs = params.agents.flatMap((agent) => ["-a", agent]);
+	const commandArgs = [
+		"add-mcp@latest",
+		PRISMA_MCP_SERVER,
+		...scopeArgs,
+		...agentArgs,
+		"--name",
+		"prisma",
+		"--gitignore",
+		"-y"
+	];
+	const execution = getPackageExecutionArgs(params.packageManager, commandArgs);
+	try {
+		await executeExternalCommand({
+			command: execution.command,
+			args: execution.args,
+			cwd: params.projectDir,
+			verbose: params.verbose
+		});
+		return;
+	} catch (error) {
+		return `MCP addon failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+function getExtensionInstallBinary(target) {
+	switch (target) {
+		case "vscode": return "code";
+		case "cursor": return "cursor";
+		case "windsurf": return "windsurf";
+		default: throw new Error(`Unsupported extension target: ${String(target)}`);
+	}
+}
+async function installExtensionAddon(params) {
+	if (params.targets.length === 0) return ["Skipped extension addon because no IDE targets were selected."];
+	const warnings = [];
+	for (const target of params.targets) {
+		const binary = getExtensionInstallBinary(target);
+		try {
+			await executeExternalCommand({
+				command: binary,
+				args: ["--version"],
+				cwd: params.projectDir,
+				verbose: false
+			});
+		} catch {
+			warnings.push(`Skipped ${target} extension install because the \`${binary}\` CLI is not available.`);
+			continue;
+		}
+		try {
+			await executeExternalCommand({
+				command: binary,
+				args: [
+					"--install-extension",
+					"Prisma.prisma",
+					"--force"
+				],
+				cwd: params.projectDir,
+				verbose: params.verbose
+			});
+		} catch (error) {
+			warnings.push(`${target} extension install failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	return warnings;
+}
+async function executeCreateAddonSetupContext(params) {
+	const { context, packageManager, projectDir, verbose } = params;
+	const addonSpinner = spinner();
+	addonSpinner.start("Applying selected add-ons...");
+	const warnings = [];
+	if (context.addons.includes("skills")) {
+		const warning = await installSkillsAddon({
+			packageManager,
+			projectDir,
+			scope: context.scope,
+			skills: context.skills,
+			agents: context.skillsAgents,
+			verbose
+		});
+		if (warning) warnings.push(warning);
+	}
+	if (context.addons.includes("mcp")) {
+		const warning = await installMcpAddon({
+			packageManager,
+			projectDir,
+			scope: context.scope,
+			agents: context.mcpAgents,
+			verbose
+		});
+		if (warning) warnings.push(warning);
+	}
+	if (context.addons.includes("extension")) {
+		const extensionWarnings = await installExtensionAddon({
+			projectDir,
+			verbose,
+			targets: context.extensionTargets
+		});
+		warnings.push(...extensionWarnings);
+	}
+	if (warnings.length > 0) {
+		addonSpinner.stop("Add-ons applied with warnings.");
+		for (const warning of warnings) log.warn(warning);
+		return;
+	}
+	addonSpinner.stop("Add-ons applied.");
+}
+//#endregion
+//#region src/tasks/deploy-to-compute.ts
+const PRISMA_CLI_PACKAGE = "@prisma/cli@latest";
+const DEPLOY_OPTIONS_BY_TEMPLATE = {
+	hono: {},
+	elysia: {},
+	nest: {},
+	next: {},
+	astro: {},
+	nuxt: {},
+	"tanstack-start": {},
+	turborepo: { configTarget: "api" }
+};
+function getPrismaCliCommand(packageManager) {
+	return getPackageExecutionCommand(getPrismaCliExecutionPackageManager(packageManager), [PRISMA_CLI_PACKAGE]);
+}
+function getPrismaCliAppDeployCommand(packageManager) {
+	return getPackageExecutionCommand(getPrismaCliExecutionPackageManager(packageManager), [
+		PRISMA_CLI_PACKAGE,
+		"app",
+		"deploy"
+	], { silent: true });
+}
+function getComputeDeployScriptMap(context) {
+	const deployArgs = [
+		...getComputeDeployTargetArgs(context),
+		"--prod",
+		"--yes"
+	];
+	return { "compute:deploy": [getPrismaCliAppDeployCommand(context.packageManager), ...deployArgs].join(" ") };
+}
+function getComputeDeployTargetArgs(context) {
+	return context.configTarget ? [context.configTarget] : [];
+}
+function runPrismaCli(packageManager, args, options = {}) {
+	const { silentPackageRunner, ...execaOptions } = options;
+	const execution = getPackageExecutionArgs(getPrismaCliExecutionPackageManager(packageManager), [PRISMA_CLI_PACKAGE, ...args], { silent: silentPackageRunner });
+	return execa(execution.command, execution.args, execaOptions);
+}
+function getPrismaCliExecutionPackageManager(packageManager) {
+	return packageManager === "deno" ? "npm" : packageManager;
+}
+async function isAuthenticated(packageManager) {
+	try {
+		await runPrismaCli(packageManager, [
+			"project",
+			"list",
+			"--json"
+		], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function ensurePrismaCliAvailable(packageManager) {
+	try {
+		await runPrismaCli(packageManager, ["--help"], { stdio: "pipe" });
+		return true;
+	} catch (error) {
+		const command = getPrismaCliCommand(packageManager);
+		if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+			log.warn(`Could not find the selected package manager. Re-run ${command} manually.`);
+			return false;
+		}
+		log.warn(`Could not run ${command}${error instanceof Error ? `: ${redactSecrets(error.message)}` : "."}`);
+		return false;
+	}
+}
+async function collectComputeDeployContext(input, options) {
+	if (!isComputeDeployableTemplate(options.template)) return null;
+	if (input.deploy === false) return null;
+	let wantsDeploy;
+	if (input.deploy === true) wantsDeploy = true;
+	else if (options.useDefaults) return null;
+	else {
+		const confirmed = await confirm({
+			message: "Deploy to Prisma Compute now?",
+			initialValue: false
+		});
+		if (isCancel(confirmed)) {
+			cancel("Operation cancelled.");
+			return;
+		}
+		wantsDeploy = confirmed;
+	}
+	if (!wantsDeploy) return null;
+	if (!await ensurePrismaCliAvailable(options.packageManager)) {
+		if (input.deploy === true) throw createExplicitDeployError("the Prisma CLI is not available");
+		return null;
+	}
+	if (!await isAuthenticated(options.packageManager)) {
+		log.info("Authenticating with Prisma...");
+		try {
+			await runPrismaCli(options.packageManager, ["auth", "login"], { stdio: "inherit" });
+		} catch (error) {
+			log.warn(`Prisma login was not completed${error instanceof Error ? `: ${redactSecrets(error.message)}` : "."}`);
+			if (input.deploy === true) throw createExplicitDeployError("authentication failed", error);
+			return null;
+		}
+	}
+	const deployOptions = DEPLOY_OPTIONS_BY_TEMPLATE[options.template];
+	if (!deployOptions) {
+		if (input.deploy === true) throw createExplicitDeployError(`${options.template} is not supported by prisma app deploy yet`);
+		return null;
+	}
+	return {
+		template: options.template,
+		packageManager: options.packageManager,
+		createProjectName: options.defaultServiceName,
+		configTarget: deployOptions.configTarget
+	};
+}
+function redactSecrets(message) {
+	return message.replace(/(['"])([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)(.*?)\1/g, "$1$2<redacted>$1").replace(/\b([A-Z0-9_]*(?:DATABASE_URL|DIRECT_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY|ACCESS_KEY)[A-Z0-9_]*=)[^\s]+/g, "$1<redacted>");
+}
+function parseJson(stdout) {
+	if (typeof stdout !== "string" || stdout.trim().length === 0) return null;
+	try {
+		return JSON.parse(stdout);
+	} catch {
+		return null;
+	}
+}
+function getJsonErrorMessage(error, fallback) {
+	return error?.summary ?? error?.message ?? error?.name ?? fallback;
+}
+function getErrorMessage(error) {
+	return redactSecrets(error instanceof Error ? error.message : String(error));
+}
+function createDeployError(message) {
+	return new Error(redactSecrets(message ?? "unknown error"));
+}
+function createExplicitDeployError(reason, error) {
+	const detail = error instanceof Error ? `: ${redactSecrets(error.message)}` : "";
+	return /* @__PURE__ */ new Error(`Deploy requested but ${reason}${detail}`);
+}
+async function runPrismaCliJson(params) {
+	try {
+		const { stdout, exitCode } = await runPrismaCli(params.packageManager, params.args, {
+			cwd: params.cwd,
+			reject: false,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			silentPackageRunner: true
+		});
+		const parsed = parseJson(stdout);
+		if (!parsed) return {
+			ok: false,
+			error: new Error(params.invalidOutputError)
+		};
+		if (exitCode !== 0 || !parsed.ok) return {
+			ok: false,
+			error: createDeployError(parsed.ok ? params.fallbackError : getJsonErrorMessage(parsed.error, params.fallbackError))
+		};
+		return {
+			ok: true,
+			result: parsed.result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: new Error(getErrorMessage(error))
+		};
+	}
+}
+function toComputeDeployResult(data) {
+	return {
+		appUrl: data.deployment.url,
+		appId: data.app.id,
+		appName: data.app.name,
+		deploymentId: data.deployment.id,
+		projectId: data.project.id,
+		projectName: data.project.name,
+		branchName: data.branch.name,
+		database: data.branchDatabase?.database
+	};
+}
+async function executeComputeDatabaseSetup(params) {
+	const projectSpinner = spinner();
+	projectSpinner.start("Creating Prisma Compute project...");
+	const projectResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args: [
+			"project",
+			"create",
+			params.context.createProjectName,
+			"--json"
+		],
+		cwd: params.projectDir,
+		fallbackError: "Prisma project create failed.",
+		invalidOutputError: "Invalid prisma project create output"
+	});
+	if (!projectResult.ok) {
+		projectSpinner.error(`Project creation failed: ${projectResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: projectResult.error
+		};
+	}
+	projectSpinner.stop("Prisma Compute project created.");
+	const databaseSpinner = spinner();
+	databaseSpinner.start("Creating Prisma Postgres database...");
+	const databaseResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args: [
+			"database",
+			"create",
+			"main",
+			"--branch",
+			"main",
+			"--json"
+		],
+		cwd: params.projectDir,
+		fallbackError: "Prisma database create failed.",
+		invalidOutputError: "Invalid prisma database create output"
+	});
+	if (!databaseResult.ok) {
+		databaseSpinner.error(`Database creation failed: ${databaseResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: databaseResult.error
+		};
+	}
+	databaseSpinner.stop("Prisma Postgres database created.");
+	return {
+		ok: true,
+		result: {
+			databaseUrl: databaseResult.result.connectionString,
+			projectId: databaseResult.result.projectId,
+			projectName: databaseResult.result.projectName,
+			database: databaseResult.result.database
+		}
+	};
+}
+async function executeComputeDeployContext(params) {
+	const deploySpinner = spinner();
+	deploySpinner.start("Deploying to Prisma Compute...");
+	const args = [
+		"app",
+		"deploy",
+		...getComputeDeployTargetArgs(params.context),
+		"--json",
+		"--yes",
+		"--prod",
+		...params.createProject === false ? [] : ["--create-project", params.context.createProjectName]
+	];
+	const deployResult = await runPrismaCliJson({
+		packageManager: params.context.packageManager,
+		args,
+		cwd: params.projectDir,
+		fallbackError: "Prisma app deploy failed.",
+		invalidOutputError: "Invalid prisma app deploy output"
+	});
+	if (!deployResult.ok) {
+		deploySpinner.error(`Deploy failed: ${deployResult.error.message}`);
+		return {
+			ok: false,
+			cancelled: false,
+			error: deployResult.error
+		};
+	}
+	deploySpinner.stop("Deployed to Prisma Compute.");
+	return {
+		ok: true,
+		result: toComputeDeployResult(deployResult.result)
+	};
+}
+//#endregion
+//#region src/telemetry/client.ts
+const TELEMETRY_API_KEY = "phc_cmc85avbWyuJ2JyKdGPdv7dxXli8xLdWDBPbvIXWJfs";
+const TELEMETRY_HOST = "https://us.i.posthog.com";
+const TELEMETRY_CONFIG_FILE = "telemetry.json";
+const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isTruthyEnvValue(value) {
+	return [
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(String(value ?? "").trim().toLowerCase());
+}
+function shouldDisableTelemetry() {
+	if (isTruthyEnvValue(process.env.CI) || isTruthyEnvValue(process.env.GITHUB_ACTIONS)) return true;
+	return process.env.CREATE_PRISMA_DISABLE_TELEMETRY !== void 0 || process.env.CREATE_PRISMA_TELEMETRY_DISABLED !== void 0 || process.env.DO_NOT_TRACK !== void 0;
+}
+function getTelemetryConfigDir() {
+	if (process.platform === "darwin") return path.join(os$1.homedir(), "Library", "Application Support", "create-prisma");
+	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os$1.homedir(), "AppData", "Roaming"), "create-prisma");
+	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os$1.homedir(), ".config"), "create-prisma");
+}
+async function getAnonymousId() {
+	const telemetryConfigPath = path.join(getTelemetryConfigDir(), TELEMETRY_CONFIG_FILE);
+	try {
+		const config = await fs.readJSON(telemetryConfigPath);
+		if (typeof config.anonymousId === "string" && UUID_V4_REGEX.test(config.anonymousId)) return config.anonymousId;
+	} catch {}
+	const anonymousId = randomUUID();
+	try {
+		await fs.ensureDir(path.dirname(telemetryConfigPath));
+		await fs.writeJSON(telemetryConfigPath, { anonymousId }, { spaces: 2 });
+	} catch {}
+	return anonymousId;
+}
+function getCommonProperties() {
+	return {
+		"cli-version": "0.7.2",
+		"node-version": process.version,
+		platform: process.platform,
+		arch: process.arch
+	};
+}
+function sanitizeProperties(properties) {
+	return Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0));
+}
+async function trackCliTelemetry(event, properties) {
+	if (shouldDisableTelemetry()) return;
+	let client;
+	try {
+		const distinctId = await getAnonymousId();
+		const sanitizedProperties = sanitizeProperties({
+			...getCommonProperties(),
+			...properties,
+			$process_person_profile: false
+		});
+		client = new PostHog(TELEMETRY_API_KEY, {
+			host: TELEMETRY_HOST,
+			disableGeoip: true,
+			flushAt: 1,
+			flushInterval: 0
+		});
+		await client.captureImmediate({
+			distinctId,
+			event,
+			properties: sanitizedProperties,
+			disableGeoip: true
+		});
+	} catch {} finally {
+		if (client) await client.shutdown().catch(() => {});
+	}
+}
+//#endregion
+//#region src/telemetry/create.ts
+function getRequestedAddons(input) {
+	const addons = [];
+	if (input.skills === true) addons.push("skills");
+	if (input.mcp === true) addons.push("mcp");
+	if (input.extension === true) addons.push("extension");
+	return addons;
+}
+function getTargetDirectoryState(context) {
+	if (!context.targetPathState.exists) return "new";
+	if (context.targetPathState.isEmptyDirectory) return "empty_directory";
+	return "non_empty_directory";
+}
+function getBaseCreateProperties(input, context) {
+	const resolvedAddons = context?.addonSetupContext?.addons ?? getRequestedAddons(input);
+	return {
+		command: "create",
+		"uses-defaults": input.yes === true,
+		verbose: input.verbose === true,
+		force: input.force === true,
+		template: context?.template ?? input.template ?? null,
+		"database-provider": context?.prismaSetupContext.databaseProvider ?? input.provider ?? null,
+		"package-manager": context?.prismaSetupContext.packageManager ?? input.packageManager ?? null,
+		"schema-preset": context?.prismaSetupContext.schemaPreset ?? input.schemaPreset ?? null,
+		"should-install": context?.prismaSetupContext.shouldInstall ?? input.install ?? null,
+		"should-generate": context?.prismaSetupContext.shouldGenerate ?? input.generate ?? null,
+		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? input.prismaPostgres ?? null,
+		addons: resolvedAddons,
+		"addon-count": resolvedAddons.length,
+		"addon-scope": context?.addonSetupContext?.scope ?? null,
+		"skills-count": context?.addonSetupContext?.skills.length ?? null,
+		"skills-agents-count": context?.addonSetupContext?.skillsAgents.length ?? null,
+		"mcp-agents-count": context?.addonSetupContext?.mcpAgents.length ?? null,
+		"extension-target-count": context?.addonSetupContext?.extensionTargets.length ?? null,
+		"target-directory-state": context ? getTargetDirectoryState(context) : null
+	};
+}
+function getErrorName(error) {
+	if (error instanceof Error) return error.name;
+	return error === void 0 ? null : "UnknownError";
+}
+function getErrorCode(error) {
+	if (typeof error !== "object" || error === null) return null;
+	const exitCode = Reflect.get(error, "exitCode");
+	if (typeof exitCode === "number") return exitCode;
+	const code = Reflect.get(error, "code");
+	return typeof code === "number" || typeof code === "string" ? code : null;
+}
+async function trackCreateCompleted(params) {
+	await trackCliTelemetry("cli:create_command_completed", {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs
+	});
+}
+async function trackCreateFailed(params) {
+	await trackCliTelemetry("cli:create_command_failed", {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs,
+		"failure-stage": params.stage,
+		"error-name": getErrorName(params.error),
+		"error-code": getErrorCode(params.error)
+	});
+}
+//#endregion
+//#region src/ui/branding.ts
+const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
+function getCreatePrismaIntro() {
+	return prismaTitle;
+}
+//#endregion
+//#region src/commands/create.ts
+const DEFAULT_PROJECT_NAME = "my-app";
+const DEFAULT_TEMPLATE = "hono";
+const DEFAULT_SCHEMA_PRESET = "basic";
+function toPackageName(projectName) {
+	return projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
+}
+function formatPathForDisplay(filePath) {
+	return path.relative(process.cwd(), filePath) || ".";
+}
+function validateProjectName(value) {
+	const trimmed = String(value ?? "").trim();
+	if (trimmed.length === 0) return "Please enter a project name.";
+	if (trimmed === "..") return "Project name cannot be '..'.";
+	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
+}
+async function promptForProjectName() {
+	const projectName = await text({
+		message: "Project name",
+		placeholder: DEFAULT_PROJECT_NAME,
+		initialValue: DEFAULT_PROJECT_NAME,
+		validate: validateProjectName
+	});
+	if (isCancel(projectName)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return String(projectName).trim();
+}
+async function promptForCreateTemplate() {
+	const template = await select({
+		message: "Select template",
+		initialValue: DEFAULT_TEMPLATE,
+		options: [
+			{
+				value: "hono",
+				label: "Hono",
+				hint: "TypeScript API starter"
+			},
+			{
+				value: "elysia",
+				label: "Elysia",
+				hint: "TypeScript API starter with Elysia's Node adapter"
+			},
+			{
+				value: "nest",
+				label: "NestJS",
+				hint: "Official Nest-style API starter with a Prisma service"
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "App Router + TypeScript starter"
+			},
+			{
+				value: "svelte",
+				label: "SvelteKit",
+				hint: "Official minimal SvelteKit + TypeScript starter"
+			},
+			{
+				value: "astro",
+				label: "Astro",
+				hint: "Official minimal Astro starter with API route example"
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "Official minimal Nuxt starter with Nitro API route example"
+			},
+			{
+				value: "tanstack-start",
+				label: "TanStack Start",
+				hint: "TanStack Start React app with file routes and server functions"
+			},
+			{
+				value: "turborepo",
+				label: "Turborepo",
+				hint: "Monorepo starter with apps + packages/db Prisma package"
+			}
+		]
+	});
+	if (isCancel(template)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return CreateTemplateSchema.parse(template);
+}
+async function inspectTargetPath(targetPath) {
+	if (!await fs.pathExists(targetPath)) return {
+		exists: false,
+		isDirectory: true,
+		isEmptyDirectory: true
+	};
+	if (!(await fs.stat(targetPath)).isDirectory()) return {
+		exists: true,
+		isDirectory: false,
+		isEmptyDirectory: false
+	};
+	return {
+		exists: true,
+		isDirectory: true,
+		isEmptyDirectory: (await fs.readdir(targetPath)).length === 0
+	};
+}
+async function runCreateCommand(rawInput = {}) {
+	const startedAt = Date.now();
+	let input = {};
+	let context;
+	let failureStage = "validate_input";
+	try {
+		input = CreateCommandInputSchema.parse(rawInput);
+		intro(getCreatePrismaIntro());
+		failureStage = "collect_context";
+		context = await collectCreateContext(input);
+		if (!context) return;
+		failureStage = "unknown";
+		const executionResult = await executeCreateContext(context);
+		if (!executionResult.ok) {
+			if (executionResult.error) cancel(`Create command failed: ${executionResult.error instanceof Error ? executionResult.error.message : String(executionResult.error)}`);
+			await trackCreateFailed({
+				input,
+				context,
+				durationMs: Date.now() - startedAt,
+				error: executionResult.error,
+				stage: executionResult.stage
+			});
+			return;
+		}
+		await trackCreateCompleted({
+			input,
+			context,
+			durationMs: Date.now() - startedAt
+		});
+	} catch (error) {
+		cancel(`Create command failed: ${error instanceof Error ? error.message : String(error)}`);
+		await trackCreateFailed({
+			input,
+			context,
+			durationMs: Date.now() - startedAt,
+			error,
+			stage: failureStage
+		});
+	}
+}
+async function collectCreateContext(input) {
+	const useDefaults = input.yes === true;
+	const force = input.force === true;
+	const projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
+	if (projectNameInput === void 0) return;
+	const projectName = String(projectNameInput).trim();
+	const projectNameValidationError = validateProjectName(projectName);
+	if (projectNameValidationError) {
+		cancel(projectNameValidationError);
+		return;
+	}
+	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
+	if (!template) return;
+	const targetDirectory = path.resolve(process.cwd(), projectName);
+	const targetPathState = await inspectTargetPath(targetDirectory);
+	if (targetPathState.exists && !targetPathState.isDirectory) {
+		cancel(`Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`);
+		return;
+	}
+	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
+		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
+		return;
+	}
+	const prismaSetupInitialContext = await collectPrismaSetupInitialContext(input, {
+		projectDir: targetDirectory,
+		defaultSchemaPreset: DEFAULT_SCHEMA_PRESET
+	});
+	if (!prismaSetupInitialContext) return;
+	const projectPackageName = toPackageName(path.basename(targetDirectory));
+	const computeDeployContext = await collectComputeDeployContext(input, {
+		template,
+		packageManager: prismaSetupInitialContext.packageManager,
+		useDefaults,
+		defaultServiceName: projectPackageName
+	});
+	if (computeDeployContext === void 0) return;
+	const prismaSetupContext = await completePrismaSetupContext(input, prismaSetupInitialContext);
+	if (!prismaSetupContext) return;
+	const useComputeDatabase = Boolean(computeDeployContext && prismaSetupContext.shouldUsePrismaPostgres);
+	if (useComputeDatabase) log.info("Prisma Postgres selected: create-prisma will provision a database and write DATABASE_URL to the template env file before deploying.");
+	const addonSetupContext = await collectCreateAddonSetupContext(input, {
+		useDefaults,
+		provider: prismaSetupContext.databaseProvider,
+		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres,
+		shouldUseComputeDeploy: Boolean(computeDeployContext)
+	});
+	if (addonSetupContext === void 0) return;
+	return {
+		targetDirectory,
+		targetPathState,
+		force,
+		template,
+		projectPackageName,
+		prismaSetupContext,
+		addonSetupContext: addonSetupContext ?? void 0,
+		computeDeployContext: computeDeployContext ?? void 0,
+		useComputeDatabase
+	};
+}
+async function executeCreateContext(context) {
+	const scaffoldSpinner = spinner();
+	scaffoldSpinner.start(`Scaffolding ${context.template} project...`);
+	try {
+		await scaffoldCreateTemplate({
+			projectDir: context.targetDirectory,
+			projectName: context.projectPackageName,
+			template: context.template,
+			schemaPreset: context.prismaSetupContext.schemaPreset,
+			provider: context.prismaSetupContext.databaseProvider,
+			packageManager: context.prismaSetupContext.packageManager,
+			compute: Boolean(context.computeDeployContext)
+		});
+		scaffoldSpinner.stop("Project files scaffolded.");
+	} catch (error) {
+		scaffoldSpinner.stop("Could not scaffold project files.");
+		return {
+			ok: false,
+			stage: "scaffold_template",
+			error
+		};
+	}
+	try {
+		await writeCreateTemplateDependencies({
+			template: context.template,
+			packageManager: context.prismaSetupContext.packageManager,
+			projectDir: context.targetDirectory
+		});
+		if (context.computeDeployContext) await addPackageDependency({
+			scripts: getComputeDeployScriptMap(context.computeDeployContext),
+			scriptMode: "if-missing",
+			projectDir: context.targetDirectory
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "scaffold_template",
+			error
+		};
+	}
+	if (context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.`);
+	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [`- cd ${formatPathForDisplay(context.targetDirectory)}`];
+	if (context.addonSetupContext) try {
+		await executeCreateAddonSetupContext({
+			context: context.addonSetupContext,
+			packageManager: context.prismaSetupContext.packageManager,
+			projectDir: context.targetDirectory,
+			verbose: context.prismaSetupContext.verbose
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "addons",
+			error
+		};
+	}
+	let computeDatabaseResult;
+	if (context.useComputeDatabase && context.computeDeployContext) try {
+		const result = await executeComputeDatabaseSetup({
+			context: context.computeDeployContext,
+			projectDir: context.targetDirectory
+		});
+		if (!result.ok && !result.cancelled) return {
+			ok: false,
+			stage: "compute_deploy",
+			error: result.error
+		};
+		if (result.ok) computeDatabaseResult = result.result;
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "compute_deploy",
+			error
+		};
+	}
+	const prismaSetupContext = computeDatabaseResult ? {
+		...context.prismaSetupContext,
+		databaseUrl: computeDatabaseResult.databaseUrl,
+		shouldUsePrismaPostgres: false
+	} : context.prismaSetupContext;
+	let prismaResult;
+	try {
+		prismaResult = await executePrismaSetupContext(prismaSetupContext, {
+			prependNextSteps: nextSteps,
+			projectDir: context.targetDirectory,
+			includeDevNextStep: !context.useComputeDatabase
+		});
+		if (!prismaResult.ok) return {
+			ok: false,
+			stage: "prisma_setup"
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "prisma_setup",
+			error
+		};
+	}
+	let deployResult;
+	if (context.computeDeployContext) try {
+		const result = await executeComputeDeployContext({
+			context: context.computeDeployContext,
+			projectDir: context.targetDirectory,
+			createProject: !computeDatabaseResult
+		});
+		if (!result.ok && !result.cancelled) return {
+			ok: false,
+			stage: "compute_deploy",
+			error: result.error
+		};
+		if (result.ok) {
+			deployResult = result.result;
+			prismaResult.nextSteps.push(`- ${getRunScriptCommand(context.prismaSetupContext.packageManager, "compute:deploy")}`);
+		}
+	} catch (error) {
+		return {
+			ok: false,
+			stage: "compute_deploy",
+			error
+		};
+	}
+	const summaryLines = [];
+	summaryLines.push(`Setup complete.${prismaResult.warningSection}`);
+	if (deployResult) {
+		const database = computeDatabaseResult?.database ?? deployResult.database;
+		summaryLines.push("", "Deployed to Prisma Compute:", ...deployResult.appUrl ? [`- App URL: ${deployResult.appUrl}`] : [], `- App: ${deployResult.appName} (${deployResult.appId})`, `- Deployment: ${deployResult.deploymentId}`, ...database ? [`- Database: ${database.name} (${database.id})`] : []);
+	}
+	summaryLines.push("", "Next steps:", prismaResult.nextSteps.join("\n"));
+	outro(summaryLines.join("\n"));
+	return { ok: true };
+}
+//#endregion
+//#region src/index.ts
+const CLI_VERSION = "0.7.2";
+const router = os.router({ create: os.meta({
+	description: "Create a new project with Prisma setup",
+	default: true,
+	negateBooleans: true
+}).input(CreateCommandInputSchema.optional()).handler(async ({ input }) => {
+	await runCreateCommand(input ?? {});
+}) });
+function createCreatePrismaCli() {
+	return createCli({
+		router,
+		name: "create-prisma",
+		version: CLI_VERSION
+	});
+}
+async function create(input = {}) {
+	await runCreateCommand(input);
+}
+//#endregion
+export { CreateTemplateSchema as a, PackageManagerSchema as c, CreateCommandInputSchema as i, SchemaPresetSchema as l, createCreatePrismaCli as n, DatabaseProviderSchema as o, router as r, DatabaseUrlSchema as s, create as t };