create-prisma 0.7.2 → 0.8.0-pr.57.218.1

package/dist/create-BHt4J1kk.mjs

@@ -0,0 +1,1489 @@
+#!/usr/bin/env node
+import { z } from "zod";
+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 { execa } from "execa";
+import { styleText } from "node:util";
+
+//#region src/telemetry/client.ts
+const TELEMETRY_API_KEY = "";
+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 shouldDisableTelemetry() {
+	return true;
+}
+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.8.0-pr.57.218.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
+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) {
+	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-deploy": context?.prismaSetupContext.shouldDeploy ?? input.deploy ?? 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(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 databaseProviderInputs = [
+	"postgres",
+	"postgresql",
+	"mongo",
+	"mongodb"
+];
+const packageManagers = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun",
+	"deno"
+];
+const authoringStyles = ["psl", "typescript"];
+const createTemplates = [
+	"minimal",
+	"hono",
+	"elysia",
+	"nest",
+	"next",
+	"svelte",
+	"astro",
+	"nuxt",
+	"tanstack-start"
+];
+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 AuthoringStyleSchema = z.enum(authoringStyles);
+const CreateTemplateSchema = z.enum(createTemplates);
+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("Prisma 8 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"),
+	deploy: z.boolean().optional().describe("Deploy the generated app to Prisma immediately"),
+	workspace: z.string().trim().min(1, "Please enter a valid workspace id or name").optional().describe("Prisma workspace id or name to deploy into")
+});
+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"),
+	force: z.boolean().optional().describe("Allow scaffolding into a non-empty target directory")
+});
+const CreateCommandInputSchema = PrismaSetupCommandInputSchema.extend(CreateScaffoldOptionsSchema.shape);
+
+//#endregion
+//#region src/utils/package-manager.ts
+const packageManagerManifestValues = {
+	npm: "npm@10.9.0",
+	pnpm: "pnpm@11.21.0",
+	yarn: "yarn@4.13.0",
+	bun: "bun@1.3.9"
+};
+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) return;
+	if (packageManager === "deno") return;
+	return packageManagerManifestValues[packageManager];
+}
+function getInstallCommand(packageManager) {
+	if (packageManager === "deno") return "deno install --allow-scripts";
+	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 getRuntimeScriptCommand(packageManager, kind, options) {
+	const { sourceEntrypoint, builtEntrypoint } = options;
+	if (packageManager === "deno") switch (kind) {
+		case "dev": return `deno run -A --env-file=.env --watch ${sourceEntrypoint}`;
+		case "build": return `deno check ${sourceEntrypoint}`;
+		case "start": return `deno run -A --env-file=.env ${sourceEntrypoint}`;
+	}
+	if (packageManager === "bun") switch (kind) {
+		case "dev": return `bun --watch ${sourceEntrypoint}`;
+		case "build": return "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"]
+	};
+	return {
+		command: packageManager,
+		args: ["install"]
+	};
+}
+function getPackageExecutionArgs(packageManager, commandArgs) {
+	switch (packageManager) {
+		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
+				]
+			};
+		}
+		case "pnpm": return {
+			command: "pnpm",
+			args: ["dlx", ...commandArgs]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: ["dlx", ...commandArgs]
+		};
+		case "bun": return {
+			command: "bunx",
+			args: [...commandArgs]
+		};
+		default: return {
+			command: "npx",
+			args: ["--yes", ...commandArgs]
+		};
+	}
+}
+function getPackageExecutionCommand(packageManager, commandArgs) {
+	const execution = getPackageExecutionArgs(packageManager, commandArgs);
+	return [execution.command, ...execution.args].join(" ");
+}
+function getRunScriptArgs(packageManager, scriptName) {
+	switch (packageManager) {
+		case "deno": return {
+			command: "deno",
+			args: ["task", scriptName]
+		};
+		case "bun": return {
+			command: "bun",
+			args: ["run", scriptName]
+		};
+		case "pnpm": return {
+			command: "pnpm",
+			args: ["run", scriptName]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: ["run", scriptName]
+		};
+		default: return {
+			command: "npm",
+			args: ["run", scriptName]
+		};
+	}
+}
+
+//#endregion
+//#region src/templates/shared.ts
+Handlebars.registerHelper("eq", (left, right) => left === right);
+Handlebars.registerHelper("runScriptCommand", (packageManager, scriptName) => packageManager ? getRunScriptCommand(packageManager, scriptName) : "");
+Handlebars.registerHelper("packageManagerManifestValue", (packageManager) => getPackageManagerManifestValue(packageManager) ?? "");
+Handlebars.registerHelper("runtimeScript", (packageManager, kind, sourceEntrypoint, builtEntrypoint, _options) => {
+	if (!packageManager) return "";
+	return getRuntimeScriptCommand(packageManager, kind, {
+		sourceEntrypoint,
+		builtEntrypoint
+	});
+});
+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 getCreateSharedTemplateDir() {
+	return resolveTemplatesDir("templates/create/_shared");
+}
+function createTemplateContext(projectName, template, provider, authoring, packageManager) {
+	return {
+		projectName,
+		template,
+		provider,
+		authoring,
+		packageManager
+	};
+}
+async function scaffoldCreateSharedTemplates(opts) {
+	const { projectDir, projectName, template, provider, authoring, packageManager } = opts;
+	await renderTemplateTree({
+		templateRoot: getCreateSharedTemplateDir(),
+		outputDir: projectDir,
+		context: createTemplateContext(projectName, template, provider, authoring, packageManager)
+	});
+}
+async function scaffoldCreateFrameworkTemplate(opts) {
+	const { projectDir, projectName, template, provider, authoring, packageManager } = opts;
+	await renderTemplateTree({
+		templateRoot: getCreateTemplateDir(template),
+		outputDir: projectDir,
+		context: createTemplateContext(projectName, template, provider, authoring, packageManager)
+	});
+}
+
+//#endregion
+//#region src/constants/dependencies.ts
+const dependencyVersionMap = {
+	"@astrojs/node": "^10.0.2",
+	"@elysiajs/node": "^1.4.5",
+	"@prisma/cli-engine": "0.2.0",
+	"@prisma/composer": "0.10.0",
+	"@prisma/composer-prisma-cloud": "0.10.0",
+	"@prisma/orm-mongo": "8.0.0-rc.4",
+	"@prisma/orm-postgres": "8.0.0-rc.4",
+	"@sveltejs/adapter-node": "^5.3.2",
+	"@types/node": "^25.6.2",
+	alchemy: "2.0.0-beta.67",
+	arktype: "^2.2.3",
+	dotenv: "^17.4.2",
+	esbuild: "^0.28.1",
+	effect: "4.0.0-beta.103",
+	mongodb: "^7.1.0",
+	"mongodb-memory-server": "^11.1.0",
+	nitro: "^3.0.260610-beta",
+	tsx: "^4.21.0",
+	typescript: "^5.9.3"
+};
+const PRISMA_PLATFORM_CLI_PACKAGE = "prisma@next";
+const PRISMA_DENO_CLI_PACKAGE = "prisma-next";
+function getDependencyVersion(packageName) {
+	return dependencyVersionMap[packageName];
+}
+function usesEsbuild(template) {
+	return template === "minimal" || template === "hono" || template === "elysia" || template === "nest";
+}
+function getCreateTemplateDependencies(template, _packageManager) {
+	const dependencies = [
+		"@prisma/composer",
+		"@prisma/composer-prisma-cloud",
+		"alchemy"
+	];
+	const devDependencies = ["@prisma/cli-engine"];
+	if (usesEsbuild(template)) devDependencies.push("esbuild");
+	if (template === "minimal" || usesEsbuild(template)) devDependencies.push("tsx");
+	if (template === "minimal") devDependencies.push("typescript");
+	if (template === "elysia") {
+		dependencies.push("@elysiajs/node");
+		devDependencies.push("@types/node");
+	}
+	if (template === "svelte") devDependencies.push("@sveltejs/adapter-node");
+	if (template === "astro") dependencies.push("@astrojs/node");
+	if (template === "tanstack-start") devDependencies.push("nitro");
+	return [{
+		packageJsonPath: "package.json",
+		dependencies,
+		devDependencies
+	}];
+}
+
+//#endregion
+//#region src/constants/db-packages.ts
+function getDbPackages(provider) {
+	switch (provider) {
+		case "postgres": return "@prisma/orm-postgres";
+		case "mongo": return "@prisma/orm-mongo";
+	}
+}
+
+//#endregion
+//#region src/tasks/install.ts
+function getPrismaScriptMap(packageManager) {
+	if (packageManager === "deno") {
+		const prismaCommand = (needsDatabase, ...args) => [
+			"deno run -A",
+			...needsDatabase ? ["--env-file=.env"] : [],
+			`npm:${PRISMA_DENO_CLI_PACKAGE}`,
+			...args
+		].join(" ");
+		return {
+			"contract:emit": prismaCommand(false, "contract", "emit"),
+			"db:init": prismaCommand(true, "db", "init"),
+			"db:update": prismaCommand(true, "db", "update"),
+			"db:verify": prismaCommand(true, "db", "verify"),
+			"migration:plan": prismaCommand(true, "migration", "plan"),
+			migrate: prismaCommand(true, "migrate"),
+			"migration:status": prismaCommand(true, "migration", "status"),
+			"migration:show": prismaCommand(true, "migration", "show")
+		};
+	}
+	const prismaCommand = (...args) => getPackageExecutionCommand(packageManager, [PRISMA_PLATFORM_CLI_PACKAGE, ...args]);
+	return {
+		"contract:emit": prismaCommand("contract", "emit"),
+		"db:init": prismaCommand("db", "init"),
+		"db:update": prismaCommand("db", "update"),
+		"db:verify": prismaCommand("db", "verify"),
+		"migration:plan": prismaCommand("migration", "plan"),
+		migrate: prismaCommand("migrate"),
+		"migration:status": prismaCommand("migration", "status"),
+		"migration:show": prismaCommand("migration", "show")
+	};
+}
+function getComposerScriptMap(packageManager) {
+	if (packageManager === "deno") return {};
+	const composerCommand = (subcommand, extraArgs = []) => getPackageExecutionCommand(packageManager, [
+		PRISMA_PLATFORM_CLI_PACKAGE,
+		"composer",
+		subcommand,
+		"module.ts",
+		...extraArgs
+	]);
+	return {
+		"composer:dev": composerCommand("dev"),
+		"composer:deploy": composerCommand("deploy"),
+		"composer:destroy": composerCommand("destroy", ["--production"]),
+		deploy: `${getRunScriptCommand(packageManager, "build")} && ${getRunScriptCommand(packageManager, "composer:deploy")}`,
+		"dev:composer": `${getRunScriptCommand(packageManager, "build")} && ${getRunScriptCommand(packageManager, "composer:dev")}`
+	};
+}
+function unique(items) {
+	return [...new Set(items)];
+}
+function sortRecord(record) {
+	return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
+}
+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);
+	pkgJson.dependencies ??= {};
+	pkgJson.devDependencies ??= {};
+	pkgJson.scripts ??= {};
+	for (const packageName of unique(dependencies)) {
+		const version = getDependencyVersion(packageName);
+		if (!version) throw new Error(`Dependency ${packageName} is missing from the version map.`);
+		pkgJson.dependencies[packageName] = version;
+	}
+	for (const packageName of unique(devDependencies)) {
+		const version = getDependencyVersion(packageName);
+		if (!version) throw new Error(`Dependency ${packageName} is missing from the version map.`);
+		pkgJson.devDependencies[packageName] = version;
+	}
+	for (const [packageName, version] of Object.entries(customDependencies)) pkgJson.dependencies[packageName] = version;
+	for (const [scriptName, command] of Object.entries(scripts)) {
+		if (scriptMode === "if-missing" && typeof pkgJson.scripts[scriptName] === "string" && pkgJson.scripts[scriptName].trim().length > 0) continue;
+		pkgJson.scripts[scriptName] = command;
+	}
+	pkgJson.dependencies = sortRecord(pkgJson.dependencies);
+	pkgJson.devDependencies = sortRecord(pkgJson.devDependencies);
+	pkgJson.scripts = sortRecord(pkgJson.scripts);
+	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+}
+async function writePrismaDependencies(provider, packageManager, _authoring, projectDir = process.cwd()) {
+	const dependencies = [getDbPackages(provider)];
+	if (provider === "mongo") dependencies.push("arktype", "mongodb");
+	if (packageManager === "deno") dependencies.push("dotenv");
+	await addPackageDependency({
+		dependencies,
+		devDependencies: packageManager === "deno" ? ["@types/node"] : ["@prisma/cli-engine", "@types/node"],
+		scripts: getPrismaScriptMap(packageManager),
+		projectDir
+	});
+}
+async function writeCreateTemplateDependencies(opts) {
+	const { template, packageManager, projectDir = process.cwd() } = opts;
+	if (packageManager === "deno") return;
+	for (const target of getCreateTemplateDependencies(template, packageManager)) await addPackageDependency({
+		dependencies: target.dependencies,
+		devDependencies: target.devDependencies,
+		customDependencies: target.customDependencies,
+		scripts: getComposerScriptMap(packageManager),
+		projectDir: path.join(projectDir, path.dirname(target.packageJsonPath))
+	});
+	const packageJsonPath = path.join(projectDir, "package.json");
+	const packageJson = await fs.readJson(packageJsonPath);
+	const effectVersion = getDependencyVersion("effect");
+	if (!effectVersion) throw new Error("Dependency effect is missing from the version map.");
+	if (packageManager === "yarn") packageJson.resolutions = {
+		...packageJson.resolutions,
+		effect: effectVersion
+	};
+	else if (packageManager !== "pnpm") packageJson.overrides = {
+		...packageJson.overrides,
+		effect: effectVersion
+	};
+	await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
+	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: options.verbose === true ? "inherit" : "pipe"
+	});
+}
+
+//#endregion
+//#region src/tasks/deploy-with-composer.ts
+function redactSecrets(message) {
+	return message.replace(/\b((?:prisma\+)?postgres(?:ql)?:\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/\b([A-Z0-9_]*(?:DATABASE_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)[A-Z0-9_]*=)[^\s]+/g, "$1<redacted>");
+}
+function getErrorMessage(error) {
+	if (error instanceof Error) return redactSecrets(error.message);
+	return redactSecrets(String(error));
+}
+function stripResourcePrefix(id, prefix) {
+	const marker = `${prefix}_`;
+	return id.startsWith(marker) ? id.slice(marker.length) : id;
+}
+function getConsoleProjectUrl(workspaceId, projectId) {
+	const consoleWorkspaceId = stripResourcePrefix(workspaceId, "wksp");
+	const consoleProjectId = stripResourcePrefix(projectId, "proj");
+	return `https://console.prisma.io/${encodeURIComponent(consoleWorkspaceId)}/${encodeURIComponent(consoleProjectId)}`;
+}
+function parsePrismaCliEnvelope(output) {
+	const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
+	for (const line of lines) try {
+		const parsed = JSON.parse(line);
+		const candidate = parsed.kind === "result" ? parsed.envelope : parsed;
+		if (typeof candidate !== "object" || candidate === null) continue;
+		if (typeof Reflect.get(candidate, "ok") !== "boolean") continue;
+		return candidate;
+	} catch {}
+	throw new Error("Prisma CLI returned output that is not a valid result envelope.");
+}
+function getPrismaCliArgs(packageManager, args) {
+	return getPackageExecutionArgs(packageManager, [PRISMA_PLATFORM_CLI_PACKAGE, ...args]);
+}
+async function runPrismaJsonCommand(options) {
+	const invocation = getPrismaCliArgs(options.packageManager, [
+		...options.args,
+		"--json",
+		"--no-interactive"
+	]);
+	const result = await execa(invocation.command, invocation.args, {
+		cwd: options.projectDir,
+		env: process.env,
+		reject: false
+	});
+	if (options.forwardStderr && result.stderr) process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+	let envelope;
+	try {
+		envelope = parsePrismaCliEnvelope(result.stdout);
+	} catch (error) {
+		if (result.exitCode !== 0 && result.stderr.trim()) throw new Error(result.stderr.trim());
+		throw error;
+	}
+	if (result.exitCode !== 0 || !envelope.ok || envelope.result === void 0) {
+		const summary = envelope.error?.summary ?? envelope.error?.message;
+		throw new Error([summary, envelope.error?.why].filter(Boolean).join(": ") || result.stderr.trim() || "Prisma CLI command failed.");
+	}
+	return envelope.result;
+}
+async function ensureAuthentication(packageManager, projectDir, beforeInteractiveLogin) {
+	const whoami = () => runPrismaJsonCommand({
+		packageManager,
+		projectDir,
+		args: ["auth", "whoami"]
+	});
+	const authState = await whoami();
+	if (authState.authenticated) return authState;
+	const loginCommand = getPackageExecutionCommand(packageManager, [
+		PRISMA_PLATFORM_CLI_PACKAGE,
+		"auth",
+		"login"
+	]);
+	if (process.stdin.isTTY !== true) throw new Error(`Sign in first with ${loginCommand}, then run ${getRunScriptCommand(packageManager, "deploy")}.`);
+	beforeInteractiveLogin?.();
+	log.info("Sign in to Prisma to deploy.");
+	const login = getPrismaCliArgs(packageManager, ["auth", "login"]);
+	await execa(login.command, login.args, {
+		cwd: projectDir,
+		env: process.env,
+		stdio: "inherit"
+	});
+	const authenticatedState = await whoami();
+	if (!authenticatedState.authenticated) throw new Error("Prisma sign-in completed without an active workspace session.");
+	return authenticatedState;
+}
+function workspaceLabel(workspace) {
+	return workspace.name ?? workspace.id;
+}
+async function useWorkspace(options) {
+	return (await runPrismaJsonCommand({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"use",
+			options.workspace
+		]
+	})).workspace;
+}
+async function selectDeploymentWorkspace(options) {
+	const activeWorkspace = options.authState.workspace;
+	if (!activeWorkspace) throw new Error("The active Prisma credential does not specify a workspace.");
+	if (options.workspace) {
+		if (options.authState.source === "environment") {
+			if (options.workspace === activeWorkspace.id || options.workspace === activeWorkspace.name) return activeWorkspace;
+			throw new Error(`The environment credential is fixed to workspace ${workspaceLabel(activeWorkspace)}. Unset it before using --workspace ${options.workspace}.`);
+		}
+		return useWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			workspace: options.workspace
+		});
+	}
+	if (!options.shouldPrompt || process.stdin.isTTY !== true) return activeWorkspace;
+	const available = await runPrismaJsonCommand({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		args: [
+			"auth",
+			"workspace",
+			"list"
+		]
+	});
+	if (available.items.length <= 1) return activeWorkspace;
+	options.beforePrompt?.();
+	const selectedWorkspaceId = await select({
+		message: "Select Prisma workspace for deployment",
+		initialValue: activeWorkspace.id,
+		options: available.items.map((workspace) => ({
+			value: workspace.workspaceId,
+			label: workspace.workspaceName ?? workspace.workspaceId,
+			hint: workspace.current ? `${workspace.workspaceId}, current` : workspace.workspaceId
+		}))
+	});
+	if (isCancel(selectedWorkspaceId)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	options.afterPrompt?.();
+	if (selectedWorkspaceId === activeWorkspace.id) return activeWorkspace;
+	return useWorkspace({
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
+		workspace: selectedWorkspaceId
+	});
+}
+function parseComposerDeployResult(result) {
+	const summary = result.summary;
+	if (!summary) return;
+	const computeService = summary.nodes.flatMap((node) => node.entities).find((entity) => entity.kind === "compute-service");
+	return {
+		appName: summary.app,
+		...computeService?.url ? { appUrl: computeService.url.replace(/\/$/, "") } : {}
+	};
+}
+async function getProjectDetails(options) {
+	try {
+		const result = await runPrismaJsonCommand({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: [
+				"project",
+				"show",
+				"--project",
+				options.appName
+			]
+		});
+		if (!result.project) return;
+		return {
+			workspace: result.workspace,
+			project: {
+				id: result.project.id,
+				name: result.project.name,
+				consoleUrl: getConsoleProjectUrl(result.workspace.id, result.project.id)
+			}
+		};
+	} catch {
+		return;
+	}
+}
+async function deployWithComposer(options) {
+	const progress = options.verbose ? void 0 : spinner();
+	let progressRunning = false;
+	const showProgress = (message) => {
+		if (!progress) return;
+		if (progressRunning) progress.message(message);
+		else {
+			progress.start(message);
+			progressRunning = true;
+		}
+	};
+	const clearProgress = () => {
+		if (!progress || !progressRunning) return;
+		progress.clear();
+		progressRunning = false;
+	};
+	try {
+		showProgress("Checking Prisma account...");
+		if (options.verbose) log.step("Checking Prisma account.");
+		const authState = await ensureAuthentication(options.packageManager, options.projectDir, clearProgress);
+		showProgress("Checking Prisma workspace...");
+		if (options.verbose) log.step("Checking Prisma workspace.");
+		const selectedWorkspace = await selectDeploymentWorkspace({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			shouldPrompt: options.shouldPromptForWorkspace,
+			authState,
+			beforePrompt: clearProgress,
+			afterPrompt: () => showProgress("Selecting Prisma workspace..."),
+			...options.workspace ? { workspace: options.workspace } : {}
+		});
+		if (!selectedWorkspace) return;
+		showProgress("Building for deployment...");
+		if (options.verbose) log.step("Building for deployment.");
+		const build = getRunScriptArgs(options.packageManager, "build");
+		await execa(build.command, build.args, {
+			cwd: options.projectDir,
+			env: process.env,
+			stdio: options.verbose ? "inherit" : "pipe"
+		});
+		showProgress("Deploying to Prisma...");
+		if (options.verbose) log.step("Deploying to Prisma.");
+		const deployment = parseComposerDeployResult(await runPrismaJsonCommand({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			args: [
+				"composer",
+				"deploy",
+				"module.ts"
+			],
+			forwardStderr: options.verbose
+		}));
+		const appName = deployment?.appName ?? options.appName;
+		showProgress("Loading deployment details...");
+		const details = await getProjectDetails({
+			packageManager: options.packageManager,
+			projectDir: options.projectDir,
+			appName
+		});
+		progress?.stop("Deployed to Prisma.");
+		progressRunning = false;
+		if (options.verbose) log.success("Deployed to Prisma.");
+		const workspace = details?.workspace ?? selectedWorkspace;
+		return {
+			appName,
+			...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
+			...workspace ? { workspace } : {},
+			project: details?.project ?? { name: appName }
+		};
+	} catch (error) {
+		progress?.error("Deployment failed.");
+		progressRunning = false;
+		log.error(`Deploy failed: ${getErrorMessage(error)}`);
+		return;
+	}
+}
+
+//#endregion
+//#region src/tasks/setup-prisma.ts
+const DEFAULT_DATABASE_PROVIDER = "postgres";
+const DEFAULT_AUTHORING = "psl";
+async function promptForDatabaseProvider() {
+	const databaseProvider = await select({
+		message: "Select your database",
+		initialValue: DEFAULT_DATABASE_PROVIDER,
+		options: [{
+			value: "postgres",
+			label: "PostgreSQL",
+			hint: "Prisma Postgres with Composer"
+		}, {
+			value: "mongo",
+			label: "MongoDB",
+			hint: "Connect an existing MongoDB database"
+		}]
+	});
+	if (isCancel(databaseProvider)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	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: "Prisma schema syntax"
+		}, {
+			value: "typescript",
+			label: "TypeScript",
+			hint: "TypeScript contract builder"
+		}]
+	});
+	if (isCancel(authoring)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return AuthoringStyleSchema.parse(authoring);
+}
+function getPackageManagerHint(option, detected) {
+	const hints = {
+		npm: "Node.js default",
+		pnpm: "Fast, disk-efficient package manager",
+		yarn: "Yarn package manager",
+		bun: "Fast runtime and package manager",
+		deno: "Deno runtime (minimal PostgreSQL apps)"
+	};
+	return option === detected ? `Detected; ${hints[option]}` : hints[option];
+}
+async function promptForPackageManager(detected) {
+	const packageManager = await select({
+		message: "Choose package manager",
+		initialValue: detected,
+		options: packageManagers.map((value) => ({
+			value,
+			label: value,
+			hint: getPackageManagerHint(value, detected)
+		}))
+	});
+	if (isCancel(packageManager)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return PackageManagerSchema.parse(packageManager);
+}
+async function promptForDeployment() {
+	const shouldDeploy = await confirm({
+		message: "Deploy to Prisma now?",
+		initialValue: true
+	});
+	if (isCancel(shouldDeploy)) {
+		cancel("Operation cancelled.");
+		return;
+	}
+	return Boolean(shouldDeploy);
+}
+async function collectPrismaSetupContext(input, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? process.cwd());
+	const useDefaults = input.yes === true;
+	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
+	if (!databaseProvider) 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;
+	if (packageManager === "deno" && databaseProvider !== "postgres") throw new Error("Deno support currently requires PostgreSQL.");
+	if (packageManager === "deno" && options.template && options.template !== "minimal") throw new Error("Deno support currently requires the minimal template.");
+	if (packageManager === "deno" && input.deploy === true) throw new Error("Prisma Compute does not support Deno deployments yet. Use --no-deploy.");
+	const shouldDeploy = packageManager === "deno" ? false : input.deploy ?? (useDefaults ? false : await promptForDeployment());
+	if (shouldDeploy === void 0) return;
+	return {
+		projectDir,
+		verbose: input.verbose === true,
+		databaseProvider,
+		authoring,
+		packageManager,
+		shouldDeploy,
+		shouldPromptForWorkspace: !useDefaults,
+		...input.workspace ? { workspace: input.workspace } : {}
+	};
+}
+function getCommandErrorMessage(error) {
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr ?? "").trim();
+		if (stderr) return stderr;
+	}
+	return error instanceof Error ? error.message : String(error);
+}
+function getContractPath(authoring) {
+	return `src/prisma/contract${authoring === "typescript" ? ".ts" : ".prisma"}`;
+}
+function getInitTarget(provider) {
+	return provider === "mongo" ? "mongodb" : "postgres";
+}
+function getPrismaCliInvocation(packageManager, args) {
+	return getPackageExecutionArgs(packageManager, [packageManager === "deno" ? PRISMA_DENO_CLI_PACKAGE : PRISMA_PLATFORM_CLI_PACKAGE, ...args]);
+}
+async function runPrismaInit(context, projectDir) {
+	const args = context.packageManager === "deno" ? [
+		"init",
+		"--yes",
+		"--no-interactive",
+		"--target",
+		getInitTarget(context.databaseProvider),
+		"--authoring",
+		context.authoring,
+		"--schema-path",
+		getContractPath(context.authoring),
+		"--no-install",
+		"--no-skill"
+	] : [
+		"orm",
+		"init",
+		"--yes",
+		"--no-interactive",
+		"--target",
+		getInitTarget(context.databaseProvider),
+		"--authoring",
+		context.authoring,
+		"--schema-path",
+		getContractPath(context.authoring),
+		"--skip-install",
+		"--skip-skills"
+	];
+	const invocation = getPrismaCliInvocation(context.packageManager, args);
+	if (context.verbose) log.step(`Running ${[invocation.command, ...invocation.args].join(" ")}`);
+	await execa(invocation.command, invocation.args, {
+		cwd: projectDir,
+		stdio: context.verbose ? "inherit" : "pipe",
+		env: {
+			...process.env,
+			CI: "1"
+		}
+	});
+	if (context.packageManager === "deno") await fs.remove(path.join(projectDir, "prisma-next.md"));
+}
+async function ensureGitignoreEntry(projectDir, entry) {
+	const gitignorePath = path.join(projectDir, ".gitignore");
+	const existing = await fs.pathExists(gitignorePath) ? await fs.readFile(gitignorePath, "utf8") : "";
+	const lines = existing.split(/\r?\n/).map((line) => line.trim());
+	if (lines.includes(entry) || lines.includes(`/${entry}`)) return;
+	const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+	await fs.writeFile(gitignorePath, `${existing}${separator}${entry}\n`, "utf8");
+}
+async function ensureMongoEnvironment(projectDir) {
+	const envPath = path.join(projectDir, ".env");
+	if (!await fs.pathExists(envPath)) await fs.writeFile(envPath, "DATABASE_URL=\"mongodb://localhost:27017/mydb?replicaSet=rs0&directConnection=true\"\n", "utf8");
+	await ensureGitignoreEntry(projectDir, ".env");
+}
+async function ensureComposerTypeScriptOptions(projectDir) {
+	const tsconfigPath = path.join(projectDir, "tsconfig.json");
+	const tsconfig = await fs.readFile(tsconfigPath, "utf8");
+	const additions = [];
+	if (!/"allowImportingTsExtensions"\s*:/.test(tsconfig)) additions.push("    \"allowImportingTsExtensions\": true,");
+	if (!/"noEmit"\s*:/.test(tsconfig)) additions.push("    \"noEmit\": true,");
+	if (additions.length === 0) return;
+	const updated = tsconfig.replace(/"compilerOptions"\s*:\s*\{/, (match) => `${match}\n${additions.join("\n")}`);
+	if (updated === tsconfig) throw new Error("tsconfig.json is missing compilerOptions.");
+	await fs.writeFile(tsconfigPath, updated, "utf8");
+}
+async function emitContract(context, projectDir) {
+	const invocation = getPrismaCliInvocation(context.packageManager, ["contract", "emit"]);
+	if (context.verbose) log.step([invocation.command, ...invocation.args].join(" "));
+	await execa(invocation.command, invocation.args, {
+		cwd: projectDir,
+		stdio: context.verbose ? "inherit" : "pipe"
+	});
+}
+function formatNextSteps(steps) {
+	return steps.map((step) => `${step.command}\n  ${step.description}`).join("\n\n");
+}
+function formatPlatformTarget(name, id) {
+	return name ? `${name} (${id})` : id;
+}
+function formatProjectSummary(options) {
+	const lines = [];
+	if (options.createdProjectPath) lines.push(`Path: ${path.resolve(options.createdProjectPath)}`);
+	if (options.deployment?.workspace) lines.push(`Workspace: ${formatPlatformTarget(options.deployment.workspace.name, options.deployment.workspace.id)}`);
+	if (options.deployment) {
+		lines.push(`Project: ${options.deployment.project.id ? formatPlatformTarget(options.deployment.project.name, options.deployment.project.id) : options.deployment.project.name}`);
+		lines.push(`App: ${options.deployment.appUrl ?? options.deployment.appName}`);
+		if (options.deployment.project.consoleUrl) lines.push(`Console: ${options.deployment.project.consoleUrl}`);
+	}
+	return lines.join("\n");
+}
+function buildNextSteps(context, options) {
+	const nextSteps = [...options.prependNextSteps ?? []];
+	if (context.databaseProvider === "mongo") nextSteps.push({
+		command: "Set MONGODB_URL in your environment",
+		description: "Composer uses this secret when deploying the MongoDB template."
+	});
+	if (options.includeDevNextStep) nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, context.packageManager === "deno" ? "dev" : "dev:composer"),
+		description: context.packageManager === "deno" ? "Start the Deno app after setting DATABASE_URL in .env." : "Build and start the app with Prisma Composer locally."
+	});
+	if (context.packageManager === "deno") return nextSteps;
+	nextSteps.push({
+		command: getRunScriptCommand(context.packageManager, "deploy"),
+		description: "Build and deploy the app with Prisma Composer."
+	});
+	return nextSteps;
+}
+async function executePrismaSetupContext(context, options = {}) {
+	const projectDir = path.resolve(options.projectDir ?? context.projectDir);
+	const projectName = options.projectName ?? path.basename(projectDir);
+	const template = options.template ?? "minimal";
+	const progress = context.verbose ? void 0 : options.progressSpinner ?? spinner();
+	if (progress !== void 0 && !options.progressSpinner) progress.start("Creating Prisma 8 project...");
+	try {
+		progress?.message("Preparing Prisma 8 project files...");
+		await runPrismaInit(context, projectDir);
+		await scaffoldCreateSharedTemplates({
+			projectDir,
+			projectName,
+			template,
+			provider: context.databaseProvider,
+			authoring: context.authoring,
+			packageManager: context.packageManager
+		});
+		await writePrismaDependencies(context.databaseProvider, context.packageManager, context.authoring, projectDir);
+		await ensureComposerTypeScriptOptions(projectDir);
+		if (context.databaseProvider === "mongo") await ensureMongoEnvironment(projectDir);
+		progress?.message(`Installing dependencies with ${getInstallCommand(context.packageManager)}...`);
+		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+		progress?.message("Generating Prisma 8 contract artifacts...");
+		await emitContract(context, projectDir);
+		progress?.stop("Prisma 8 project ready.");
+	} catch (error) {
+		progress?.error("Could not create Prisma 8 project.");
+		cancel(getCommandErrorMessage(error));
+		return false;
+	}
+	let deployment;
+	if (context.shouldDeploy) {
+		deployment = await deployWithComposer({
+			appName: projectName,
+			packageManager: context.packageManager,
+			projectDir,
+			shouldPromptForWorkspace: context.shouldPromptForWorkspace,
+			verbose: context.verbose,
+			...context.workspace ? { workspace: context.workspace } : {}
+		});
+		if (!deployment) return false;
+	}
+	const projectSummary = formatProjectSummary({
+		createdProjectPath: options.createdProjectPath,
+		deployment
+	});
+	if (projectSummary) note(projectSummary, context.shouldDeploy ? "Deployment" : "Project");
+	note(formatNextSteps(buildNextSteps(context, options)), "Next steps");
+	outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 project ready.");
+	return true;
+}
+
+//#endregion
+//#region src/ui/branding.ts
+const prismaTitle = `${styleText(["bold", "cyanBright"], "◭")} ${styleText(["bold", "cyanBright"], "Create")} ${styleText(["bold", "magentaBright"], "Prisma")} ${styleText(["bold", "blueBright"], "8")}`;
+function getCreatePrismaIntro() {
+	return prismaTitle;
+}
+
+//#endregion
+//#region src/utils/node-version.ts
+const MINIMUM_NODE_VERSION = [
+	22,
+	18,
+	0
+];
+function parseVersion(version) {
+	const [major = "0", minor = "0", patch = "0"] = version.replace(/^v/, "").split(".");
+	return [
+		Number(major),
+		Number(minor),
+		Number.parseInt(patch, 10)
+	];
+}
+function supportsPrismaNext(nodeVersion = process.versions.node) {
+	const current = parseVersion(nodeVersion);
+	for (let index = 0; index < MINIMUM_NODE_VERSION.length; index += 1) {
+		if (current[index] > MINIMUM_NODE_VERSION[index]) return true;
+		if (current[index] < MINIMUM_NODE_VERSION[index]) return false;
+	}
+	return true;
+}
+function getUnsupportedNodeMessage(nodeVersion = process.versions.node) {
+	return [
+		`Node.js ${nodeVersion} is unsupported by create-prisma@next.`,
+		"Required: Node.js 22.18 or newer.",
+		"Update Node.js and run the command again."
+	].join("\n");
+}
+
+//#endregion
+//#region src/commands/create.ts
+const DEFAULT_PROJECT_NAME = "my-app";
+const DEFAULT_TEMPLATE = "minimal";
+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: "minimal",
+				label: "Minimal",
+				hint: "Script-first Prisma 8 starter with no web framework"
+			},
+			{
+				value: "hono",
+				label: "Hono",
+				hint: "Lightweight TypeScript API server"
+			},
+			{
+				value: "elysia",
+				label: "Elysia",
+				hint: "Bun-friendly TypeScript API server"
+			},
+			{
+				value: "nest",
+				label: "NestJS",
+				hint: "Structured Node API with controllers and services"
+			},
+			{
+				value: "next",
+				label: "Next.js",
+				hint: "Full-stack React app with App Router"
+			},
+			{
+				value: "svelte",
+				label: "SvelteKit",
+				hint: "Full-stack Svelte 5 app with Vite"
+			},
+			{
+				value: "astro",
+				label: "Astro",
+				hint: "Content-oriented web app with server routes"
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "Full-stack Vue app with Nitro server routes"
+			},
+			{
+				value: "tanstack-start",
+				label: "TanStack Start",
+				hint: "React app with file routes and server functions"
+			}
+		]
+	});
+	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);
+		if (!supportsPrismaNext()) {
+			cancel(getUnsupportedNodeMessage());
+			process.exitCode = 1;
+			return;
+		}
+		intro(getCreatePrismaIntro());
+		failureStage = "collect_context";
+		context = await collectCreateContext(input);
+		if (!context) return;
+		failureStage = "unknown";
+		const executionResult = await executeCreateContext(context);
+		if (!executionResult.ok) {
+			process.exitCode = 1;
+			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) {
+		process.exitCode = 1;
+		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 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();
+	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 prismaSetupContext = await collectPrismaSetupContext(input, {
+		projectDir: targetDirectory,
+		template
+	});
+	if (!prismaSetupContext) return;
+	return {
+		targetDirectory,
+		targetPathState,
+		force,
+		template,
+		projectPackageName: toPackageName(path.basename(targetDirectory)),
+		prismaSetupContext
+	};
+}
+async function executeCreateContext(context) {
+	const createSpinner = context.prismaSetupContext.verbose ? void 0 : spinner();
+	createSpinner?.start("Creating Prisma 8 project...");
+	try {
+		if (context.prismaSetupContext.verbose) log.step(`Scaffolding ${context.template} starter.`);
+		await scaffoldCreateFrameworkTemplate({
+			projectDir: context.targetDirectory,
+			projectName: context.projectPackageName,
+			template: context.template,
+			provider: context.prismaSetupContext.databaseProvider,
+			authoring: context.prismaSetupContext.authoring,
+			packageManager: context.prismaSetupContext.packageManager
+		});
+		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.");
+	} catch (error) {
+		createSpinner?.error("Could not create Prisma 8 project.");
+		return {
+			ok: false,
+			stage: "scaffold_template",
+			error
+		};
+	}
+	try {
+		await writeCreateTemplateDependencies({
+			template: context.template,
+			packageManager: context.prismaSetupContext.packageManager,
+			projectDir: context.targetDirectory
+		});
+	} catch (error) {
+		createSpinner?.error("Could not create Prisma 8 project.");
+		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) === "." ? [] : [{
+		command: `cd ${formatPathForDisplay(context.targetDirectory)}`,
+		description: "Enter your new project directory."
+	}];
+	try {
+		if (!await executePrismaSetupContext(context.prismaSetupContext, {
+			prependNextSteps: nextSteps,
+			projectDir: context.targetDirectory,
+			projectName: context.projectPackageName,
+			template: context.template,
+			createdProjectPath: context.targetDirectory,
+			includeDevNextStep: true,
+			progressSpinner: createSpinner
+		})) return {
+			ok: false,
+			stage: "prisma_setup"
+		};
+	} catch (error) {
+		createSpinner?.error("Could not create Prisma 8 project.");
+		return {
+			ok: false,
+			stage: "prisma_setup",
+			error
+		};
+	}
+	return { ok: true };
+}
+
+//#endregion
+export { DatabaseProviderSchema as a, CreateTemplateSchema as i, AuthoringStyleSchema as n, PackageManagerSchema as o, CreateCommandInputSchema as r, runCreateCommand as t };