create-prisma 0.11.2 → 0.11.3

package/dist/create-TR_gtjND.mjs

@@ -1,1987 +0,0 @@
-#!/usr/bin/env node
-import { z } from "zod";
-import { cancel, confirm, intro, isCancel, log, note, outro, select, spinner, taskLog, 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 { Writable } from "node:stream";
-import { createInterface } from "node:readline";
-import { styleText } from "node:util";
-
-//#region src/create-outcome.ts
-var CreateCancellationError = class extends Error {
-	stage;
-	constructor(stage) {
-		super("Operation cancelled.");
-		this.name = "CreateCancellationError";
-		this.stage = stage;
-	}
-};
-var ClassifiedCreateError = class extends Error {
-	reason;
-	constructor(reason, message, options) {
-		super(message, options);
-		this.name = "ClassifiedCreateError";
-		this.reason = reason;
-	}
-};
-function getCreateFailureReason(error, fallback) {
-	return error instanceof ClassifiedCreateError ? error.reason : fallback;
-}
-
-//#endregion
-//#region src/result.ts
-const CREATE_PRISMA_RESULT_SCHEMA_VERSION = 1;
-function createCommandFailureResult(stage, message, project) {
-	return {
-		schemaVersion: CREATE_PRISMA_RESULT_SCHEMA_VERSION,
-		ok: false,
-		error: {
-			stage,
-			message
-		},
-		...project ? { project } : {}
-	};
-}
-
-//#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.11.2",
-		"node-version": process.version,
-		platform: process.platform,
-		arch: process.arch
-	};
-}
-function sanitizeProperties(properties) {
-	return Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0));
-}
-async function trackCliTelemetry(event, properties) {
-	if (shouldDisableTelemetry()) return;
-	let client;
-	try {
-		const distinctId = await getAnonymousId();
-		const sanitizedProperties = sanitizeProperties({
-			...getCommonProperties(),
-			...properties,
-			$process_person_profile: false
-		});
-		client = new PostHog(TELEMETRY_API_KEY, {
-			host: TELEMETRY_HOST,
-			disableGeoip: true,
-			flushAt: 1,
-			flushInterval: 0
-		});
-		await client.captureImmediate({
-			distinctId,
-			event,
-			properties: sanitizedProperties,
-			disableGeoip: true
-		});
-	} catch {} finally {
-		if (client) await client.shutdown().catch(() => {});
-	}
-}
-
-//#endregion
-//#region src/telemetry/create.ts
-const CREATE_PRISMA_NEXT_COMPLETED_EVENT = "cli:create_prisma_next_command_completed";
-const CREATE_PRISMA_NEXT_FAILED_EVENT = "cli:create_prisma_next_command_failed";
-const CREATE_PRISMA_NEXT_CANCELLED_EVENT = "cli:create_prisma_next_command_cancelled";
-const expectedRejectionReasons = new Set([
-	"invalid_input",
-	"unsupported_node_version",
-	"invalid_project_name",
-	"target_path_not_directory",
-	"target_directory_not_empty",
-	"unsupported_configuration",
-	"not_authenticated",
-	"workspace_missing",
-	"workspace_mismatch",
-	"project_name_collision"
-]);
-function getFailureClass(reason) {
-	return expectedRejectionReasons.has(reason) ? "expected_rejection" : "technical_failure";
-}
-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 {
-		"telemetry-schema-version": 2,
-		command: "create",
-		"uses-defaults": input.yes === true || input.json === true,
-		json: input.json === 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;
-}
-function getPrismaCliFailureProperty(error, property) {
-	if (typeof error !== "object" || error === null) return null;
-	const value = Reflect.get(error, property);
-	return typeof value === "string" && value.length > 0 ? value : 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-class": getFailureClass(params.reason),
-		"failure-stage": params.stage,
-		"failure-reason": params.reason,
-		"error-name": getErrorName(params.error),
-		"error-code": getErrorCode(params.error),
-		"prisma-cli-command": getPrismaCliFailureProperty(params.error, "prismaCliCommand"),
-		"prisma-cli-error-code": getPrismaCliFailureProperty(params.error, "prismaCliErrorCode")
-	});
-}
-async function trackCreateCancelled(params) {
-	await trackCliTelemetry(CREATE_PRISMA_NEXT_CANCELLED_EVENT, {
-		...getBaseCreateProperties(params.input, params.context),
-		"duration-ms": params.durationMs,
-		"cancellation-stage": params.stage
-	});
-}
-
-//#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"),
-	json: z.boolean().optional().describe("Emit one quiet JSON result for agents and automation (non-interactive; deploys unless --no-deploy)")
-});
-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 DENO_ALLOW_FRESH_DEPENDENCIES = "--minimum-dependency-age=0";
-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";
-	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", DENO_ALLOW_FRESH_DEPENDENCIES]
-	};
-	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",
-					DENO_ALLOW_FRESH_DEPENDENCIES,
-					`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
-const tsdownEntries = {
-	minimal: "src/index.ts",
-	hono: "src/index.ts",
-	elysia: "src/index.ts",
-	nest: "src/main.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,
-		tsdownEntry: tsdownEntries[template] ?? null
-	};
-}
-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/composer": "0.16.0",
-	"@prisma/composer-prisma-cloud": "0.16.0",
-	"@prisma/orm-mongo": "8.0.0-rc.8",
-	"@prisma/orm-postgres": "8.0.0-rc.8",
-	"@sveltejs/adapter-node": "^5.3.2",
-	"@types/node": "^25.6.2",
-	alchemy: "2.0.0-beta.74",
-	arktype: "^2.2.3",
-	dotenv: "^17.4.2",
-	effect: "4.0.0-rc.112",
-	mongodb: "^7.1.0",
-	"mongodb-memory-server": "^11.1.0",
-	nitro: "^3.0.260610-beta",
-	prisma: "latest",
-	"temporal-polyfill": "^1.0.4",
-	tsdown: "^0.22.14",
-	tsx: "^4.21.0",
-	typescript: "^5.9.3"
-};
-const PRISMA_PLATFORM_CLI_PACKAGE = "prisma@latest";
-const PRISMA_DENO_CLI_PACKAGE = PRISMA_PLATFORM_CLI_PACKAGE;
-function getDependencyVersion(packageName) {
-	return dependencyVersionMap[packageName];
-}
-function usesTsdown(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 = [];
-	if (usesTsdown(template)) {
-		devDependencies.push("tsdown");
-		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/utils/run-command.ts
-/**
-* Runs a setup command without allowing child output to corrupt structured CLI output.
-* Human verbose mode keeps native streaming; JSON mode always captures child output.
-*/
-async function runSetupCommand(options) {
-	const shouldInheritOutput = options.verbose && !options.json;
-	await execa(options.command, options.args, {
-		cwd: options.cwd,
-		env: options.env,
-		stdio: shouldInheritOutput ? "inherit" : "pipe"
-	});
-}
-
-//#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, "db", "migrate"),
-			"migration:status": prismaCommand(true, "migration", "status"),
-			"migration:show": prismaCommand(true, "migration", "show")
-		};
-	}
-	const prismaCommand = (...args) => ["prisma", ...args].join(" ");
-	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("db", "migrate"),
-		"migration:status": prismaCommand("migration", "status"),
-		"migration:show": prismaCommand("migration", "show"),
-		"skills:sync": `${prismaCommand("skills", "sync")} || exit 0`
-	};
-}
-function getComposerScriptMap(packageManager) {
-	if (packageManager === "deno") return {};
-	const composerCommand = (subcommand) => [
-		"prisma",
-		subcommand,
-		"module.ts"
-	].join(" ");
-	return {
-		"composer:dev": composerCommand("dev"),
-		"composer:deploy": composerCommand("deploy"),
-		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 === "postgres" && packageManager !== "deno") dependencies.push("temporal-polyfill");
-	if (provider === "mongo") dependencies.push("arktype", "mongodb");
-	if (packageManager === "deno") dependencies.push("dotenv");
-	await addPackageDependency({
-		dependencies,
-		devDependencies: ["@types/node", "prisma"],
-		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 runSetupCommand({
-		command: installCommand.command,
-		args: installCommand.args,
-		cwd: projectDir,
-		env,
-		verbose: options.verbose === true,
-		json: options.json === true
-	});
-}
-
-//#endregion
-//#region src/ui/output.ts
-const silentOutput = new Writable({ write(_chunk, _encoding, callback) {
-	callback();
-} });
-/** Resolves the shared interaction policy for human and machine-readable modes. */
-function resolveExecutionSettings(options) {
-	const json = options.json === true;
-	return {
-		json,
-		output: json ? silentOutput : process.stdout,
-		useDefaults: options.yes === true || json
-	};
-}
-
-//#endregion
-//#region src/utils/errors.ts
-function redactSecrets(message) {
-	return message.replace(/\b((?:(?:prisma\+)?postgres(?:ql)?|mongodb(?:\+srv)?):\/\/)[^\s'"]+/gi, "$1<redacted>").replace(/\b([A-Z0-9_]*(?:MONGODB_(?:URL|URI)|DATABASE_URL|TOKEN|SECRET|PASSWORD|API_KEY|PRIVATE_KEY)[A-Z0-9_]*\s*=\s*)(?:"[^"]*"|'[^']*'|[^\s]+)/gi, "$1<redacted>").replace(/(\bAuthorization\s*:\s*Bearer\s+)[^\s'"]+/gi, "$1<redacted>");
-}
-function getErrorMessage(error) {
-	if (error instanceof Error && "stderr" in error) {
-		const stderr = String(error.stderr ?? "").trim();
-		if (stderr) return redactSecrets(stderr);
-	}
-	return redactSecrets(error instanceof Error ? error.message : String(error));
-}
-
-//#endregion
-//#region src/tasks/deploy-with-composer.ts
-var PrismaCliCommandError = class extends Error {
-	prismaCliCommand;
-	prismaCliErrorCode;
-	constructor(options) {
-		super(options.message);
-		this.name = "PrismaCliCommandError";
-		this.prismaCliCommand = options.command;
-		this.prismaCliErrorCode = options.code;
-	}
-};
-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 subprocess = execa(invocation.command, invocation.args, {
-		cwd: options.projectDir,
-		env: process.env,
-		reject: false
-	});
-	const stderrLines = options.onStderrLine && subprocess.stderr ? (async () => {
-		const lines = createInterface({ input: subprocess.stderr });
-		for await (const line of lines) if (line.trim()) options.onStderrLine?.(line);
-	})() : Promise.resolve();
-	const [result] = await Promise.all([subprocess, stderrLines]);
-	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) throw new PrismaCliCommandError({
-		message: [envelope.error?.summary ?? envelope.error?.message, envelope.error?.why].filter(Boolean).join(": ") || result.stderr.trim() || "Prisma CLI command failed.",
-		...envelope.commandId || envelope.command ? { command: envelope.commandId ?? envelope.command } : {},
-		...envelope.error?.code ? { code: envelope.error.code } : {}
-	});
-	return envelope.result;
-}
-function findProjectNameCollisions(projects, appName) {
-	return projects.filter((project) => project.name === appName);
-}
-async function ensureProjectNameAvailable(options) {
-	const collisions = findProjectNameCollisions((await runPrismaJsonCommand({
-		packageManager: options.packageManager,
-		projectDir: options.projectDir,
-		args: ["project", "list"]
-	})).items, options.appName);
-	if (collisions.length === 0) return;
-	const projectIds = collisions.map((project) => project.id).join(", ");
-	throw new ClassifiedCreateError("project_name_collision", `A Prisma project named "${options.appName}" already exists in workspace ${workspaceLabel(options.workspace)} (${options.workspace.id}). Choose a different project name or delete the existing project (${projectIds}) in Prisma Console, then retry.`);
-}
-async function ensureAuthentication(options) {
-	const whoami = () => runPrismaJsonCommand({
-		packageManager: options.packageManager,
-		projectDir: options.projectDir,
-		args: ["auth", "whoami"]
-	});
-	const authState = await whoami();
-	if (authState.authenticated) return authState;
-	const loginCommand = getPackageExecutionCommand(options.packageManager, [
-		PRISMA_PLATFORM_CLI_PACKAGE,
-		"auth",
-		"login"
-	]);
-	if (!options.allowInteractiveLogin || process.stdin.isTTY !== true) throw new ClassifiedCreateError("not_authenticated", `Sign in first with ${loginCommand}, then run ${getRunScriptCommand(options.packageManager, "deploy")}.`);
-	options.beforeInteractiveLogin?.();
-	log.info("Sign in to Prisma to deploy.", { output: options.output });
-	const login = getPrismaCliArgs(options.packageManager, ["auth", "login"]);
-	await execa(login.command, login.args, {
-		cwd: options.projectDir,
-		env: process.env,
-		stdio: "inherit"
-	});
-	const authenticatedState = await whoami();
-	if (!authenticatedState.authenticated) throw new ClassifiedCreateError("authentication_failed", "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 ClassifiedCreateError("workspace_missing", "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 {
-				ok: true,
-				workspace: activeWorkspace
-			};
-			throw new ClassifiedCreateError("workspace_mismatch", `The environment credential is fixed to workspace ${workspaceLabel(activeWorkspace)}. Unset it before using --workspace ${options.workspace}.`);
-		}
-		return {
-			ok: true,
-			workspace: await useWorkspace({
-				packageManager: options.packageManager,
-				projectDir: options.projectDir,
-				workspace: options.workspace
-			})
-		};
-	}
-	if (!options.shouldPrompt || process.stdin.isTTY !== true) return {
-		ok: true,
-		workspace: activeWorkspace
-	};
-	const available = await runPrismaJsonCommand({
-		packageManager: options.packageManager,
-		projectDir: options.projectDir,
-		args: [
-			"auth",
-			"workspace",
-			"list"
-		]
-	});
-	if (available.items.length <= 1) return {
-		ok: true,
-		workspace: 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
-		})),
-		output: options.output
-	});
-	if (isCancel(selectedWorkspaceId)) {
-		cancel("Operation cancelled.", { output: options.output });
-		return {
-			ok: false,
-			cancelled: true
-		};
-	}
-	options.afterPrompt?.();
-	if (selectedWorkspaceId === activeWorkspace.id) return {
-		ok: true,
-		workspace: activeWorkspace
-	};
-	return {
-		ok: true,
-		workspace: await 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?.id ? { serviceId: computeService.id } : {},
-		...computeService?.url ? { appUrl: computeService.url.replace(/\/$/, "") } : {}
-	};
-}
-async function getProjectDetails(options) {
-	try {
-		const result = await runPrismaJsonCommand({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			args: [
-				"project",
-				"show",
-				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;
-	}
-}
-/**
-* Performs the optional one-shot deployment at the end of a create-prisma scaffold.
-* Generated projects use their own `deploy` script for every subsequent deployment.
-*/
-async function deployNewProjectWithComposer(options) {
-	const output = options.output ?? process.stdout;
-	const progress = options.verbose ? void 0 : spinner({ output });
-	let deploymentLog;
-	let progressRunning = false;
-	let failureStage = "authenticate";
-	let failureReason = "prisma_auth_command_failed";
-	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.", { output });
-		const authState = await ensureAuthentication({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			output,
-			allowInteractiveLogin: options.allowInteractiveLogin ?? true,
-			beforeInteractiveLogin: clearProgress
-		});
-		showProgress("Checking Prisma workspace...");
-		failureStage = "select_workspace";
-		failureReason = "workspace_selection_failed";
-		if (options.verbose) log.step("Checking Prisma workspace.", { output });
-		const workspaceResult = await selectDeploymentWorkspace({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			shouldPrompt: options.shouldPromptForWorkspace,
-			authState,
-			output,
-			beforePrompt: clearProgress,
-			afterPrompt: () => showProgress("Selecting Prisma workspace..."),
-			...options.workspace ? { workspace: options.workspace } : {}
-		});
-		if (!workspaceResult.ok) return {
-			ok: false,
-			cancelled: true,
-			stage: "select_workspace"
-		};
-		const selectedWorkspace = workspaceResult.workspace;
-		showProgress("Checking Prisma project name...");
-		failureStage = "check_project_name";
-		failureReason = "project_lookup_failed";
-		if (options.verbose) log.step("Checking Prisma project name.", { output });
-		await ensureProjectNameAvailable({
-			appName: options.appName,
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			workspace: selectedWorkspace
-		});
-		showProgress("Building for deployment...");
-		failureStage = "build";
-		failureReason = "build_failed";
-		if (options.verbose) log.step("Building for deployment.", { output });
-		const build = getRunScriptArgs(options.packageManager, "build");
-		await runSetupCommand({
-			command: build.command,
-			args: build.args,
-			cwd: options.projectDir,
-			env: process.env,
-			verbose: options.verbose,
-			json: options.json === true
-		});
-		clearProgress();
-		failureStage = "composer_deploy";
-		failureReason = "composer_deploy_failed";
-		const deployCommand = getPackageExecutionCommand(options.packageManager, [
-			PRISMA_PLATFORM_CLI_PACKAGE,
-			"deploy",
-			"module.ts"
-		]);
-		if (options.verbose) log.step(`Deploying to Prisma with ${deployCommand}.`, { output });
-		else {
-			deploymentLog = taskLog({
-				title: "Deploying to Prisma...",
-				limit: 10,
-				output
-			});
-			deploymentLog.message(`$ ${deployCommand}`);
-		}
-		const deployment = parseComposerDeployResult(await runPrismaJsonCommand({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			args: ["deploy", "module.ts"],
-			onStderrLine: (line) => {
-				const redactedLine = redactSecrets(line);
-				if (options.verbose) output.write(`${redactedLine}\n`);
-				else deploymentLog?.message(redactedLine);
-			}
-		}));
-		const appName = deployment?.appName ?? options.appName;
-		if (options.verbose) log.step("Loading deployment details.", { output });
-		else deploymentLog?.message("Loading deployment details...");
-		const details = await getProjectDetails({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			appName
-		});
-		deploymentLog?.success("Deployed to Prisma.");
-		deploymentLog = void 0;
-		progressRunning = false;
-		if (options.verbose) log.success("Deployed to Prisma.", { output });
-		const workspace = details?.workspace ?? selectedWorkspace;
-		return {
-			ok: true,
-			deployment: {
-				appName,
-				...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
-				...deployment?.serviceId ? { serviceId: deployment.serviceId } : {},
-				...workspace ? { workspace } : {},
-				project: details?.project ?? { name: appName }
-			}
-		};
-	} catch (error) {
-		if (deploymentLog) {
-			deploymentLog.error("Deployment failed.");
-			deploymentLog = void 0;
-		} else progress?.error("Deployment failed.");
-		progressRunning = false;
-		log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
-		return {
-			ok: false,
-			stage: failureStage,
-			reason: getCreateFailureReason(error, failureReason),
-			error
-		};
-	}
-}
-
-//#endregion
-//#region src/tasks/initialize-git.ts
-function errorMessage(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);
-}
-/**
-* Initializes a standalone scaffold as a Git repository and records its generated files.
-* Projects created inside an existing repository remain part of that repository.
-*/
-async function initializeGitRepository(projectDir, env = process.env) {
-	try {
-		const existing = await execa("git", ["rev-parse", "--is-inside-work-tree"], {
-			cwd: projectDir,
-			env,
-			reject: false
-		});
-		if (existing.exitCode === 0 && existing.stdout.trim() === "true") return { status: "already-in-repository" };
-	} catch (error) {
-		return {
-			status: "skipped",
-			reason: errorMessage(error)
-		};
-	}
-	let initialized = false;
-	try {
-		await execa("git", ["init"], {
-			cwd: projectDir,
-			env
-		});
-		initialized = true;
-		await execa("git", ["add", "--all"], {
-			cwd: projectDir,
-			env
-		});
-		await execa("git", [
-			"commit",
-			"--no-verify",
-			"-m",
-			"Initial commit from create-prisma"
-		], {
-			cwd: projectDir,
-			env
-		});
-		return { status: "initialized" };
-	} catch (error) {
-		if (initialized) await fs.remove(path.join(projectDir, ".git"));
-		return {
-			status: "skipped",
-			reason: errorMessage(error)
-		};
-	}
-}
-
-//#endregion
-//#region src/tasks/setup-prisma.ts
-const DEFAULT_DATABASE_PROVIDER = "postgres";
-const DEFAULT_AUTHORING = "psl";
-async function promptForDatabaseProvider(output) {
-	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"
-		}],
-		output
-	});
-	if (isCancel(databaseProvider)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("database_provider");
-	}
-	return DatabaseProviderSchema.parse(databaseProvider);
-}
-async function promptForAuthoringStyle(output) {
-	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"
-		}],
-		output
-	});
-	if (isCancel(authoring)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("authoring_style");
-	}
-	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, output) {
-	const packageManager = await select({
-		message: "Choose package manager",
-		initialValue: detected,
-		options: packageManagers.map((value) => ({
-			value,
-			label: value,
-			hint: getPackageManagerHint(value, detected)
-		})),
-		output
-	});
-	if (isCancel(packageManager)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("package_manager");
-	}
-	return PackageManagerSchema.parse(packageManager);
-}
-async function promptForDeployment(output) {
-	const shouldDeploy = await confirm({
-		message: "Deploy to Prisma now?",
-		initialValue: true,
-		output
-	});
-	if (isCancel(shouldDeploy)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("deployment_intent");
-	}
-	return Boolean(shouldDeploy);
-}
-async function collectPrismaSetupContext(input, options = {}) {
-	const projectDir = path.resolve(options.projectDir ?? process.cwd());
-	const { json, output, useDefaults } = resolveExecutionSettings(input);
-	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider(output));
-	const authoring = input.authoring ?? (useDefaults ? DEFAULT_AUTHORING : await promptForAuthoringStyle(output));
-	const detectedPackageManager = await detectPackageManager(projectDir);
-	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager, output));
-	if (packageManager === "deno" && databaseProvider !== "postgres") throw new ClassifiedCreateError("unsupported_configuration", "Deno support currently requires PostgreSQL.");
-	if (packageManager === "deno" && options.template && options.template !== "minimal") throw new ClassifiedCreateError("unsupported_configuration", "Deno support currently requires the minimal template.");
-	if (packageManager === "deno" && input.deploy === true) throw new ClassifiedCreateError("unsupported_configuration", "Prisma Compute does not support Deno deployments yet. Use --no-deploy.");
-	const shouldDeploy = packageManager === "deno" ? false : input.deploy ?? (json ? true : useDefaults ? false : await promptForDeployment(output));
-	return {
-		projectDir,
-		verbose: input.verbose === true,
-		json,
-		output,
-		databaseProvider,
-		authoring,
-		packageManager,
-		shouldDeploy,
-		shouldPromptForWorkspace: !useDefaults,
-		...input.workspace ? { workspace: input.workspace } : {}
-	};
-}
-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 = [
-		"orm",
-		"init",
-		"--yes",
-		"--no-interactive",
-		"--target",
-		getInitTarget(context.databaseProvider),
-		"--authoring",
-		context.authoring,
-		"--schema-path",
-		getContractPath(context.authoring),
-		"--skip-install"
-	];
-	const invocation = getPrismaCliInvocation(context.packageManager, args);
-	if (context.verbose) log.step(`Running ${[invocation.command, ...invocation.args].join(" ")}`, { output: context.output });
-	await runSetupCommand({
-		command: invocation.command,
-		args: invocation.args,
-		cwd: projectDir,
-		env: {
-			...process.env,
-			CI: "1"
-		},
-		verbose: context.verbose,
-		json: context.json
-	});
-	if (context.packageManager === "deno") await fs.remove(path.join(projectDir, "prisma-next.md"));
-}
-async function initializeAgentSkills(context, projectDir) {
-	if (context.packageManager === "deno") return;
-	const invocation = getPrismaCliInvocation(context.packageManager, [
-		"init",
-		"--yes",
-		"--no-interactive"
-	]);
-	if (context.verbose) log.step(`Running ${[invocation.command, ...invocation.args].join(" ")}`, { output: context.output });
-	await runSetupCommand({
-		command: invocation.command,
-		args: invocation.args,
-		cwd: projectDir,
-		env: {
-			...process.env,
-			CI: "1"
-		},
-		verbose: context.verbose,
-		json: context.json
-	});
-}
-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 runPrismaCli(context, projectDir, args) {
-	const invocation = getPrismaCliInvocation(context.packageManager, args);
-	if (context.verbose) log.step([invocation.command, ...invocation.args].join(" "), { output: context.output });
-	await runSetupCommand({
-		command: invocation.command,
-		args: invocation.args,
-		cwd: projectDir,
-		env: {
-			...process.env,
-			CI: "1"
-		},
-		verbose: context.verbose,
-		json: context.json
-	});
-}
-async function emitContract(context, projectDir) {
-	await runPrismaCli(context, projectDir, ["contract", "emit"]);
-}
-async function planBaselineMigration(context, projectDir) {
-	await runPrismaCli(context, projectDir, [
-		"migration",
-		"plan",
-		"--name",
-		"init"
-	]);
-}
-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({ output: context.output });
-	const ownsProgress = progress !== void 0 && !options.progressSpinner;
-	let gitInitialization;
-	let setupStage = "initialize_prisma";
-	let setupReason = "prisma_init_failed";
-	if (ownsProgress) progress.start("Creating Prisma 8 project...");
-	try {
-		progress?.message("Preparing Prisma 8 project files...");
-		await runPrismaInit(context, projectDir);
-		setupStage = "configure_project";
-		setupReason = "project_configuration_failed";
-		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);
-		if (context.packageManager !== "deno") {
-			await ensureGitignoreEntry(projectDir, "/.alchemy");
-			await ensureGitignoreEntry(projectDir, "/.prisma-composer");
-		}
-		progress?.message(`Installing dependencies with ${getInstallCommand(context.packageManager)}...`);
-		setupStage = "install_dependencies";
-		setupReason = "dependency_install_failed";
-		await installProjectDependencies(context.packageManager, projectDir, {
-			verbose: context.verbose,
-			json: context.json
-		});
-		progress?.message("Installing Prisma agent skills...");
-		setupStage = "initialize_agent_skills";
-		setupReason = "agent_skills_init_failed";
-		await initializeAgentSkills(context, projectDir);
-		progress?.message("Generating Prisma 8 contract artifacts...");
-		setupStage = "emit_contract";
-		setupReason = "contract_emit_failed";
-		await emitContract(context, projectDir);
-		if (context.databaseProvider === "postgres") {
-			progress?.message("Authoring the baseline migration...");
-			setupStage = "plan_migration";
-			setupReason = "migration_plan_failed";
-			await planBaselineMigration(context, projectDir);
-		}
-		if (options.initializeGit) {
-			progress?.message("Initializing Git repository...");
-			setupStage = "initialize_git";
-			setupReason = "git_initialization_failed";
-			gitInitialization = await initializeGitRepository(projectDir);
-		}
-		progress?.stop("Prisma 8 project ready.");
-		if (gitInitialization?.status === "initialized" && context.verbose) log.success("Initialized Git repository with an initial commit.", { output: context.output });
-		else if (gitInitialization?.status === "skipped") log.warn(`Could not initialize Git repository: ${gitInitialization.reason}`, { output: context.output });
-	} catch (error) {
-		progress?.error("Could not create Prisma 8 project.");
-		cancel(getErrorMessage(error), { output: context.output });
-		return {
-			ok: false,
-			stage: setupStage,
-			reason: getCreateFailureReason(error, setupReason),
-			error,
-			errorReported: true
-		};
-	}
-	let deployment;
-	if (context.shouldDeploy) {
-		const deploymentResult = await deployNewProjectWithComposer({
-			appName: projectName,
-			packageManager: context.packageManager,
-			projectDir,
-			shouldPromptForWorkspace: context.shouldPromptForWorkspace,
-			verbose: context.verbose,
-			output: context.output,
-			allowInteractiveLogin: !context.json,
-			json: context.json,
-			...context.workspace ? { workspace: context.workspace } : {}
-		});
-		if (!deploymentResult.ok) {
-			if (deploymentResult.cancelled) return {
-				ok: false,
-				cancelled: true,
-				stage: deploymentResult.stage,
-				errorReported: true
-			};
-			return {
-				ok: false,
-				stage: deploymentResult.stage,
-				reason: deploymentResult.reason,
-				error: deploymentResult.error,
-				errorReported: true
-			};
-		}
-		deployment = deploymentResult.deployment;
-	}
-	const nextSteps = buildNextSteps(context, options);
-	const warnings = gitInitialization?.status === "skipped" ? [`Could not initialize Git repository: ${gitInitialization.reason}`] : [];
-	const projectSummary = formatProjectSummary({
-		createdProjectPath: options.createdProjectPath,
-		deployment
-	});
-	if (projectSummary) note(projectSummary, context.shouldDeploy ? "Deployment" : "Project", { output: context.output });
-	note(formatNextSteps(nextSteps), "Next steps", { output: context.output });
-	outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 project ready.", { output: context.output });
-	return {
-		ok: true,
-		deployment: deployment ?? null,
-		nextSteps,
-		...gitInitialization ? { gitInitialization } : {},
-		warnings
-	};
-}
-
-//#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 supportsPrisma(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@latest.`,
-		"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.";
-}
-function getProjectResult(context) {
-	return {
-		name: context.projectPackageName,
-		path: context.targetDirectory,
-		template: context.template,
-		databaseProvider: context.prismaSetupContext.databaseProvider,
-		authoring: context.prismaSetupContext.authoring,
-		packageManager: context.prismaSetupContext.packageManager
-	};
-}
-async function promptForProjectName(output) {
-	const projectName = await text({
-		message: "Project name",
-		placeholder: DEFAULT_PROJECT_NAME,
-		initialValue: DEFAULT_PROJECT_NAME,
-		validate: validateProjectName,
-		output
-	});
-	if (isCancel(projectName)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("project_name");
-	}
-	return String(projectName).trim();
-}
-async function promptForCreateTemplate(output) {
-	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"
-			}
-		],
-		output
-	});
-	if (isCancel(template)) {
-		cancel("Operation cancelled.", { output });
-		throw new CreateCancellationError("template");
-	}
-	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";
-	let failureReason = "invalid_input";
-	const { output } = resolveExecutionSettings(rawInput);
-	try {
-		input = CreateCommandInputSchema.parse(rawInput);
-		if (input.json && input.verbose) throw new Error("--verbose cannot be used with --json because JSON mode is output-only.");
-		if (!supportsPrisma()) {
-			const message = getUnsupportedNodeMessage();
-			cancel(message, { output });
-			process.exitCode = 1;
-			await trackCreateFailed({
-				input,
-				durationMs: Date.now() - startedAt,
-				stage: failureStage,
-				reason: "unsupported_node_version"
-			});
-			return createCommandFailureResult(failureStage, message);
-		}
-		intro(getCreatePrismaIntro(), { output });
-		failureStage = "collect_context";
-		failureReason = "unexpected_error";
-		const collected = await collectCreateContext(input);
-		if (!collected.ok) {
-			process.exitCode = 1;
-			const result = createCommandFailureResult(failureStage, collected.message);
-			await trackCreateFailed({
-				input,
-				durationMs: Date.now() - startedAt,
-				stage: failureStage,
-				reason: collected.reason
-			});
-			return result;
-		}
-		context = collected.context;
-		failureStage = "unknown";
-		const executionResult = await executeCreateContext(context);
-		if (!executionResult.ok) {
-			process.exitCode = 1;
-			if (executionResult.cancelled) {
-				await trackCreateCancelled({
-					input,
-					context,
-					durationMs: Date.now() - startedAt,
-					stage: executionResult.stage
-				});
-				return createCommandFailureResult(executionResult.stage, "Operation cancelled.", getProjectResult(context));
-			}
-			const message = executionResult.error ? getErrorMessage(executionResult.error) : "Project setup did not complete.";
-			if (executionResult.error && !executionResult.errorReported) cancel(`Create command failed: ${message}`, { output });
-			await trackCreateFailed({
-				input,
-				context,
-				durationMs: Date.now() - startedAt,
-				error: executionResult.error,
-				stage: executionResult.stage,
-				reason: executionResult.reason
-			});
-			return createCommandFailureResult(executionResult.stage, message, getProjectResult(context));
-		}
-		await trackCreateCompleted({
-			input,
-			context,
-			durationMs: Date.now() - startedAt
-		});
-		return executionResult.result;
-	} catch (error) {
-		process.exitCode = 1;
-		if (error instanceof CreateCancellationError) {
-			await trackCreateCancelled({
-				input,
-				context,
-				durationMs: Date.now() - startedAt,
-				stage: error.stage
-			});
-			return createCommandFailureResult(error.stage, error.message, context ? getProjectResult(context) : void 0);
-		}
-		const message = getErrorMessage(error);
-		cancel(`Create command failed: ${message}`, { output });
-		await trackCreateFailed({
-			input,
-			context,
-			durationMs: Date.now() - startedAt,
-			error,
-			stage: failureStage,
-			reason: getCreateFailureReason(error, failureReason)
-		});
-		return createCommandFailureResult(failureStage, message, context ? getProjectResult(context) : void 0);
-	}
-}
-async function collectCreateContext(input) {
-	const force = input.force === true;
-	const { output, useDefaults } = resolveExecutionSettings(input);
-	const projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName(output));
-	const projectName = String(projectNameInput).trim();
-	const projectNameValidationError = validateProjectName(projectName);
-	if (projectNameValidationError) {
-		cancel(projectNameValidationError, { output });
-		return {
-			ok: false,
-			message: projectNameValidationError,
-			reason: "invalid_project_name"
-		};
-	}
-	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate(output));
-	const targetDirectory = path.resolve(process.cwd(), projectName);
-	const targetPathState = await inspectTargetPath(targetDirectory);
-	if (targetPathState.exists && !targetPathState.isDirectory) {
-		const message = `Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`;
-		cancel(message, { output });
-		return {
-			ok: false,
-			message,
-			reason: "target_path_not_directory"
-		};
-	}
-	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
-		const message = `Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`;
-		cancel(message, { output });
-		return {
-			ok: false,
-			message,
-			reason: "target_directory_not_empty"
-		};
-	}
-	const prismaSetupContext = await collectPrismaSetupContext(input, {
-		projectDir: targetDirectory,
-		template
-	});
-	return {
-		ok: true,
-		context: {
-			targetDirectory,
-			targetPathState,
-			force,
-			template,
-			projectPackageName: toPackageName(path.basename(targetDirectory)),
-			prismaSetupContext
-		}
-	};
-}
-async function executeCreateContext(context) {
-	const output = context.prismaSetupContext.output;
-	const createSpinner = context.prismaSetupContext.verbose ? void 0 : spinner({ output });
-	createSpinner?.start("Creating Prisma 8 project...");
-	try {
-		if (context.prismaSetupContext.verbose) log.step(`Scaffolding ${context.template} starter.`, { output });
-		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.", { output });
-	} catch (error) {
-		createSpinner?.error("Could not create Prisma 8 project.");
-		return {
-			ok: false,
-			stage: "scaffold_template",
-			reason: "template_scaffold_failed",
-			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",
-			reason: "template_scaffold_failed",
-			error
-		};
-	}
-	const forceWarning = context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force ? `Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.` : void 0;
-	if (forceWarning) log.warn(forceWarning, { output });
-	const nextSteps = formatPathForDisplay(context.targetDirectory) === "." ? [] : [{
-		command: `cd ${formatPathForDisplay(context.targetDirectory)}`,
-		description: "Enter your new project directory."
-	}];
-	try {
-		const setupResult = await executePrismaSetupContext(context.prismaSetupContext, {
-			prependNextSteps: nextSteps,
-			projectDir: context.targetDirectory,
-			projectName: context.projectPackageName,
-			template: context.template,
-			createdProjectPath: context.targetDirectory,
-			includeDevNextStep: true,
-			initializeGit: !context.targetPathState.exists || context.targetPathState.isEmptyDirectory,
-			progressSpinner: createSpinner
-		});
-		if (!setupResult.ok) {
-			if (setupResult.cancelled) return {
-				ok: false,
-				cancelled: true,
-				stage: setupResult.stage,
-				errorReported: setupResult.errorReported
-			};
-			return {
-				ok: false,
-				stage: setupResult.stage,
-				reason: setupResult.reason,
-				error: setupResult.error,
-				errorReported: setupResult.errorReported
-			};
-		}
-		const warnings = [...setupResult.warnings];
-		if (forceWarning) warnings.unshift(forceWarning);
-		return {
-			ok: true,
-			result: {
-				schemaVersion: CREATE_PRISMA_RESULT_SCHEMA_VERSION,
-				ok: true,
-				project: getProjectResult(context),
-				deployment: setupResult.deployment,
-				nextSteps: setupResult.nextSteps,
-				warnings
-			}
-		};
-	} catch (error) {
-		createSpinner?.error("Could not create Prisma 8 project.");
-		return {
-			ok: false,
-			stage: "unknown",
-			reason: getCreateFailureReason(error, "unexpected_error"),
-			error
-		};
-	}
-}
-
-//#endregion
-export { DatabaseProviderSchema as a, createCommandFailureResult as c, CreateTemplateSchema as i, AuthoringStyleSchema as n, PackageManagerSchema as o, CreateCommandInputSchema as r, CREATE_PRISMA_RESULT_SCHEMA_VERSION as s, runCreateCommand as t };