create-prisma 0.10.0 → 0.11.0-pr.77.267.1

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as createCommandFailureResult } from "./create-BoFbgXIm.mjs";
+import { c as createCommandFailureResult } from "./create-CsgEDEx2.mjs";
 import { createCreatePrismaCli } from "./index.mjs";
 
 //#region src/ui/json-output.ts

package/dist/{create-BoFbgXIm.mjs → create-CsgEDEx2.mjs}

@@ -14,6 +14,28 @@ 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) {
@@ -30,21 +52,12 @@ function createCommandFailureResult(stage, message, project) {
 
 //#endregion
 //#region src/telemetry/client.ts
-const TELEMETRY_API_KEY = "phc_cmc85avbWyuJ2JyKdGPdv7dxXli8xLdWDBPbvIXWJfs";
+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 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;
+	return true;
 }
 function getTelemetryConfigDir() {
 	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "create-prisma");
@@ -66,7 +79,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.10.0",
+		"cli-version": "0.11.0-pr.77.267.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -106,6 +119,7 @@ async function trackCliTelemetry(event, properties) {
 //#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";
 function getTargetDirectoryState(context) {
 	if (!context.targetPathState.exists) return "new";
 	if (context.targetPathState.isEmptyDirectory) return "empty_directory";
@@ -113,6 +127,7 @@ function getTargetDirectoryState(context) {
 }
 function getBaseCreateProperties(input, context) {
 	return {
+		"telemetry-schema-version": 2,
 		command: "create",
 		"uses-defaults": input.yes === true || input.json === true,
 		json: input.json === true,
@@ -148,10 +163,18 @@ async function trackCreateFailed(params) {
 		...getBaseCreateProperties(params.input, params.context),
 		"duration-ms": params.durationMs,
 		"failure-stage": params.stage,
+		"failure-reason": params.reason,
 		"error-name": getErrorName(params.error),
 		"error-code": getErrorCode(params.error)
 	});
 }
+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
@@ -500,8 +523,8 @@ async function scaffoldCreateFrameworkTemplate(opts) {
 const dependencyVersionMap = {
 	"@astrojs/node": "^10.0.2",
 	"@elysiajs/node": "^1.4.5",
-	"@prisma/composer": "0.15.0",
-	"@prisma/composer-prisma-cloud": "0.15.0",
+	"@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",
@@ -514,11 +537,12 @@ const dependencyVersionMap = {
 	mongodb: "^7.1.0",
 	"mongodb-memory-server": "^11.1.0",
 	nitro: "^3.0.260610-beta",
-	prisma: "8.0.0-rc.11",
+	prisma: "8.0.0-rc.12",
+	"temporal-polyfill": "^1.0.4",
 	tsx: "^4.21.0",
 	typescript: "^5.9.3"
 };
-const PRISMA_PLATFORM_CLI_PACKAGE = "prisma@8.0.0-rc.11";
+const PRISMA_PLATFORM_CLI_PACKAGE = "prisma@8.0.0-rc.12";
 const PRISMA_DENO_CLI_PACKAGE = PRISMA_PLATFORM_CLI_PACKAGE;
 function getDependencyVersion(packageName) {
 	return dependencyVersionMap[packageName];
@@ -658,6 +682,7 @@ async function addPackageDependency(opts) {
 }
 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({
@@ -797,7 +822,7 @@ async function ensureProjectNameAvailable(options) {
 	})).items, options.appName);
 	if (collisions.length === 0) return;
 	const projectIds = collisions.map((project) => project.id).join(", ");
-	throw new Error(`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.`);
+	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({
@@ -812,7 +837,7 @@ async function ensureAuthentication(options) {
 		"auth",
 		"login"
 	]);
-	if (!options.allowInteractiveLogin || process.stdin.isTTY !== true) throw new Error(`Sign in first with ${loginCommand}, then run ${getRunScriptCommand(options.packageManager, "deploy")}.`);
+	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"]);
@@ -822,7 +847,7 @@ async function ensureAuthentication(options) {
 		stdio: "inherit"
 	});
 	const authenticatedState = await whoami();
-	if (!authenticatedState.authenticated) throw new Error("Prisma sign-in completed without an active workspace session.");
+	if (!authenticatedState.authenticated) throw new ClassifiedCreateError("authentication_failed", "Prisma sign-in completed without an active workspace session.");
 	return authenticatedState;
 }
 function workspaceLabel(workspace) {
@@ -842,19 +867,28 @@ async function useWorkspace(options) {
 }
 async function selectDeploymentWorkspace(options) {
 	const activeWorkspace = options.authState.workspace;
-	if (!activeWorkspace) throw new Error("The active Prisma credential does not specify a 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 activeWorkspace;
-			throw new Error(`The environment credential is fixed to workspace ${workspaceLabel(activeWorkspace)}. Unset it before using --workspace ${options.workspace}.`);
+			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 useWorkspace({
-			packageManager: options.packageManager,
-			projectDir: options.projectDir,
-			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 activeWorkspace;
+	if (!options.shouldPrompt || process.stdin.isTTY !== true) return {
+		ok: true,
+		workspace: activeWorkspace
+	};
 	const available = await runPrismaJsonCommand({
 		packageManager: options.packageManager,
 		projectDir: options.projectDir,
@@ -864,7 +898,10 @@ async function selectDeploymentWorkspace(options) {
 			"list"
 		]
 	});
-	if (available.items.length <= 1) return activeWorkspace;
+	if (available.items.length <= 1) return {
+		ok: true,
+		workspace: activeWorkspace
+	};
 	options.beforePrompt?.();
 	const selectedWorkspaceId = await select({
 		message: "Select Prisma workspace for deployment",
@@ -878,15 +915,24 @@ async function selectDeploymentWorkspace(options) {
 	});
 	if (isCancel(selectedWorkspaceId)) {
 		cancel("Operation cancelled.", { output: options.output });
-		return;
+		return {
+			ok: false,
+			cancelled: true
+		};
 	}
 	options.afterPrompt?.();
-	if (selectedWorkspaceId === activeWorkspace.id) return activeWorkspace;
-	return useWorkspace({
-		packageManager: options.packageManager,
-		projectDir: options.projectDir,
-		workspace: selectedWorkspaceId
-	});
+	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;
@@ -931,6 +977,8 @@ async function deployNewProjectWithComposer(options) {
 	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);
@@ -955,8 +1003,10 @@ async function deployNewProjectWithComposer(options) {
 			beforeInteractiveLogin: clearProgress
 		});
 		showProgress("Checking Prisma workspace...");
+		failureStage = "select_workspace";
+		failureReason = "workspace_selection_failed";
 		if (options.verbose) log.step("Checking Prisma workspace.", { output });
-		const selectedWorkspace = await selectDeploymentWorkspace({
+		const workspaceResult = await selectDeploymentWorkspace({
 			packageManager: options.packageManager,
 			projectDir: options.projectDir,
 			shouldPrompt: options.shouldPromptForWorkspace,
@@ -966,8 +1016,15 @@ async function deployNewProjectWithComposer(options) {
 			afterPrompt: () => showProgress("Selecting Prisma workspace..."),
 			...options.workspace ? { workspace: options.workspace } : {}
 		});
-		if (!selectedWorkspace) return;
+		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,
@@ -976,6 +1033,8 @@ async function deployNewProjectWithComposer(options) {
 			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({
@@ -987,6 +1046,8 @@ async function deployNewProjectWithComposer(options) {
 			json: options.json === true
 		});
 		clearProgress();
+		failureStage = "composer_deploy";
+		failureReason = "composer_deploy_failed";
 		const deployCommand = getPackageExecutionCommand(options.packageManager, [
 			PRISMA_PLATFORM_CLI_PACKAGE,
 			"deploy",
@@ -1025,11 +1086,14 @@ async function deployNewProjectWithComposer(options) {
 		if (options.verbose) log.success("Deployed to Prisma.", { output });
 		const workspace = details?.workspace ?? selectedWorkspace;
 		return {
-			appName,
-			...deployment?.appUrl ? { appUrl: deployment.appUrl } : {},
-			...deployment?.serviceId ? { serviceId: deployment.serviceId } : {},
-			...workspace ? { workspace } : {},
-			project: details?.project ?? { name: appName }
+			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) {
@@ -1038,8 +1102,12 @@ async function deployNewProjectWithComposer(options) {
 		} else progress?.error("Deployment failed.");
 		progressRunning = false;
 		log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
-		if (options.throwOnError) throw error;
-		return;
+		return {
+			ok: false,
+			stage: failureStage,
+			reason: getCreateFailureReason(error, failureReason),
+			error
+		};
 	}
 }
 
@@ -1121,7 +1189,7 @@ async function promptForDatabaseProvider(output) {
 	});
 	if (isCancel(databaseProvider)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("database_provider");
 	}
 	return DatabaseProviderSchema.parse(databaseProvider);
 }
@@ -1142,7 +1210,7 @@ async function promptForAuthoringStyle(output) {
 	});
 	if (isCancel(authoring)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("authoring_style");
 	}
 	return AuthoringStyleSchema.parse(authoring);
 }
@@ -1169,7 +1237,7 @@ async function promptForPackageManager(detected, output) {
 	});
 	if (isCancel(packageManager)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("package_manager");
 	}
 	return PackageManagerSchema.parse(packageManager);
 }
@@ -1181,7 +1249,7 @@ async function promptForDeployment(output) {
 	});
 	if (isCancel(shouldDeploy)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("deployment_intent");
 	}
 	return Boolean(shouldDeploy);
 }
@@ -1189,17 +1257,13 @@ 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));
-	if (!databaseProvider) return;
 	const authoring = input.authoring ?? (useDefaults ? DEFAULT_AUTHORING : await promptForAuthoringStyle(output));
-	if (!authoring) return;
 	const detectedPackageManager = await detectPackageManager(projectDir);
 	const packageManager = input.packageManager ?? (useDefaults ? detectedPackageManager : await promptForPackageManager(detectedPackageManager, output));
-	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.");
+	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));
-	if (shouldDeploy === void 0) return;
 	return {
 		projectDir,
 		verbose: input.verbose === true,
@@ -1362,10 +1426,14 @@ async function executePrismaSetupContext(context, options = {}) {
 	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,
@@ -1382,20 +1450,30 @@ async function executePrismaSetupContext(context, options = {}) {
 			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.");
@@ -1406,13 +1484,15 @@ async function executePrismaSetupContext(context, options = {}) {
 		cancel(getErrorMessage(error), { output: context.output });
 		return {
 			ok: false,
+			stage: setupStage,
+			reason: getCreateFailureReason(error, setupReason),
 			error,
 			errorReported: true
 		};
 	}
 	let deployment;
 	if (context.shouldDeploy) {
-		deployment = await deployNewProjectWithComposer({
+		const deploymentResult = await deployNewProjectWithComposer({
 			appName: projectName,
 			packageManager: context.packageManager,
 			projectDir,
@@ -1421,13 +1501,24 @@ async function executePrismaSetupContext(context, options = {}) {
 			output: context.output,
 			allowInteractiveLogin: !context.json,
 			json: context.json,
-			throwOnError: context.json,
 			...context.workspace ? { workspace: context.workspace } : {}
 		});
-		if (!deployment) return {
-			ok: false,
-			errorReported: true
-		};
+		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}`] : [];
@@ -1469,7 +1560,7 @@ function parseVersion(version) {
 		Number.parseInt(patch, 10)
 	];
 }
-function supportsPrismaNext(nodeVersion = process.versions.node) {
+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;
@@ -1521,7 +1612,7 @@ async function promptForProjectName(output) {
 	});
 	if (isCancel(projectName)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("project_name");
 	}
 	return String(projectName).trim();
 }
@@ -1580,7 +1671,7 @@ async function promptForCreateTemplate(output) {
 	});
 	if (isCancel(template)) {
 		cancel("Operation cancelled.", { output });
-		return;
+		throw new CreateCancellationError("template");
 	}
 	return CreateTemplateSchema.parse(template);
 }
@@ -1606,18 +1697,26 @@ async function runCreateCommand(rawInput = {}) {
 	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 (!supportsPrismaNext()) {
+		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;
@@ -1625,7 +1724,8 @@ async function runCreateCommand(rawInput = {}) {
 			await trackCreateFailed({
 				input,
 				durationMs: Date.now() - startedAt,
-				stage: failureStage
+				stage: failureStage,
+				reason: collected.reason
 			});
 			return result;
 		}
@@ -1634,6 +1734,15 @@ async function runCreateCommand(rawInput = {}) {
 		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({
@@ -1641,7 +1750,8 @@ async function runCreateCommand(rawInput = {}) {
 				context,
 				durationMs: Date.now() - startedAt,
 				error: executionResult.error,
-				stage: executionResult.stage
+				stage: executionResult.stage,
+				reason: executionResult.reason
 			});
 			return createCommandFailureResult(executionResult.stage, message, getProjectResult(context));
 		}
@@ -1653,6 +1763,15 @@ async function runCreateCommand(rawInput = {}) {
 		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(failureStage, error.message, context ? getProjectResult(context) : void 0);
+		}
 		const message = getErrorMessage(error);
 		cancel(`Create command failed: ${message}`, { output });
 		await trackCreateFailed({
@@ -1660,7 +1779,8 @@ async function runCreateCommand(rawInput = {}) {
 			context,
 			durationMs: Date.now() - startedAt,
 			error,
-			stage: failureStage
+			stage: failureStage,
+			reason: getCreateFailureReason(error, failureReason)
 		});
 		return createCommandFailureResult(failureStage, message, context ? getProjectResult(context) : void 0);
 	}
@@ -1669,24 +1789,17 @@ 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));
-	if (projectNameInput === void 0) return {
-		ok: false,
-		message: "Operation cancelled."
-	};
 	const projectName = String(projectNameInput).trim();
 	const projectNameValidationError = validateProjectName(projectName);
 	if (projectNameValidationError) {
 		cancel(projectNameValidationError, { output });
 		return {
 			ok: false,
-			message: projectNameValidationError
+			message: projectNameValidationError,
+			reason: "invalid_project_name"
 		};
 	}
 	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate(output));
-	if (!template) return {
-		ok: false,
-		message: "Operation cancelled."
-	};
 	const targetDirectory = path.resolve(process.cwd(), projectName);
 	const targetPathState = await inspectTargetPath(targetDirectory);
 	if (targetPathState.exists && !targetPathState.isDirectory) {
@@ -1694,7 +1807,8 @@ async function collectCreateContext(input) {
 		cancel(message, { output });
 		return {
 			ok: false,
-			message
+			message,
+			reason: "target_path_not_directory"
 		};
 	}
 	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
@@ -1702,17 +1816,14 @@ async function collectCreateContext(input) {
 		cancel(message, { output });
 		return {
 			ok: false,
-			message
+			message,
+			reason: "target_directory_not_empty"
 		};
 	}
 	const prismaSetupContext = await collectPrismaSetupContext(input, {
 		projectDir: targetDirectory,
 		template
 	});
-	if (!prismaSetupContext) return {
-		ok: false,
-		message: "Operation cancelled."
-	};
 	return {
 		ok: true,
 		context: {
@@ -1745,6 +1856,7 @@ async function executeCreateContext(context) {
 		return {
 			ok: false,
 			stage: "scaffold_template",
+			reason: "template_scaffold_failed",
 			error
 		};
 	}
@@ -1759,6 +1871,7 @@ async function executeCreateContext(context) {
 		return {
 			ok: false,
 			stage: "scaffold_template",
+			reason: "template_scaffold_failed",
 			error
 		};
 	}
@@ -1779,12 +1892,21 @@ async function executeCreateContext(context) {
 			initializeGit: !context.targetPathState.exists || context.targetPathState.isEmptyDirectory,
 			progressSpinner: createSpinner
 		});
-		if (!setupResult.ok) return {
-			ok: false,
-			stage: "prisma_setup",
-			error: setupResult.error,
-			errorReported: setupResult.errorReported
-		};
+		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 {
@@ -1802,7 +1924,8 @@ async function executeCreateContext(context) {
 		createSpinner?.error("Could not create Prisma 8 project.");
 		return {
 			ok: false,
-			stage: "prisma_setup",
+			stage: "unknown",
+			reason: getCreateFailureReason(error, "unexpected_error"),
 			error
 		};
 	}

package/dist/index.d.mts

@@ -2,9 +2,11 @@
 import * as _orpc_server0 from "@orpc/server";
 import * as trpc_cli0 from "trpc-cli";
 import { z } from "zod";
-import { spinner } from "@clack/prompts";
 import { Writable } from "node:stream";
 
+//#region src/create-outcome.d.ts
+type CreateFailureStage = "validate_input" | "collect_context" | "scaffold_template" | "initialize_prisma" | "configure_project" | "install_dependencies" | "initialize_agent_skills" | "emit_contract" | "plan_migration" | "initialize_git" | "authenticate" | "select_workspace" | "check_project_name" | "build" | "composer_deploy" | "unknown";
+//#endregion
 //#region src/types.d.ts
 declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
   postgres: "postgres";
@@ -94,9 +96,6 @@ type ComposerDeployResult = {
   };
 };
 //#endregion
-//#region src/telemetry/create.d.ts
-type CreateTelemetryFailureStage = "validate_input" | "collect_context" | "scaffold_template" | "prisma_setup" | "unknown";
-//#endregion
 //#region src/result.d.ts
 declare const CREATE_PRISMA_RESULT_SCHEMA_VERSION: 1;
 type CreateNextStep = {
@@ -111,7 +110,7 @@ type CreateProjectResult = {
   authoring: AuthoringStyle;
   packageManager: PackageManager;
 };
-type CreateCommandFailureStage = CreateTelemetryFailureStage | "parse_arguments";
+type CreateCommandFailureStage = CreateFailureStage | "parse_arguments";
 type CreateCommandSuccessResult = {
   schemaVersion: typeof CREATE_PRISMA_RESULT_SCHEMA_VERSION;
   ok: true;

package/dist/index.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as runCreateCommand } from "./create-BoFbgXIm.mjs";
+import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as runCreateCommand } from "./create-CsgEDEx2.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 import { z } from "zod";
 
 //#region src/index.ts
-const CLI_VERSION = "0.10.0";
+const CLI_VERSION = "0.11.0-pr.77.267.1";
 const CreateCliInputSchema = z.tuple([z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"), CreateCommandInputSchema]);
 function normalizeCreateCliInput(input) {
 	const [projectName, options] = input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.10.0",
+  "version": "0.11.0-pr.77.267.1",
   "private": false,
   "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",

package/templates/create/_shared/module.ts.hbs

@@ -1,7 +1,7 @@
 {{#unless (eq packageManager "deno")}}
 import { module } from "@prisma/composer";
 {{#if (eq provider "postgres")}}
-import { pnPostgres } from "@prisma/composer-prisma-cloud/prisma-next";
+import { postgres } from "@prisma/composer-prisma-cloud/orm";
 
 import { appContract } from "./src/prisma/composer.ts";
 {{else}}
@@ -12,7 +12,7 @@ import app from "./service.ts";
 export default module("{{projectName}}", ({ provision }) => {
 {{#if (eq provider "postgres")}}
   const database = provision(
-    pnPostgres({
+    postgres({
       name: "database",
       contract: appContract,
       config: "./prisma.config.ts",

package/templates/create/_shared/service.ts.hbs

@@ -10,7 +10,7 @@ import { type } from "arktype";
 {{/if}}
 import { compute } from "@prisma/composer-prisma-cloud";
 {{#if (eq provider "postgres")}}
-import { pnPostgres } from "@prisma/composer-prisma-cloud/prisma-next";
+import { postgres } from "@prisma/composer-prisma-cloud/orm";
 
 import { appContract } from "./src/prisma/composer.ts";
 {{/if}}
@@ -19,7 +19,7 @@ export default compute({
   name: "app",
   deps: {
 {{#if (eq provider "postgres")}}
-    database: pnPostgres(appContract),
+    database: postgres(appContract),
 {{/if}}
   },
 {{#if (eq provider "mongo")}}

package/templates/create/_shared/src/prisma/composer.ts.hbs

@@ -1,10 +1,10 @@
 {{#unless (eq packageManager "deno")}}
 {{#if (eq provider "postgres")}}
-import { pnContract } from "@prisma/composer-prisma-cloud/prisma-next";
+import { dataContract } from "@prisma/composer-prisma-cloud/orm";
 
 import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
 import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };
 
-export const appContract = pnContract<Contract>(contractJson);
+export const appContract = dataContract<Contract>(contractJson);
 {{/if}}
 {{/unless}}

package/templates/create/_shared/src/prisma/db.ts.hbs

@@ -12,6 +12,8 @@ if (!databaseUrl) {
 
 export const db = postgres<Contract>({ contractJson, url: databaseUrl });
 {{else}}
+import "temporal-polyfill/global";
+
 import service from "../../service.ts";
 import type { Contract } from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.d.ts";
 import contractJson from "./{{#if (eq authoring "typescript")}}generated/{{/if}}contract.json" with { type: "json" };