create-prisma 0.4.1 → 0.4.2-next.37.104.1

package/dist/{create-H6Tk0JlE.mjs → create-BeFhatOc.mjs}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, text } from "@clack/prompts";
 import fs from "fs-extra";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { PostHog } from "posthog-node";
 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 from "node:os";
-import { PostHog } from "posthog-node";
 import { styleText } from "node:util";
 
 //#region src/utils/runtime.ts
@@ -24,23 +24,60 @@ function requiresDotenvConfigImport(packageManager) {
 //#region src/constants/dependencies.ts
 const dependencyVersionMap = {
 	"@elysiajs/node": "^1.4.5",
-	"@prisma/client": "^7.4.0",
-	"@prisma/adapter-pg": "^7.4.0",
-	"@prisma/adapter-mariadb": "^7.4.0",
-	"@prisma/adapter-better-sqlite3": "^7.4.0",
-	"@prisma/adapter-mssql": "^7.4.0",
-	"@types/node": "^24.3.0",
-	dotenv: "^17.2.3",
-	"node-gyp": "^11.5.0",
-	prisma: "^7.4.0",
+	"@types/node": "^25.6.2",
+	dotenv: "^17.4.2",
+	"mongodb-memory-server": "^11.1.0",
 	tsx: "^4.21.0"
 };
-function getWorkspaceDependencyVersion(packageManager) {
-	return packageManager === "npm" ? "*" : "workspace:*";
+const PRISMA_NEXT_DEFAULT_VERSION = "latest";
+const PKG_PR_NEW_PREFIX = "pkg-pr-new:";
+const PKG_PR_NEW_BASE_URL = "https://pkg.pr.new/prisma/prisma-next";
+const DEFAULT_PRISMA_NEXT_SPEC = {
+	kind: "npm",
+	spec: PRISMA_NEXT_DEFAULT_VERSION
+};
+function parsePrismaNextVersionSpec(input) {
+	if (input === void 0) return DEFAULT_PRISMA_NEXT_SPEC;
+	const trimmed = input.trim();
+	if (trimmed.length === 0) return DEFAULT_PRISMA_NEXT_SPEC;
+	if (trimmed.startsWith(PKG_PR_NEW_PREFIX)) {
+		const ref = trimmed.slice(11).trim();
+		if (ref.length === 0) throw new Error(`Invalid --prisma-next-version value: '${input}'. Expected 'pkg-pr-new:<sha|branch|pr-number>'.`);
+		return {
+			kind: "pkg-pr-new",
+			ref
+		};
+	}
+	return {
+		kind: "npm",
+		spec: trimmed
+	};
+}
+function isPrismaNextPackage(packageName) {
+	return packageName === "prisma-next" || packageName.startsWith("@prisma-next/");
+}
+function getPrismaNextPackageSpecifier(packageName, spec = DEFAULT_PRISMA_NEXT_SPEC) {
+	if (spec.kind === "pkg-pr-new") return `${PKG_PR_NEW_BASE_URL}/${packageName}@${spec.ref}`;
+	return `${packageName}@${spec.spec}`;
+}
+function getDependencyVersion(packageName, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	if (isPrismaNextPackage(packageName)) {
+		if (prismaNextSpec.kind === "pkg-pr-new") return `${PKG_PR_NEW_BASE_URL}/${packageName}@${prismaNextSpec.ref}`;
+		return prismaNextSpec.spec;
+	}
+	return dependencyVersionMap[packageName];
+}
+function usesViteDevServer(template) {
+	return template === "astro" || template === "nuxt" || template === "svelte" || template === "tanstack-start";
 }
 function getCreateTemplateDependencies(template, packageManager) {
 	const targets = [];
-	if (template === "hono" || template === "elysia" || template === "nest") {
+	if (usesViteDevServer(template)) targets.push({
+		packageJsonPath: "package.json",
+		dependencies: [],
+		devDependencies: ["@prisma-next/vite-plugin-contract-emit"]
+	});
+	if (template === "minimal" || template === "hono" || template === "elysia" || template === "nest") {
 		const runtimeDevDependencies = usesNodeStyleRuntime(packageManager) ? ["tsx"] : [];
 		if (template === "elysia" && packageManager !== "deno") targets.push({
 			packageJsonPath: "package.json",
@@ -53,23 +90,155 @@ function getCreateTemplateDependencies(template, packageManager) {
 			devDependencies: runtimeDevDependencies
 		});
 	}
-	if (template === "turborepo") targets.push({
-		packageJsonPath: "apps/api/package.json",
-		dependencies: [],
-		devDependencies: ["tsx"],
-		customDependencies: { "@repo/db": getWorkspaceDependencyVersion(packageManager) }
-	});
 	return targets;
 }
 
+//#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.homedir(), "Library", "Application Support", "create-prisma");
+	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "create-prisma");
+	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.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.4.2-next.37.104.1",
+		"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 classifyPrismaNextSpec(spec) {
+	if (!spec || spec === DEFAULT_PRISMA_NEXT_SPEC) return "default";
+	if (spec.kind === "pkg-pr-new") return "pkg-pr-new";
+	if (spec.spec === PRISMA_NEXT_DEFAULT_VERSION) return "default";
+	return /^[0-9]/.test(spec.spec) ? "npm-version" : "npm-tag";
+}
+function getPrismaNextVersionSpecString(spec) {
+	if (!spec) return null;
+	return spec.kind === "pkg-pr-new" ? `pkg-pr-new:${spec.ref}` : spec.spec;
+}
+const CREATE_PRISMA_NEXT_COMPLETED_EVENT = "cli:create_prisma_next_command_completed";
+const CREATE_PRISMA_NEXT_FAILED_EVENT = "cli:create_prisma_next_command_failed";
+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 resolvedPrismaNextSpec = context?.prismaSetupContext.prismaNextSpec;
+	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,
+		"authoring-style": context?.prismaSetupContext.authoring ?? input.authoring ?? null,
+		"package-manager": context?.prismaSetupContext.packageManager ?? input.packageManager ?? null,
+		"should-install": context?.prismaSetupContext.shouldInstall ?? input.install ?? null,
+		"should-emit": context?.prismaSetupContext.shouldEmit ?? input.emit ?? null,
+		"uses-prisma-postgres": context?.prismaSetupContext.shouldUsePrismaPostgres ?? input.prismaPostgres ?? null,
+		"target-directory-state": context ? getTargetDirectoryState(context) : null,
+		"prisma-next-version-kind": classifyPrismaNextSpec(resolvedPrismaNextSpec),
+		"prisma-next-version-spec": getPrismaNextVersionSpecString(resolvedPrismaNextSpec) ?? input.prismaNextVersion ?? 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(CREATE_PRISMA_NEXT_COMPLETED_EVENT, {
+		...getBaseCreateProperties(params.input, params.context),
+		"duration-ms": params.durationMs
+	});
+}
+async function trackCreateFailed(params) {
+	await trackCliTelemetry(CREATE_PRISMA_NEXT_FAILED_EVENT, {
+		...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/types.ts
-const databaseProviders = [
+const databaseProviderInputs = [
+	"postgres",
 	"postgresql",
-	"mysql",
-	"sqlite",
-	"sqlserver",
-	"cockroachdb"
+	"mongo",
+	"mongodb"
 ];
 const packageManagers = [
 	"npm",
@@ -78,8 +247,9 @@ const packageManagers = [
 	"bun",
 	"deno"
 ];
-const schemaPresets = ["empty", "basic"];
+const authoringStyles = ["psl", "typescript"];
 const createTemplates = [
+	"minimal",
 	"hono",
 	"elysia",
 	"nest",
@@ -87,56 +257,36 @@ const createTemplates = [
 	"svelte",
 	"astro",
 	"nuxt",
-	"tanstack-start",
-	"turborepo"
+	"tanstack-start"
 ];
-const createAddons = [
-	"skills",
-	"mcp",
-	"extension"
-];
-const addonInstallScopes = ["project", "global"];
-const extensionTargets = [
-	"vscode",
-	"cursor",
-	"windsurf"
-];
-const prismaSkillNames = [
-	"prisma-cli",
-	"prisma-client-api",
-	"prisma-database-setup",
-	"prisma-upgrade-v7",
-	"prisma-postgres"
-];
-const DatabaseProviderSchema = z.enum(databaseProviders);
+function normalizeDatabaseProvider(value) {
+	if (value === "postgresql") return "postgres";
+	if (value === "mongodb") return "mongo";
+	return value;
+}
+const DatabaseProviderSchema = z.enum(databaseProviderInputs).transform(normalizeDatabaseProvider);
 const PackageManagerSchema = z.enum(packageManagers);
-const SchemaPresetSchema = z.enum(schemaPresets);
+const AuthoringStyleSchema = z.enum(authoringStyles);
 const CreateTemplateSchema = z.enum(createTemplates);
-const CreateAddonSchema = z.enum(createAddons);
-const AddonInstallScopeSchema = z.enum(addonInstallScopes);
-const ExtensionTargetSchema = z.enum(extensionTargets);
-const PrismaSkillNameSchema = 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"),
+	provider: DatabaseProviderSchema.optional().describe("Prisma Next database target: PostgreSQL relational models or MongoDB document models"),
+	authoring: AuthoringStyleSchema.optional().describe("Contract authoring style"),
 	packageManager: PackageManagerSchema.optional().describe("Package manager used for dependency installation"),
-	prismaPostgres: z.boolean().optional().describe("Provision Prisma Postgres with create-db when provider is postgresql"),
+	prismaPostgres: z.boolean().optional().describe("Provision Prisma Postgres with create-db when target is postgres"),
 	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"),
-	schemaPreset: SchemaPresetSchema.optional().describe("Schema preset to scaffold in prisma/schema.prisma")
+	emit: z.boolean().optional().describe("Emit Prisma Next contract artifacts after scaffolding"),
+	prismaNextVersion: z.string().trim().min(1).optional().describe("Prisma Next version, npm dist-tag, or 'pkg-pr-new:<sha|branch|pr>' (default: latest)")
 });
 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"),
 	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
 });
 const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
@@ -221,13 +371,17 @@ function getPackageManagerManifestValue(packageManager) {
 	return packageManagerManifestValues[packageManager];
 }
 function getDenoPrismaSpecifier() {
-	return `npm:prisma@${dependencyVersionMap.prisma}`;
+	return "npm:prisma-next";
+}
+function getDenoNpmSpecifier(packageSpecifier) {
+	return `npm:${packageSpecifier.replace(/@latest$/, "")}`;
 }
 function getDenoAllowedScriptSpecifiers() {
 	return [
-		`npm:prisma@${dependencyVersionMap.prisma}`,
-		`npm:@prisma/client@${dependencyVersionMap["@prisma/client"]}`,
-		`npm:@prisma/engines@${dependencyVersionMap.prisma}`
+		"npm:prisma-next",
+		"npm:@prisma-next/postgres",
+		"npm:@prisma-next/mongo",
+		"npm:mongodb-memory-server"
 	].join(",");
 }
 function getInstallCommand(packageManager) {
@@ -311,7 +465,7 @@ function getPackageExecutionArgs(packageManager, commandArgs) {
 				args: [
 					"run",
 					"-A",
-					`npm:${packageName}`,
+					getDenoNpmSpecifier(packageName),
 					...args
 				]
 			};
@@ -326,26 +480,46 @@ function getPackageExecutionCommand(packageManager, commandArgs) {
 	const execution = getPackageExecutionArgs(packageManager, commandArgs);
 	return [execution.command, ...execution.args].join(" ");
 }
-function getPrismaCliArgs(packageManager, prismaArgs) {
-	if (packageManager === "bun") return getPackageExecutionArgs(packageManager, [
-		"--bun",
-		"prisma",
-		...prismaArgs
-	]);
-	if (packageManager === "deno") return {
-		command: "deno",
-		args: [
-			"run",
-			"-A",
-			"--env-file=.env",
-			getDenoPrismaSpecifier(),
-			...prismaArgs
-		]
-	};
-	return getPackageExecutionArgs(packageManager, ["prisma", ...prismaArgs]);
+function getLocalPackageBinaryArgs(packageManager, binaryName, binaryArgs) {
+	switch (packageManager) {
+		case "pnpm": return {
+			command: "pnpm",
+			args: [
+				"exec",
+				binaryName,
+				...binaryArgs
+			]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: [binaryName, ...binaryArgs]
+		};
+		case "bun": return {
+			command: "bun",
+			args: [binaryName, ...binaryArgs]
+		};
+		case "deno": return {
+			command: "deno",
+			args: [
+				"run",
+				"-A",
+				`npm:${binaryName}`,
+				...binaryArgs
+			]
+		};
+		default: return {
+			command: "npm",
+			args: [
+				"exec",
+				binaryName,
+				"--",
+				...binaryArgs
+			]
+		};
+	}
 }
-function getPrismaCliCommand(packageManager, prismaArgs) {
-	const execution = getPrismaCliArgs(packageManager, prismaArgs);
+function getLocalPackageBinaryCommand(packageManager, binaryName, binaryArgs) {
+	const execution = getLocalPackageBinaryArgs(packageManager, binaryName, binaryArgs);
 	return [execution.command, ...execution.args].join(" ");
 }
 
@@ -431,97 +605,133 @@ async function renderTemplateTree(opts) {
 function getCreateTemplateDir(template) {
 	return resolveTemplatesDir(`templates/create/${template}`);
 }
-function createTemplateContext(projectName, provider, schemaPreset, packageManager) {
+function getCreateSharedTemplateDir() {
+	return resolveTemplatesDir("templates/create/_shared");
+}
+function createTemplateContext(projectName, template, provider, authoring, packageManager) {
 	return {
 		projectName,
+		template,
 		provider,
-		schemaPreset,
+		authoring,
 		packageManager
 	};
 }
 async function scaffoldCreateTemplate(opts) {
-	const { projectDir, projectName, template, provider, schemaPreset, packageManager } = opts;
+	const { projectDir, projectName, template, provider, authoring, packageManager } = opts;
+	const templateRoot = getCreateTemplateDir(template);
+	const sharedTemplateRoot = getCreateSharedTemplateDir();
+	const context = createTemplateContext(projectName, template, provider, authoring, packageManager);
+	await renderTemplateTree({
+		templateRoot: sharedTemplateRoot,
+		outputDir: projectDir,
+		context
+	});
 	await renderTemplateTree({
-		templateRoot: getCreateTemplateDir(template),
+		templateRoot,
 		outputDir: projectDir,
-		context: createTemplateContext(projectName, provider, schemaPreset, packageManager)
+		context
 	});
 }
 
 //#endregion
 //#region src/constants/db-packages.ts
-function getDbPackages(provider) {
+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-better-sqlite3";
-		case "sqlserver": return "@prisma/adapter-mssql";
+		case "postgres": return "@prisma-next/postgres";
+		case "mongo": return "@prisma-next/mongo";
 		default: {
 			const exhaustiveCheck = provider;
-			throw new Error(`Unsupported database provider: ${String(exhaustiveCheck)}`);
+			throw new Error(`Unsupported Prisma Next target: ${String(exhaustiveCheck)}`);
 		}
 	}
 }
 
 //#endregion
 //#region src/tasks/install.ts
-function getPrismaScriptMap(packageManager) {
+function getPrismaNextScriptMap(packageManager) {
 	if (packageManager === "deno") {
-		const prismaSpecifier = getDenoPrismaSpecifier();
+		const prismaNextCli = `deno run -A --env-file=.env ${getDenoPrismaSpecifier()}`;
 		return {
-			"db:generate": `deno run -A --env-file=.env ${prismaSpecifier} generate`,
-			"db:push": `deno run -A --env-file=.env ${prismaSpecifier} db push`,
-			"db:migrate": `deno run -A --env-file=.env ${prismaSpecifier} migrate dev`,
-			"db:seed": `deno run -A --env-file=.env ${prismaSpecifier} db seed`
+			"contract:emit": `${prismaNextCli} contract emit`,
+			"db:init": `${prismaNextCli} db init`,
+			"db:update": `${prismaNextCli} db update`,
+			"db:verify": `${prismaNextCli} db verify`,
+			"db:seed": "deno run -A --env-file=.env prisma/seed.ts",
+			"migration:plan": `${prismaNextCli} migration plan`,
+			migrate: `${prismaNextCli} migrate`,
+			"migration:status": `${prismaNextCli} migration status`,
+			"migration:show": `${prismaNextCli} migration show`
 		};
 	}
 	if (packageManager === "bun") {
-		const prismaCli = "bun --env-file=.env ./node_modules/.bin/prisma";
+		const prismaNextCli = "bun prisma-next";
 		return {
-			"db:generate": `${prismaCli} generate`,
-			"db:push": `${prismaCli} db push`,
-			"db:migrate": `${prismaCli} migrate dev`,
-			"db:seed": `${prismaCli} db seed`
+			"contract:emit": `${prismaNextCli} contract emit`,
+			"db:init": `${prismaNextCli} db init`,
+			"db:update": `${prismaNextCli} db update`,
+			"db:verify": `${prismaNextCli} db verify`,
+			"db:seed": "bun prisma/seed.ts",
+			"migration:plan": `${prismaNextCli} migration plan`,
+			migrate: `${prismaNextCli} migrate`,
+			"migration:status": `${prismaNextCli} migration status`,
+			"migration:show": `${prismaNextCli} migration show`
 		};
 	}
 	return {
-		"db:generate": "prisma generate",
-		"db:push": "prisma db push",
-		"db:migrate": "prisma migrate dev",
-		"db:seed": "prisma db seed"
+		"contract:emit": "prisma-next contract emit",
+		"db:init": "prisma-next db init",
+		"db:update": "prisma-next db update",
+		"db:verify": "prisma-next db verify",
+		"db:seed": "tsx prisma/seed.ts",
+		"migration:plan": "prisma-next migration plan",
+		migrate: "prisma-next migrate",
+		"migration:status": "prisma-next migration status",
+		"migration:show": "prisma-next migration show"
 	};
 }
-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;
+function getGeneratedContractTypePackages(provider) {
+	if (provider === "mongo") return [
+		"@prisma-next/adapter-mongo",
+		"@prisma-next/contract",
+		"@prisma-next/mongo-contract"
+	];
+	return [
+		"@prisma-next/adapter-postgres",
+		"@prisma-next/contract",
+		"@prisma-next/sql-contract",
+		"@prisma-next/target-postgres"
+	];
+}
+function getTypeScriptContractPackages(provider) {
+	if (provider === "mongo") return [
+		...getGeneratedContractTypePackages(provider),
+		"@prisma-next/family-mongo",
+		"@prisma-next/mongo-contract-ts",
+		"@prisma-next/target-mongo"
+	];
+	return [
+		...getGeneratedContractTypePackages(provider),
+		"@prisma-next/family-sql",
+		"@prisma-next/sql-contract-ts"
+	];
+}
+function getMigrationPackages(provider) {
+	if (provider === "mongo") return ["@prisma-next/family-mongo", "@prisma-next/target-mongo"];
+	return ["@prisma-next/target-postgres"];
+}
+function getOrmTypePackages(provider) {
+	if (provider === "mongo") return ["@prisma-next/mongo-orm"];
+	return ["@prisma-next/sql-orm-client"];
 }
 async function addPackageDependency(opts) {
-	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir } = opts;
+	const { dependencies = [], devDependencies = [], customDependencies = {}, scripts = {}, scriptMode, projectDir, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC } = 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);
@@ -529,12 +739,12 @@ async function addPackageDependency(opts) {
 	if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
 	if (!pkgJson.scripts) pkgJson.scripts = {};
 	for (const pkgName of unique(dependencies)) {
-		const version = getVersion(pkgName);
+		const version = getDependencyVersion(pkgName, prismaNextSpec);
 		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);
+		const version = getDependencyVersion(pkgName, prismaNextSpec);
 		if (version) pkgJson.devDependencies[pkgName] = version;
 		else console.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
 	}
@@ -550,22 +760,27 @@ async function addPackageDependency(opts) {
 	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));
-	if (requiresDotenvConfigImport(packageManager) || await projectContainsText(projectDir, "dotenv/config")) dependencies.push("dotenv");
-	if (provider === "sqlite" && packageManager === "deno") devDependencies.push("node-gyp");
+async function writePrismaDependencies(provider, packageManager, authoring, projectDir = process.cwd(), prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	const dependencies = [getDbPackages(provider, packageManager), "dotenv"];
+	const devDependencies = [
+		"prisma-next",
+		"@prisma-next/cli",
+		"@types/node"
+	];
+	devDependencies.push(...getGeneratedContractTypePackages(provider));
+	devDependencies.push(...getMigrationPackages(provider));
+	devDependencies.push(...getOrmTypePackages(provider));
+	if (authoring === "typescript") devDependencies.push(...getTypeScriptContractPackages(provider));
 	await addPackageDependency({
 		dependencies,
 		devDependencies,
-		scripts: getPrismaScriptMap(packageManager),
-		scriptMode: "if-missing",
-		projectDir
+		scripts: getPrismaNextScriptMap(packageManager),
+		projectDir,
+		prismaNextSpec
 	});
 }
 async function writeCreateTemplateDependencies(opts) {
-	const { template, packageManager, projectDir = process.cwd() } = opts;
+	const { template, packageManager, projectDir = process.cwd(), prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC } = opts;
 	const targets = getCreateTemplateDependencies(template, packageManager);
 	for (const dependencyTarget of targets) {
 		const targetDirectory = path.join(projectDir, path.dirname(dependencyTarget.packageJsonPath));
@@ -573,15 +788,18 @@ async function writeCreateTemplateDependencies(opts) {
 			dependencies: dependencyTarget.dependencies,
 			devDependencies: dependencyTarget.devDependencies,
 			customDependencies: dependencyTarget.customDependencies,
-			projectDir: targetDirectory
+			projectDir: targetDirectory,
+			prismaNextSpec
 		});
 	}
 }
 async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
 	const verbose = options.verbose === true;
 	const installCommand = getInstallArgs(packageManager);
+	const env = packageManager === "yarn" ? { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" } : void 0;
 	await execa(installCommand.command, installCommand.args, {
 		cwd: projectDir,
+		env,
 		stdio: verbose ? "inherit" : "pipe"
 	});
 }
@@ -643,55 +861,233 @@ function getCreateDbCommand(packageManager) {
 
 //#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_DATABASE_PROVIDER = "postgres";
+const DEFAULT_AUTHORING = "psl";
 const DEFAULT_INSTALL = true;
-const DEFAULT_GENERATE = true;
+const DEFAULT_EMIT = true;
+const DEFAULT_INTERACTIVE_PRISMA_POSTGRES = true;
+const DEFAULT_AUTOMATED_PRISMA_POSTGRES = false;
+const MONGO_MEMORY_SERVER_SCRIPT = `import { spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const defaultDatabaseUrl = "mongodb://localhost:27017/mydb?replicaSet=rs0&directConnection=true";
+const dataRoot = path.resolve(process.env.MONGO_DB_PATH ?? ".mongo-data");
+const dbPath = path.join(dataRoot, "db");
+const pidFile = path.join(dataRoot, "mongo.pid");
+const logFile = path.join(dataRoot, "mongo.log");
+const readyTimeoutMs = Number(process.env.MONGO_READY_TIMEOUT_MS ?? 60_000);
+
+function getMongoConfig() {
+  const databaseUrl = process.env.DATABASE_URL ?? defaultDatabaseUrl;
+  const url = new URL(databaseUrl);
+  if (url.protocol !== "mongodb:") {
+    throw new Error("DATABASE_URL must use the mongodb:// protocol.");
+  }
+
+  const port = Number(url.port || "27017");
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(\`DATABASE_URL has an invalid MongoDB port: \${url.port}\`);
+  }
+
+  return {
+    databaseUrl,
+    port,
+    replSetName: url.searchParams.get("replicaSet") || "rs0",
+  };
+}
+
+function readPid() {
+  if (!existsSync(pidFile)) return null;
+  const raw = readFileSync(pidFile, "utf8").trim();
+  const pid = Number(raw);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getChildCommand() {
+  const scriptPath = path.resolve(process.argv[1] ?? "");
+  const versions = process.versions;
+  if (versions.deno) return { command: process.execPath, args: ["run", "-A", scriptPath, "_run"] };
+  return { command: process.execPath, args: [scriptPath, "_run"] };
+}
+
+async function runServer() {
+  mkdirSync(dbPath, { recursive: true });
+  const config = getMongoConfig();
+  const memoryServer = await import("mongodb-memory-server");
+  const { MongoMemoryReplSet } = memoryServer.default ?? memoryServer;
+  const replSet = await MongoMemoryReplSet.create({
+    replSet: { name: config.replSetName, count: 1 },
+    instanceOpts: [{ port: config.port, storageEngine: "wiredTiger", dbPath }],
+  });
+  console.log(\`MongoDB server ready for \${config.databaseUrl}\`);
+  console.log(\`Data directory: \${dbPath}\`);
+  const shutdown = async () => {
+    await replSet.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+async function up() {
+  mkdirSync(dataRoot, { recursive: true });
+  const existing = readPid();
+  if (existing !== null && isAlive(existing)) {
+    console.log(\`MongoDB is already running (PID \${existing}). Use \\\`db:down\\\` to stop.\`);
+    return;
+  }
+  if (existing !== null) rmSync(pidFile, { force: true });
+
+  writeFileSync(logFile, "");
+  const logFd = openSync(logFile, "a");
+  const { command, args } = getChildCommand();
+  const child = spawn(
+    command,
+    args,
+    {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      env: process.env,
+    },
+  );
+  closeSync(logFd);
+  if (typeof child.pid !== "number") throw new Error("Failed to spawn MongoDB child process.");
+  writeFileSync(pidFile, String(child.pid));
+  child.unref();
+
+  const start = Date.now();
+  while (Date.now() - start < readyTimeoutMs) {
+    if (!isAlive(child.pid)) {
+      console.error("MongoDB failed to start:");
+      console.error(readFileSync(logFile, "utf8"));
+      rmSync(pidFile, { force: true });
+      process.exit(1);
+    }
+    const log = readFileSync(logFile, "utf8");
+    if (log.includes("MongoDB server ready")) {
+      for (const line of log.split("\\n")) {
+        if (line.trim().length > 0) console.log(line);
+      }
+      console.log(\`Detached (PID \${child.pid}). Logs: \${logFile}\`);
+      console.log("Stop with \`db:down\` or wipe with \`db:reset\`.");
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  console.error(\`Timed out waiting for MongoDB after \${readyTimeoutMs}ms.\`);
+  console.error(readFileSync(logFile, "utf8"));
+  try {
+    process.kill(child.pid, "SIGTERM");
+  } catch {
+    // ignore
+  }
+  rmSync(pidFile, { force: true });
+  process.exit(1);
+}
+
+async function down(wipe) {
+  const pid = readPid();
+  if (pid !== null && isAlive(pid)) {
+    process.kill(pid, "SIGTERM");
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline && isAlive(pid)) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    if (isAlive(pid)) {
+      console.warn(\`MongoDB (PID \${pid}) did not exit within 10s; sending SIGKILL.\`);
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+        // ignore
+      }
+    }
+    console.log(\`Stopped MongoDB (PID \${pid}).\`);
+  } else if (pid !== null) {
+    console.log("MongoDB was not running (stale PID file).");
+  } else {
+    console.log("MongoDB is not running.");
+  }
+  rmSync(pidFile, { force: true });
+  if (wipe) {
+    rmSync(dataRoot, { recursive: true, force: true });
+    console.log(\`Removed \${dataRoot}.\`);
+  }
+}
+
+const cmd = process.argv[2] ?? "up";
+switch (cmd) {
+  case "up":
+    await up();
+    break;
+  case "down":
+    await down(false);
+    break;
+  case "reset":
+    await down(true);
+    break;
+  case "_run":
+    await runServer();
+    break;
+  default:
+    console.error(\`Unknown command: \${cmd}. Use: up | down | reset\`);
+    process.exit(2);
+}
+`;
+function getMongoMemoryScripts(packageManager) {
+	switch (packageManager) {
+		case "bun": return {
+			"db:up": "bun --env-file=.env scripts/mongo.mjs up",
+			"db:down": "bun --env-file=.env scripts/mongo.mjs down",
+			"db:reset": "bun --env-file=.env scripts/mongo.mjs reset"
+		};
+		case "deno": return {
+			"db:up": "deno run -A --env-file=.env scripts/mongo.mjs up",
+			"db:down": "deno run -A --env-file=.env scripts/mongo.mjs down",
+			"db:reset": "deno run -A --env-file=.env scripts/mongo.mjs reset"
+		};
+		default: return {
+			"db:up": "node --env-file=.env scripts/mongo.mjs up",
+			"db:down": "node --env-file=.env scripts/mongo.mjs down",
+			"db:reset": "node --env-file=.env scripts/mongo.mjs reset"
+		};
+	}
+}
 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"],
+	["prisma/contract.prisma", "prisma/contract.ts"],
+	["prisma-next.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"
+		"server/utils/prisma.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;
+function getContractPath(authoring) {
+	return `prisma/contract${authoring === "typescript" ? ".ts" : ".prisma"}`;
 }
 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"
-			}
-		]
+		options: [{
+			value: "postgres",
+			label: "PostgreSQL",
+			hint: "Relational models with typed ORM, relations, indexes, raw SQL"
+		}, {
+			value: "mongo",
+			label: "MongoDB",
+			hint: "Document models with typed ORM, indexes, aggregations"
+		}]
 	});
 	if (isCancel(databaseProvider)) {
 		cancel("Operation cancelled.");
@@ -699,10 +1095,48 @@ async function promptForDatabaseProvider() {
 	}
 	return DatabaseProviderSchema.parse(databaseProvider);
 }
+async function promptForAuthoringStyle() {
+	const authoring = await select({
+		message: "Choose contract authoring style",
+		initialValue: DEFAULT_AUTHORING,
+		options: [{
+			value: "psl",
+			label: "PSL",
+			hint: "Schema syntax emits contract.json + types"
+		}, {
+			value: "typescript",
+			label: "TypeScript",
+			hint: "Builder API emits the same contract artifacts"
+		}]
+	});
+	if (isCancel(authoring)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return AuthoringStyleSchema.parse(authoring);
+}
+async function promptForPrismaPostgres() {
+	const shouldUsePrismaPostgres = await confirm({
+		message: "Provision a Prisma Postgres database?",
+		active: "Provision Prisma Postgres",
+		inactive: "Use my own database",
+		initialValue: DEFAULT_INTERACTIVE_PRISMA_POSTGRES
+	});
+	if (isCancel(shouldUsePrismaPostgres)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldUsePrismaPostgres);
+}
 function getPackageManagerHint(option, detected) {
-	if (option === detected) return "Detected";
-	if (option === "bun") return "Fast runtime + package manager";
-	if (option === "deno") return "Runtime + package manager";
+	const hint = {
+		npm: "Node.js default",
+		pnpm: "Fast, disk-efficient Node.js package manager",
+		yarn: "Yarn package manager",
+		bun: "Fast runtime + package manager",
+		deno: "Deno runtime + task runner"
+	}[option];
+	return option === detected ? `Detected; ${hint}` : hint;
 }
 async function promptForPackageManager(detectedPackageManager) {
 	const packageManager = await select({
@@ -744,7 +1178,9 @@ async function promptForPackageManager(detectedPackageManager) {
 }
 async function promptForDependencyInstall(packageManager) {
 	const shouldInstall = await confirm({
-		message: `Install dependencies now with ${getInstallCommand(packageManager)}?`,
+		message: `Install dependencies now with ${getInstallCommand(packageManager)}? You can run it later.`,
+		active: "Install now",
+		inactive: "Skip for now",
 		initialValue: true
 	});
 	if (isCancel(shouldInstall)) {
@@ -753,17 +1189,6 @@ async function promptForDependencyInstall(packageManager) {
 	}
 	return Boolean(shouldInstall);
 }
-async function promptForPrismaPostgres() {
-	const shouldUsePrismaPostgres = await confirm({
-		message: "Use Prisma Postgres and auto-generate DATABASE_URL with create-db?",
-		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();
@@ -775,17 +1200,29 @@ async function collectPrismaSetupContext(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 shouldEmit = input.emit ?? DEFAULT_EMIT;
+	let prismaNextSpec;
+	try {
+		prismaNextSpec = parsePrismaNextVersionSpec(input.prismaNextVersion);
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		return;
+	}
 	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;
-	let shouldUsePrismaPostgres = false;
-	if (databaseProvider === "postgresql" && !databaseUrl) {
-		const prismaPostgresChoice = input.prismaPostgres ?? (useDefaults ? DEFAULT_PRISMA_POSTGRES : await promptForPrismaPostgres());
-		if (prismaPostgresChoice === void 0) return;
-		shouldUsePrismaPostgres = prismaPostgresChoice;
+	const shouldUsePrismaPostgres = input.prismaPostgres ?? (databaseProvider === "postgres" && !databaseUrl && !useDefaults ? await promptForPrismaPostgres() : DEFAULT_AUTOMATED_PRISMA_POSTGRES);
+	if (shouldUsePrismaPostgres === void 0) return;
+	if (shouldUsePrismaPostgres && databaseProvider !== "postgres") {
+		cancel("--prisma-postgres is only supported with --provider postgres.");
+		return;
 	}
+	if (shouldUsePrismaPostgres && databaseUrl) {
+		cancel("Use either --database-url or --prisma-postgres, not both.");
+		return;
+	}
+	const authoring = input.authoring ?? (useDefaults ? DEFAULT_AUTHORING : await promptForAuthoringStyle());
+	if (!authoring) return;
 	const detectedPackageManager = await detectPackageManager(projectDir);
 	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager));
 	if (!packageManager) return;
@@ -794,25 +1231,23 @@ async function collectPrismaSetupContext(input, options = {}) {
 	return {
 		projectDir,
 		verbose,
-		shouldGenerate,
+		shouldEmit,
 		databaseProvider,
-		schemaPreset,
+		authoring,
 		databaseUrl,
 		shouldUsePrismaPostgres,
 		packageManager,
-		shouldInstall
+		shouldInstall,
+		prismaNextSpec
 	};
 }
 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;";
+		case "postgres": return "postgresql://user:password@localhost:5432/mydb";
+		case "mongo": return "mongodb://localhost:27017/mydb?replicaSet=rs0&directConnection=true";
 		default: {
 			const exhaustiveCheck = provider;
-			throw new Error(`Unsupported provider: ${String(exhaustiveCheck)}`);
+			throw new Error(`Unsupported Prisma Next target: ${String(exhaustiveCheck)}`);
 		}
 	}
 }
@@ -882,6 +1317,48 @@ async function ensureGitignoreEntry(projectDir, entry) {
 	const separator = existingContent.endsWith("\n") ? "" : "\n";
 	await fs.appendFile(gitignorePath, `${separator}${entry}\n`, "utf8");
 }
+async function ensurePackageScripts(projectDir, scripts) {
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	if (!packageJson.scripts) packageJson.scripts = {};
+	let didChange = false;
+	for (const [scriptName, command] of Object.entries(scripts)) if (typeof packageJson.scripts[scriptName] !== "string" || packageJson.scripts[scriptName].trim().length === 0) {
+		packageJson.scripts[scriptName] = command;
+		didChange = true;
+	}
+	if (didChange) await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+async function ensureMongoMemoryServerScript(projectDir) {
+	const scriptPath = path.join(projectDir, "scripts", "mongo.mjs");
+	if (await fs.pathExists(scriptPath)) return;
+	await fs.ensureDir(path.dirname(scriptPath));
+	await fs.writeFile(scriptPath, MONGO_MEMORY_SERVER_SCRIPT, "utf8");
+}
+async function ensureMongoMemoryServerDevDependency(projectDir) {
+	const packageJsonPath = path.join(projectDir, "package.json");
+	if (!await fs.pathExists(packageJsonPath)) return;
+	const packageJson = await fs.readJson(packageJsonPath);
+	if (!packageJson.devDependencies) packageJson.devDependencies = {};
+	const memoryServerVersion = getDependencyVersion("mongodb-memory-server");
+	if (packageJson.devDependencies["mongodb-memory-server"] === memoryServerVersion) return;
+	packageJson.devDependencies["mongodb-memory-server"] = memoryServerVersion;
+	packageJson.devDependencies = Object.fromEntries(Object.entries(packageJson.devDependencies).sort(([a], [b]) => a.localeCompare(b)));
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+async function writeMongoLocalHelpersForContext(context, projectDir) {
+	if (context.databaseProvider !== "mongo" || context.databaseUrl) return true;
+	try {
+		await ensureMongoMemoryServerScript(projectDir);
+		await ensureMongoMemoryServerDevDependency(projectDir);
+		await ensurePackageScripts(projectDir, getMongoMemoryScripts(context.packageManager));
+		await ensureGitignoreEntry(projectDir, ".mongo-data");
+		return true;
+	} catch (error) {
+		cancel(getCommandErrorMessage(error));
+		return false;
+	}
+}
 async function ensureRequiredPrismaFiles(projectDir) {
 	const missingFiles = [];
 	for (const candidates of requiredPrismaFileGroups) {
@@ -895,41 +1372,37 @@ async function ensureRequiredPrismaFiles(projectDir) {
 		}
 		if (!foundCandidate) missingFiles.push(candidates.join(" or "));
 	}
-	if (missingFiles.length > 0) throw new Error(`Template is missing required Prisma files: ${missingFiles.join(", ")}`);
+	if (missingFiles.length > 0) throw new Error(`Template is missing required Prisma Next 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), {
+	await ensureEnvVarInEnv(projectDir, "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, {
+		await ensureEnvVarInEnv(projectDir, "CLAIM_URL", options.claimUrl, {
 			mode: "upsert",
 			comment: PRISMA_POSTGRES_TEMPORARY_NOTICE
 		});
-		await ensureEnvComment(prismaProjectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
+		await ensureEnvComment(projectDir, PRISMA_POSTGRES_TEMPORARY_NOTICE);
 	}
-	await ensureGitignoreEntry(prismaProjectDir, generatedDir);
+	await ensureGitignoreEntry(projectDir, ".env");
 }
 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}...`);
+	if (context.verbose) log.step(`Running ${createDbCommand}`);
 	try {
 		const prismaPostgresResult = await provisionPrismaPostgres(context.packageManager, projectDir);
-		prismaPostgresSpinner.stop("Prisma Postgres database provisioned.");
+		if (context.verbose) log.success("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}`
@@ -937,44 +1410,86 @@ async function provisionPrismaPostgresIfNeeded(context, projectDir) {
 	}
 }
 async function writeDependenciesForContext(context, projectDir) {
-	const prismaProjectDir = await resolvePrismaProjectDir(projectDir);
 	try {
-		await writePrismaDependencies(context.databaseProvider, context.packageManager, prismaProjectDir);
+		await writePrismaDependencies(context.databaseProvider, context.packageManager, context.authoring, projectDir, context.prismaNextSpec);
 		return true;
 	} catch (error) {
 		cancel(getCommandErrorMessage(error));
 		return false;
 	}
 }
+function getPrismaNextCliPackageSpecifier(prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	return getPrismaNextPackageSpecifier("prisma-next", prismaNextSpec);
+}
+function getPrismaNextInitTarget(provider) {
+	return provider === "mongo" ? "mongodb" : "postgres";
+}
+function getPrismaNextInitCliArgs(packageManager, prismaNextArgs, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	if (packageManager === "npm") return {
+		command: "npx",
+		args: [
+			"--yes",
+			getPrismaNextCliPackageSpecifier(prismaNextSpec),
+			"init",
+			...prismaNextArgs
+		]
+	};
+	return getPackageExecutionArgs(packageManager, [
+		getPrismaNextCliPackageSpecifier(prismaNextSpec),
+		"init",
+		...prismaNextArgs
+	]);
+}
+function getPrismaNextInitCliCommand(packageManager, prismaNextArgs, prismaNextSpec = DEFAULT_PRISMA_NEXT_SPEC) {
+	const execution = getPrismaNextInitCliArgs(packageManager, prismaNextArgs, prismaNextSpec);
+	return [execution.command, ...execution.args].join(" ");
+}
+async function runPrismaNextInitForContext(context, projectDir) {
+	const initArgs = [
+		"--yes",
+		"--force",
+		"--target",
+		getPrismaNextInitTarget(context.databaseProvider),
+		"--authoring",
+		context.authoring,
+		"--schema-path",
+		getContractPath(context.authoring),
+		"--no-install"
+	];
+	const initCommand = getPrismaNextInitCliCommand(context.packageManager, initArgs, context.prismaNextSpec);
+	if (context.verbose) log.step(`Running ${initCommand}`);
+	try {
+		const initExecution = getPrismaNextInitCliArgs(context.packageManager, initArgs, context.prismaNextSpec);
+		await execa(initExecution.command, initExecution.args, {
+			cwd: projectDir,
+			stdio: context.verbose ? "inherit" : "pipe",
+			env: {
+				...process.env,
+				CI: "1"
+			}
+		});
+		if (context.verbose) log.success("Prisma Next project files ready.");
+		return true;
+	} catch (error) {
+		if (context.verbose) log.warn("Could not run Prisma Next init.");
+		cancel(`Failed to run ${initCommand}: ${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}...`);
+	if (context.verbose) log.step(`Running ${installCommand}`);
 	try {
 		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
-		installSpinner.stop("Dependencies installed.");
+		if (context.verbose) log.success("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,
@@ -982,746 +1497,165 @@ async function finalizePrismaFilesForContext(context, projectDir, provisionResul
 			claimUrl: provisionResult.claimUrl,
 			projectDir
 		});
-		initSpinner.stop("Prisma files ready.");
+		if (context.verbose) log.success("Prisma Next environment configured.");
 		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(context.packageManager, ["generate"]);
-	if (context.verbose) log.step(`Running ${generateCommand}`);
-	const generateSpinner = context.verbose ? void 0 : spinner();
-	generateSpinner?.start("Generating Prisma Client...");
+function getPrismaNextCliCommand(packageManager, prismaNextArgs) {
+	if (packageManager === "deno") return `deno run -A --env-file=.env ${getDenoPrismaSpecifier()} ${prismaNextArgs.join(" ")}`;
+	return getLocalPackageBinaryCommand(packageManager, "prisma-next", prismaNextArgs);
+}
+function getPrismaNextCliArgs(packageManager, prismaNextArgs) {
+	if (packageManager === "deno") return {
+		command: "deno",
+		args: [
+			"run",
+			"-A",
+			"--env-file=.env",
+			getDenoPrismaSpecifier(),
+			...prismaNextArgs
+		]
+	};
+	return getLocalPackageBinaryArgs(packageManager, "prisma-next", prismaNextArgs);
+}
+async function emitPrismaNextContractForContext(context, projectDir) {
+	if (!context.shouldEmit) return { didEmitContract: false };
+	if (!context.shouldInstall) return {
+		didEmitContract: false,
+		warning: "Skipped contract emit because dependencies were not installed."
+	};
+	const emitCommand = getPrismaNextCliCommand(context.packageManager, ["contract", "emit"]);
+	if (context.verbose) log.step(`Running ${emitCommand}`);
 	try {
-		const generateArgs = getPrismaCliArgs(context.packageManager, ["generate"]);
-		await execa(generateArgs.command, generateArgs.args, {
-			cwd: prismaProjectDir,
+		const emitArgs = getPrismaNextCliArgs(context.packageManager, ["contract", "emit"]);
+		await execa(emitArgs.command, emitArgs.args, {
+			cwd: projectDir,
 			stdio: context.verbose ? "inherit" : "pipe"
 		});
-		if (context.verbose) log.success("Prisma Client generated.");
-		else generateSpinner?.stop("Prisma Client generated.");
-		return { didGenerateClient: true };
+		if (context.verbose) log.success("Prisma Next contract artifacts emitted.");
+		return { didEmitContract: true };
 	} catch (error) {
-		if (context.verbose) log.warn("Could not generate Prisma Client.");
-		else generateSpinner?.stop("Could not generate Prisma Client.");
+		if (context.verbose) log.warn("Could not emit Prisma Next contract.");
 		return {
-			didGenerateClient: false,
-			warning: `Prisma generate failed: ${getCommandErrorMessage(error)}`
+			didEmitContract: false,
+			warning: `Contract emit failed: ${getCommandErrorMessage(error)}`
 		};
 	}
 }
-function buildWarningLines(provisionWarning, generateWarning) {
+function buildWarningLines(provisionWarning, emitWarning) {
 	const warningLines = [];
 	if (provisionWarning) warningLines.push(`- ${provisionWarning}`);
-	if (generateWarning) warningLines.push(`- ${generateWarning}`);
+	if (emitWarning) warningLines.push(`- ${emitWarning}`);
 	return warningLines;
 }
 function buildNextStepsForContext(opts) {
-	const { context, options, didGenerateClient } = opts;
+	const { context, options, didEmitContract } = opts;
 	const nextSteps = [...options.prependNextSteps ?? []];
-	if (!context.shouldInstall) nextSteps.push(`- ${getInstallCommand(context.packageManager)}`);
-	if (!didGenerateClient || !context.shouldGenerate) nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:generate")}`);
-	nextSteps.push(`- ${getRunScriptCommand(context.packageManager, "db:migrate")}`);
-	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 false;
-	if (!await writeDependenciesForContext(context, projectDir)) return false;
-	if (!await installDependenciesForContext(context, projectDir)) return false;
-	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) return false;
-	const generateResult = await generatePrismaClientForContext(context, projectDir);
-	const warningLines = buildWarningLines(provisionResult.warning, generateResult.warning);
-	const nextSteps = buildNextStepsForContext({
-		context,
-		options,
-		didGenerateClient: generateResult.didGenerateClient
+	if (!context.shouldInstall) nextSteps.push({
+		command: getInstallCommand(context.packageManager),
+		description: "Install the project dependencies."
 	});
-	outro(`Setup complete.${warningLines.length > 0 ? `\n\n${warningLines.join("\n")}` : ""}
-
-Next steps:
-${nextSteps.join("\n")}`);
-	return true;
-}
-
-//#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) {
-	if (provider === "postgresql") return [...SHARED_PRISMA_SKILLS, "prisma-postgres"];
-	return [...SHARED_PRISMA_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-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) {
-	const skills = [...getAvailablePrismaSkills(provider)];
-	if (!shouldUsePrismaPostgres) return skills.filter((skill) => skill !== "prisma-postgres");
-	return uniqueValues(skills);
-}
-async function promptForAddons() {
-	const selectedAddons = await multiselect({
-		message: "Select add-ons (optional)",
-		options: ADDON_OPTIONS,
-		required: false
+	if (!didEmitContract || !context.shouldEmit) nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "contract:emit"),
+		description: "Emit contract.json and TypeScript types from your Prisma Next contract."
 	});
-	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 (context.databaseProvider === "postgres") nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "db:init"),
+		description: "Create the initial PostgreSQL database objects and sign the database."
 	});
-	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 (context.databaseProvider === "mongo" && !context.databaseUrl) nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "db:up"),
+		description: "Start the local MongoDB replica set with mongodb-memory-server. Stop with `db:down`, wipe with `db:reset`."
 	});
-	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]
+	nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "migration:plan"),
+		description: "Compare the contract to the database and write a migration plan."
 	});
-	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]
+	nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "migrate"),
+		description: "Apply the planned migration to the database."
 	});
-	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
+	nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "db:seed"),
+		description: "Insert the sample users from prisma/seed.ts."
 	});
-	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);
-	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"
-		}
+	if (options.includeDevNextStep) nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "dev"),
+		description: "Start the development server."
 	});
+	return nextSteps;
 }
-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 formatNextSteps(nextSteps) {
+	return nextSteps.map((step) => `${step.command}\n  ${step.description}`).join("\n\n");
 }
-function getExtensionInstallBinary(target) {
-	switch (target) {
-		case "vscode": return "code";
-		case "cursor": return "cursor";
-		case "windsurf": return "windsurf";
-		default: {
-			const exhaustiveCheck = target;
-			throw new Error(`Unsupported extension target: ${String(exhaustiveCheck)}`);
-		}
-	}
+function formatAgentPrompt() {
+	return [
+		"Ask your agent:",
+		"What can I do with Prisma Next?",
+		"",
+		"Learn more:",
+		`Docs: prisma-next.md`,
+		"Skills: https://github.com/prisma/prisma-next/tree/main/skills"
+	].join("\n");
 }
-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)}`);
-		}
+async function executePrismaSetupContext(context, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
+	const progressSpinner = context.verbose ? void 0 : options.progressSpinner ?? spinner();
+	if (progressSpinner !== void 0 && !options.progressSpinner) progressSpinner.start("Creating Prisma Next project...");
+	const stopProgressOnFailure = () => {
+		progressSpinner?.stop("Could not create Prisma Next project.");
+	};
+	if (context.shouldUsePrismaPostgres) progressSpinner?.message("Provisioning Prisma Postgres...");
+	const provisionResult = await provisionPrismaPostgresIfNeeded(context, projectDir);
+	if (!provisionResult) {
+		stopProgressOnFailure();
+		return false;
 	}
-	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);
+	progressSpinner?.message("Preparing Prisma Next project files...");
+	if (!await runPrismaNextInitForContext(context, projectDir)) {
+		stopProgressOnFailure();
+		return false;
 	}
-	if (context.addons.includes("mcp")) {
-		const warning = await installMcpAddon({
-			packageManager,
-			projectDir,
-			scope: context.scope,
-			agents: context.mcpAgents,
-			verbose
-		});
-		if (warning) warnings.push(warning);
+	if (!await writeDependenciesForContext(context, projectDir)) {
+		stopProgressOnFailure();
+		return false;
 	}
-	if (context.addons.includes("extension")) {
-		const extensionWarnings = await installExtensionAddon({
-			projectDir,
-			verbose,
-			targets: context.extensionTargets
-		});
-		warnings.push(...extensionWarnings);
+	if (!await writeMongoLocalHelpersForContext(context, projectDir)) {
+		stopProgressOnFailure();
+		return false;
 	}
-	if (warnings.length > 0) {
-		addonSpinner.stop("Add-ons applied with warnings.");
-		for (const warning of warnings) log.warn(warning);
-		return;
+	if (context.shouldInstall) progressSpinner?.message("Installing dependencies...");
+	if (!await installDependenciesForContext(context, projectDir)) {
+		stopProgressOnFailure();
+		return false;
 	}
-	addonSpinner.stop("Add-ons applied.");
-}
-
-//#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.homedir(), "Library", "Application Support", "create-prisma");
-	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), "create-prisma");
-	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.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.4.1",
-		"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(() => {});
+	progressSpinner?.message("Configuring Prisma Next...");
+	if (!await finalizePrismaFilesForContext(context, projectDir, provisionResult)) {
+		stopProgressOnFailure();
+		return false;
 	}
-}
-
-//#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)
+	if (context.shouldEmit && context.shouldInstall) progressSpinner?.message("Emitting Prisma Next contract artifacts...");
+	const emitResult = await emitPrismaNextContractForContext(context, projectDir);
+	const warningLines = buildWarningLines(provisionResult.warning, emitResult.warning);
+	const nextSteps = buildNextStepsForContext({
+		context,
+		options,
+		didEmitContract: emitResult.didEmitContract
 	});
+	progressSpinner?.stop("Prisma Next project ready.");
+	if (warningLines.length > 0) note(warningLines.map((line) => line.replace(/^- /, "")).join("\n"), "Heads up");
+	note(formatAgentPrompt(), "Agent prompt");
+	if (context.verbose) note(formatNextSteps(nextSteps), "Next steps for Prisma Next");
+	outro("Prisma Next setup complete.");
+	return true;
 }
 
 //#endregion
 //#region src/ui/branding.ts
-const prismaTitle = `${styleText(["bold", "cyan"], "Create")} ${styleText(["bold", "magenta"], "Prisma")}`;
+const prismaTitle = `${styleText(["bold", "cyanBright"], "◭")} ${styleText(["bold", "cyanBright"], "Create")} ${styleText(["bold", "magentaBright"], "Prisma")} ${styleText(["bold", "blueBright"], "Next")}`;
 function getCreatePrismaIntro() {
 	return prismaTitle;
 }
@@ -1729,8 +1663,7 @@ function getCreatePrismaIntro() {
 //#endregion
 //#region src/commands/create.ts
 const DEFAULT_PROJECT_NAME = "my-app";
-const DEFAULT_TEMPLATE = "hono";
-const DEFAULT_SCHEMA_PRESET = "basic";
+const DEFAULT_TEMPLATE = "minimal";
 function toPackageName(projectName) {
 	return projectName.toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "app";
 }
@@ -1761,50 +1694,50 @@ async function promptForCreateTemplate() {
 		message: "Select template",
 		initialValue: DEFAULT_TEMPLATE,
 		options: [
+			{
+				value: "minimal",
+				label: "Minimal",
+				hint: "Script-first Prisma Next starter with no web framework"
+			},
 			{
 				value: "hono",
 				label: "Hono",
-				hint: "TypeScript API starter"
+				hint: "Lightweight TypeScript API server"
 			},
 			{
 				value: "elysia",
 				label: "Elysia",
-				hint: "TypeScript API starter with Elysia's Node adapter"
+				hint: "Bun-friendly TypeScript API server"
 			},
 			{
 				value: "nest",
 				label: "NestJS",
-				hint: "Official Nest-style API starter with a Prisma service"
+				hint: "Structured Node API with controllers and services"
 			},
 			{
 				value: "next",
 				label: "Next.js",
-				hint: "App Router + TypeScript starter"
+				hint: "Full-stack React app with App Router"
 			},
 			{
 				value: "svelte",
 				label: "SvelteKit",
-				hint: "Official minimal SvelteKit + TypeScript starter"
+				hint: "Full-stack Svelte 5 app with Vite"
 			},
 			{
 				value: "astro",
 				label: "Astro",
-				hint: "Official minimal Astro starter with API route example"
+				hint: "Content-oriented web app with server routes"
 			},
 			{
 				value: "nuxt",
 				label: "Nuxt",
-				hint: "Official minimal Nuxt starter with Nitro API route example"
+				hint: "Full-stack Vue app with Nitro server routes"
 			},
 			{
 				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"
+				hint: "React app with file routes and server functions"
 			}
 		]
 	});
@@ -1872,8 +1805,8 @@ async function runCreateCommand(rawInput = {}) {
 	}
 }
 async function collectCreateContext(input) {
-	const useDefaults = input.yes === true;
 	const force = input.force === true;
+	const useDefaults = input.yes === true;
 	const projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
 	if (projectNameInput === void 0) return;
 	const projectName = String(projectNameInput).trim();
@@ -1894,42 +1827,33 @@ async function collectCreateContext(input) {
 		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
 		return;
 	}
-	const prismaSetupContext = await collectPrismaSetupContext(input, {
-		projectDir: targetDirectory,
-		defaultSchemaPreset: DEFAULT_SCHEMA_PRESET
-	});
+	const prismaSetupContext = await collectPrismaSetupContext(input, { projectDir: targetDirectory });
 	if (!prismaSetupContext) return;
-	const addonSetupContext = await collectCreateAddonSetupContext(input, {
-		useDefaults,
-		provider: prismaSetupContext.databaseProvider,
-		shouldUsePrismaPostgres: prismaSetupContext.shouldUsePrismaPostgres
-	});
-	if (addonSetupContext === void 0) return;
 	return {
 		targetDirectory,
 		targetPathState,
 		force,
 		template,
 		projectPackageName: toPackageName(path.basename(targetDirectory)),
-		prismaSetupContext,
-		addonSetupContext: addonSetupContext ?? void 0
+		prismaSetupContext
 	};
 }
 async function executeCreateContext(context) {
-	const scaffoldSpinner = spinner();
-	scaffoldSpinner.start(`Scaffolding ${context.template} project...`);
+	const createSpinner = context.prismaSetupContext.verbose ? void 0 : spinner();
+	createSpinner?.start("Creating Prisma Next project...");
 	try {
+		if (context.prismaSetupContext.verbose) log.step(`Scaffolding ${context.template} starter.`);
 		await scaffoldCreateTemplate({
 			projectDir: context.targetDirectory,
 			projectName: context.projectPackageName,
 			template: context.template,
-			schemaPreset: context.prismaSetupContext.schemaPreset,
 			provider: context.prismaSetupContext.databaseProvider,
+			authoring: context.prismaSetupContext.authoring,
 			packageManager: context.prismaSetupContext.packageManager
 		});
-		scaffoldSpinner.stop("Project files scaffolded.");
+		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.");
 	} catch (error) {
-		scaffoldSpinner.stop("Could not scaffold project files.");
+		createSpinner?.stop("Could not create Prisma Next project.");
 		return {
 			ok: false,
 			stage: "scaffold_template",
@@ -1940,9 +1864,11 @@ async function executeCreateContext(context) {
 		await writeCreateTemplateDependencies({
 			template: context.template,
 			packageManager: context.prismaSetupContext.packageManager,
-			projectDir: context.targetDirectory
+			projectDir: context.targetDirectory,
+			prismaNextSpec: context.prismaSetupContext.prismaNextSpec
 		});
 	} catch (error) {
+		createSpinner?.stop("Could not create Prisma Next project.");
 		return {
 			ok: false,
 			stage: "scaffold_template",
@@ -1950,31 +1876,22 @@ async function executeCreateContext(context) {
 		};
 	}
 	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
-		};
-	}
+	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [{
+		command: `cd ${formatPathForDisplay(context.targetDirectory)}`,
+		description: "Enter your new project directory."
+	}];
 	try {
 		if (!await executePrismaSetupContext(context.prismaSetupContext, {
 			prependNextSteps: nextSteps,
 			projectDir: context.targetDirectory,
-			includeDevNextStep: true
+			includeDevNextStep: true,
+			progressSpinner: createSpinner
 		})) return {
 			ok: false,
 			stage: "prisma_setup"
 		};
 	} catch (error) {
+		createSpinner?.stop("Could not create Prisma Next project.");
 		return {
 			ok: false,
 			stage: "prisma_setup",
@@ -1985,4 +1902,4 @@ async function executeCreateContext(context) {
 }
 
 //#endregion
-export { DatabaseUrlSchema as a, DatabaseProviderSchema as i, CreateCommandInputSchema as n, PackageManagerSchema as o, CreateTemplateSchema as r, SchemaPresetSchema as s, runCreateCommand as t };
+export { DatabaseProviderSchema as a, CreateTemplateSchema as i, AuthoringStyleSchema as n, DatabaseUrlSchema as o, CreateCommandInputSchema as r, PackageManagerSchema as s, runCreateCommand as t };