create-prisma 0.9.5 → 0.10.0-pr.72.261.1

package/README.md

@@ -63,6 +63,22 @@ older cached version. Prisma Compute does not support Deno deployments yet.
 - `--yes`
 - `--force`
 - `--verbose`
+- `--json`
+
+### JSON output for agents and automation
+
+Use `--json` when another program is driving `create-prisma`:
+
+```bash
+bunx create-prisma@latest my-app --template next --package-manager bun --no-deploy --json
+```
+
+JSON mode is non-interactive and deploys by default; pass `--no-deploy` to generate locally only. It
+writes exactly one compact result object to stdout and suppresses all human UI and subprocess output.
+Successful results include the generated project, deployment metadata, next steps, and warnings.
+Errors use the same envelope with `ok: false`, an actionable message, and the stage that failed.
+`--verbose` is intentionally incompatible with `--json` so the machine-readable contract stays
+deterministic.
 
 This branch intentionally targets Prisma 8 only. It does not generate a Prisma 7 compatibility path.
 

package/dist/cli.mjs

@@ -1,12 +1,63 @@
 #!/usr/bin/env node
-import "./create-C2fGwZxV.mjs";
+import { c as createCommandFailureResult } from "./create-JgaDOyzC.mjs";
 import { createCreatePrismaCli } from "./index.mjs";
 
+//#region src/ui/json-output.ts
+function isCreateCommandResult(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return Reflect.get(value, "schemaVersion") === 1 && typeof Reflect.get(value, "ok") === "boolean";
+}
+function formatLoggerMessage(values) {
+	return values.map((value) => {
+		if (value instanceof Error) return value.message;
+		if (typeof value === "string") return value.trim();
+		try {
+			return JSON.stringify(value);
+		} catch {
+			return String(value);
+		}
+	}).filter(Boolean).join(" ");
+}
+function isJsonOutputRequested(argv) {
+	let requested = false;
+	for (const [index, argument] of argv.entries()) {
+		if (argument === "--json") requested = argv[index + 1]?.toLowerCase() !== "false";
+		if (argument.startsWith("--json=")) requested = argument.slice(7).toLowerCase() !== "false";
+		if (argument === "--no-json") requested = false;
+	}
+	return requested;
+}
+function createJsonOutputLogger(write = (output) => process.stdout.write(output)) {
+	let didWrite = false;
+	const writeResult = (result) => {
+		if (didWrite) return;
+		didWrite = true;
+		write(`${JSON.stringify(result)}\n`);
+	};
+	return {
+		info(...values) {
+			const result = values.length === 1 ? values[0] : void 0;
+			if (isCreateCommandResult(result)) {
+				writeResult(result);
+				return;
+			}
+			writeResult(createCommandFailureResult("parse_arguments", formatLoggerMessage(values) || "The CLI returned an unexpected result."));
+		},
+		error(...values) {
+			writeResult(createCommandFailureResult("parse_arguments", formatLoggerMessage(values) || "Could not parse command arguments."));
+		}
+	};
+}
+
+//#endregion
 //#region src/cli.ts
-createCreatePrismaCli().run({ process: { exit(code) {
-	const commandExitCode = typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : code;
-	process.exit(commandExitCode);
-} } });
+createCreatePrismaCli().run({
+	...isJsonOutputRequested(process.argv) ? { logger: createJsonOutputLogger() } : {},
+	process: { exit(code) {
+		const commandExitCode = typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : code;
+		process.exit(commandExitCode);
+	} }
+});
 
 //#endregion
 export {  };

package/dist/{create-C2fGwZxV.mjs → create-JgaDOyzC.mjs}

@@ -10,25 +10,32 @@ 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/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_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");
@@ -50,7 +57,7 @@ async function getAnonymousId() {
 }
 function getCommonProperties() {
 	return {
-		"cli-version": "0.9.5",
+		"cli-version": "0.10.0-pr.72.261.1",
 		"node-version": process.version,
 		platform: process.platform,
 		arch: process.arch
@@ -98,7 +105,8 @@ function getTargetDirectoryState(context) {
 function getBaseCreateProperties(input, context) {
 	return {
 		command: "create",
-		"uses-defaults": input.yes === true,
+		"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,
@@ -174,7 +182,8 @@ 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")
+	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"),
@@ -482,8 +491,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",
@@ -496,11 +505,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];
@@ -541,6 +551,21 @@ function getDbPackages(provider) {
 	}
 }
 
+//#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) {
@@ -625,6 +650,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({
@@ -661,22 +687,46 @@ async function writeCreateTemplateDependencies(opts) {
 async function installProjectDependencies(packageManager, projectDir = process.cwd(), options = {}) {
 	const installCommand = getInstallArgs(packageManager);
 	const env = packageManager === "yarn" ? { YARN_ENABLE_IMMUTABLE_INSTALLS: "false" } : void 0;
-	await execa(installCommand.command, installCommand.args, {
+	await runSetupCommand({
+		command: installCommand.command,
+		args: installCommand.args,
 		cwd: projectDir,
 		env,
-		stdio: options.verbose === true ? "inherit" : "pipe"
+		verbose: options.verbose === true,
+		json: options.json === true
 	});
 }
 
 //#endregion
-//#region src/tasks/deploy-with-composer.ts
+//#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) return redactSecrets(error.message);
-	return redactSecrets(String(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
 function stripResourcePrefix(id, prefix) {
 	const marker = `${prefix}_`;
 	return id.startsWith(marker) ? id.slice(marker.length) : id;
@@ -742,25 +792,25 @@ async function ensureProjectNameAvailable(options) {
 	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.`);
 }
-async function ensureAuthentication(packageManager, projectDir, beforeInteractiveLogin) {
+async function ensureAuthentication(options) {
 	const whoami = () => runPrismaJsonCommand({
-		packageManager,
-		projectDir,
+		packageManager: options.packageManager,
+		projectDir: options.projectDir,
 		args: ["auth", "whoami"]
 	});
 	const authState = await whoami();
 	if (authState.authenticated) return authState;
-	const loginCommand = getPackageExecutionCommand(packageManager, [
+	const loginCommand = getPackageExecutionCommand(options.packageManager, [
 		PRISMA_PLATFORM_CLI_PACKAGE,
 		"auth",
 		"login"
 	]);
-	if (process.stdin.isTTY !== true) throw new Error(`Sign in first with ${loginCommand}, then run ${getRunScriptCommand(packageManager, "deploy")}.`);
-	beforeInteractiveLogin?.();
-	log.info("Sign in to Prisma to deploy.");
-	const login = getPrismaCliArgs(packageManager, ["auth", "login"]);
+	if (!options.allowInteractiveLogin || process.stdin.isTTY !== true) throw new Error(`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: projectDir,
+		cwd: options.projectDir,
 		env: process.env,
 		stdio: "inherit"
 	});
@@ -816,10 +866,11 @@ async function selectDeploymentWorkspace(options) {
 			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.");
+		cancel("Operation cancelled.", { output: options.output });
 		return;
 	}
 	options.afterPrompt?.();
@@ -836,6 +887,7 @@ function parseComposerDeployResult(result) {
 	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(/\/$/, "") } : {}
 	};
 }
@@ -868,7 +920,8 @@ async function getProjectDetails(options) {
 * Generated projects use their own `deploy` script for every subsequent deployment.
 */
 async function deployNewProjectWithComposer(options) {
-	const progress = options.verbose ? void 0 : spinner();
+	const output = options.output ?? process.stdout;
+	const progress = options.verbose ? void 0 : spinner({ output });
 	let deploymentLog;
 	let progressRunning = false;
 	const showProgress = (message) => {
@@ -886,22 +939,29 @@ async function deployNewProjectWithComposer(options) {
 	};
 	try {
 		showProgress("Checking Prisma account...");
-		if (options.verbose) log.step("Checking Prisma account.");
-		const authState = await ensureAuthentication(options.packageManager, options.projectDir, clearProgress);
+		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...");
-		if (options.verbose) log.step("Checking Prisma workspace.");
+		if (options.verbose) log.step("Checking Prisma workspace.", { output });
 		const selectedWorkspace = 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 (!selectedWorkspace) return;
 		showProgress("Checking Prisma project name...");
-		if (options.verbose) log.step("Checking Prisma project name.");
+		if (options.verbose) log.step("Checking Prisma project name.", { output });
 		await ensureProjectNameAvailable({
 			appName: options.appName,
 			packageManager: options.packageManager,
@@ -909,12 +969,15 @@ async function deployNewProjectWithComposer(options) {
 			workspace: selectedWorkspace
 		});
 		showProgress("Building for deployment...");
-		if (options.verbose) log.step("Building for deployment.");
+		if (options.verbose) log.step("Building for deployment.", { output });
 		const build = getRunScriptArgs(options.packageManager, "build");
-		await execa(build.command, build.args, {
+		await runSetupCommand({
+			command: build.command,
+			args: build.args,
 			cwd: options.projectDir,
 			env: process.env,
-			stdio: options.verbose ? "inherit" : "pipe"
+			verbose: options.verbose,
+			json: options.json === true
 		});
 		clearProgress();
 		const deployCommand = getPackageExecutionCommand(options.packageManager, [
@@ -922,11 +985,12 @@ async function deployNewProjectWithComposer(options) {
 			"deploy",
 			"module.ts"
 		]);
-		if (options.verbose) log.step(`Deploying to Prisma with ${deployCommand}.`);
+		if (options.verbose) log.step(`Deploying to Prisma with ${deployCommand}.`, { output });
 		else {
 			deploymentLog = taskLog({
 				title: "Deploying to Prisma...",
-				limit: 10
+				limit: 10,
+				output
 			});
 			deploymentLog.message(`$ ${deployCommand}`);
 		}
@@ -936,12 +1000,12 @@ async function deployNewProjectWithComposer(options) {
 			args: ["deploy", "module.ts"],
 			onStderrLine: (line) => {
 				const redactedLine = redactSecrets(line);
-				if (options.verbose) process.stderr.write(`${redactedLine}\n`);
+				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.");
+		if (options.verbose) log.step("Loading deployment details.", { output });
 		else deploymentLog?.message("Loading deployment details...");
 		const details = await getProjectDetails({
 			packageManager: options.packageManager,
@@ -951,11 +1015,12 @@ async function deployNewProjectWithComposer(options) {
 		deploymentLog?.success("Deployed to Prisma.");
 		deploymentLog = void 0;
 		progressRunning = false;
-		if (options.verbose) log.success("Deployed to Prisma.");
+		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 }
 		};
@@ -965,7 +1030,8 @@ async function deployNewProjectWithComposer(options) {
 			deploymentLog = void 0;
 		} else progress?.error("Deployment failed.");
 		progressRunning = false;
-		log.error(`Deploy failed: ${getErrorMessage(error)}`);
+		log.error(`Deploy failed: ${getErrorMessage(error)}`, { output });
+		if (options.throwOnError) throw error;
 		return;
 	}
 }
@@ -1031,7 +1097,7 @@ async function initializeGitRepository(projectDir, env = process.env) {
 //#region src/tasks/setup-prisma.ts
 const DEFAULT_DATABASE_PROVIDER = "postgres";
 const DEFAULT_AUTHORING = "psl";
-async function promptForDatabaseProvider() {
+async function promptForDatabaseProvider(output) {
 	const databaseProvider = await select({
 		message: "Select your database",
 		initialValue: DEFAULT_DATABASE_PROVIDER,
@@ -1043,15 +1109,16 @@ async function promptForDatabaseProvider() {
 			value: "mongo",
 			label: "MongoDB",
 			hint: "Connect an existing MongoDB database"
-		}]
+		}],
+		output
 	});
 	if (isCancel(databaseProvider)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return DatabaseProviderSchema.parse(databaseProvider);
 }
-async function promptForAuthoringStyle() {
+async function promptForAuthoringStyle(output) {
 	const authoring = await select({
 		message: "Choose contract authoring style",
 		initialValue: DEFAULT_AUTHORING,
@@ -1063,10 +1130,11 @@ async function promptForAuthoringStyle() {
 			value: "typescript",
 			label: "TypeScript",
 			hint: "TypeScript contract builder"
-		}]
+		}],
+		output
 	});
 	if (isCancel(authoring)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return AuthoringStyleSchema.parse(authoring);
@@ -1081,7 +1149,7 @@ function getPackageManagerHint(option, detected) {
 	};
 	return option === detected ? `Detected; ${hints[option]}` : hints[option];
 }
-async function promptForPackageManager(detected) {
+async function promptForPackageManager(detected, output) {
 	const packageManager = await select({
 		message: "Choose package manager",
 		initialValue: detected,
@@ -1089,43 +1157,47 @@ async function promptForPackageManager(detected) {
 			value,
 			label: value,
 			hint: getPackageManagerHint(value, detected)
-		}))
+		})),
+		output
 	});
 	if (isCancel(packageManager)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return PackageManagerSchema.parse(packageManager);
 }
-async function promptForDeployment() {
+async function promptForDeployment(output) {
 	const shouldDeploy = await confirm({
 		message: "Deploy to Prisma now?",
-		initialValue: true
+		initialValue: true,
+		output
 	});
 	if (isCancel(shouldDeploy)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return Boolean(shouldDeploy);
 }
 async function collectPrismaSetupContext(input, options = {}) {
 	const projectDir = path.resolve(options.projectDir ?? process.cwd());
-	const useDefaults = input.yes === true;
-	const databaseProvider = input.provider ?? (useDefaults ? DEFAULT_DATABASE_PROVIDER : await promptForDatabaseProvider());
+	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());
+	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));
+	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.");
-	const shouldDeploy = packageManager === "deno" ? false : input.deploy ?? (useDefaults ? false : await promptForDeployment());
+	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,
+		json,
+		output,
 		databaseProvider,
 		authoring,
 		packageManager,
@@ -1134,13 +1206,6 @@ async function collectPrismaSetupContext(input, options = {}) {
 		...input.workspace ? { workspace: input.workspace } : {}
 	};
 }
-function getCommandErrorMessage(error) {
-	if (error instanceof Error && "stderr" in error) {
-		const stderr = String(error.stderr ?? "").trim();
-		if (stderr) return stderr;
-	}
-	return error instanceof Error ? error.message : String(error);
-}
 function getContractPath(authoring) {
 	return `src/prisma/contract${authoring === "typescript" ? ".ts" : ".prisma"}`;
 }
@@ -1165,14 +1230,17 @@ async function runPrismaInit(context, projectDir) {
 		"--skip-install"
 	];
 	const invocation = getPrismaCliInvocation(context.packageManager, args);
-	if (context.verbose) log.step(`Running ${[invocation.command, ...invocation.args].join(" ")}`);
-	await execa(invocation.command, invocation.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,
-		stdio: context.verbose ? "inherit" : "pipe",
 		env: {
 			...process.env,
 			CI: "1"
-		}
+		},
+		verbose: context.verbose,
+		json: context.json
 	});
 	if (context.packageManager === "deno") await fs.remove(path.join(projectDir, "prisma-next.md"));
 }
@@ -1183,14 +1251,17 @@ async function initializeAgentSkills(context, projectDir) {
 		"--yes",
 		"--no-interactive"
 	]);
-	if (context.verbose) log.step(`Running ${[invocation.command, ...invocation.args].join(" ")}`);
-	await execa(invocation.command, invocation.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,
-		stdio: context.verbose ? "inherit" : "pipe",
 		env: {
 			...process.env,
 			CI: "1"
-		}
+		},
+		verbose: context.verbose,
+		json: context.json
 	});
 }
 async function ensureGitignoreEntry(projectDir, entry) {
@@ -1219,14 +1290,17 @@ async function ensureComposerTypeScriptOptions(projectDir) {
 }
 async function runPrismaCli(context, projectDir, args) {
 	const invocation = getPrismaCliInvocation(context.packageManager, args);
-	if (context.verbose) log.step([invocation.command, ...invocation.args].join(" "));
-	await execa(invocation.command, invocation.args, {
+	if (context.verbose) log.step([invocation.command, ...invocation.args].join(" "), { output: context.output });
+	await runSetupCommand({
+		command: invocation.command,
+		args: invocation.args,
 		cwd: projectDir,
-		stdio: context.verbose ? "inherit" : "pipe",
 		env: {
 			...process.env,
 			CI: "1"
-		}
+		},
+		verbose: context.verbose,
+		json: context.json
 	});
 }
 async function emitContract(context, projectDir) {
@@ -1278,7 +1352,7 @@ 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();
+	const progress = context.verbose ? void 0 : options.progressSpinner ?? spinner({ output: context.output });
 	const ownsProgress = progress !== void 0 && !options.progressSpinner;
 	let gitInitialization;
 	if (ownsProgress) progress.start("Creating Prisma 8 project...");
@@ -1301,7 +1375,10 @@ async function executePrismaSetupContext(context, options = {}) {
 			await ensureGitignoreEntry(projectDir, "/.prisma-composer");
 		}
 		progress?.message(`Installing dependencies with ${getInstallCommand(context.packageManager)}...`);
-		await installProjectDependencies(context.packageManager, projectDir, { verbose: context.verbose });
+		await installProjectDependencies(context.packageManager, projectDir, {
+			verbose: context.verbose,
+			json: context.json
+		});
 		progress?.message("Installing Prisma agent skills...");
 		await initializeAgentSkills(context, projectDir);
 		progress?.message("Generating Prisma 8 contract artifacts...");
@@ -1315,12 +1392,16 @@ async function executePrismaSetupContext(context, options = {}) {
 			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.");
-		else if (gitInitialization?.status === "skipped") log.warn(`Could not initialize Git repository: ${gitInitialization.reason}`);
+		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(getCommandErrorMessage(error));
-		return false;
+		cancel(getErrorMessage(error), { output: context.output });
+		return {
+			ok: false,
+			error,
+			errorReported: true
+		};
 	}
 	let deployment;
 	if (context.shouldDeploy) {
@@ -1330,18 +1411,33 @@ async function executePrismaSetupContext(context, options = {}) {
 			projectDir,
 			shouldPromptForWorkspace: context.shouldPromptForWorkspace,
 			verbose: context.verbose,
+			output: context.output,
+			allowInteractiveLogin: !context.json,
+			json: context.json,
+			throwOnError: context.json,
 			...context.workspace ? { workspace: context.workspace } : {}
 		});
-		if (!deployment) return false;
+		if (!deployment) return {
+			ok: false,
+			errorReported: true
+		};
 	}
+	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");
-	note(formatNextSteps(buildNextSteps(context, options)), "Next steps");
-	outro(context.shouldDeploy ? "Prisma 8 app deployed." : "Prisma 8 project ready.");
-	return true;
+	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
@@ -1366,7 +1462,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;
@@ -1398,20 +1494,31 @@ function validateProjectName(value) {
 	if (trimmed === "..") return "Project name cannot be '..'.";
 	if (path.isAbsolute(trimmed)) return "Use a relative project name instead of an absolute path.";
 }
-async function promptForProjectName() {
+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
+		validate: validateProjectName,
+		output
 	});
 	if (isCancel(projectName)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return String(projectName).trim();
 }
-async function promptForCreateTemplate() {
+async function promptForCreateTemplate(output) {
 	const template = await select({
 		message: "Select template",
 		initialValue: DEFAULT_TEMPLATE,
@@ -1461,10 +1568,11 @@ async function promptForCreateTemplate() {
 				label: "TanStack Start",
 				hint: "React app with file routes and server functions"
 			}
-		]
+		],
+		output
 	});
 	if (isCancel(template)) {
-		cancel("Operation cancelled.");
+		cancel("Operation cancelled.", { output });
 		return;
 	}
 	return CreateTemplateSchema.parse(template);
@@ -1491,22 +1599,36 @@ async function runCreateCommand(rawInput = {}) {
 	let input = {};
 	let context;
 	let failureStage = "validate_input";
+	const { output } = resolveExecutionSettings(rawInput);
 	try {
 		input = CreateCommandInputSchema.parse(rawInput);
-		if (!supportsPrismaNext()) {
-			cancel(getUnsupportedNodeMessage());
+		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;
-			return;
+			return createCommandFailureResult(failureStage, message);
 		}
-		intro(getCreatePrismaIntro());
+		intro(getCreatePrismaIntro(), { output });
 		failureStage = "collect_context";
-		context = await collectCreateContext(input);
-		if (!context) return;
+		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
+			});
+			return result;
+		}
+		context = collected.context;
 		failureStage = "unknown";
 		const executionResult = await executeCreateContext(context);
 		if (!executionResult.ok) {
 			process.exitCode = 1;
-			if (executionResult.error) cancel(`Create command failed: ${executionResult.error instanceof Error ? executionResult.error.message : String(executionResult.error)}`);
+			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,
@@ -1514,16 +1636,18 @@ async function runCreateCommand(rawInput = {}) {
 				error: executionResult.error,
 				stage: executionResult.stage
 			});
-			return;
+			return createCommandFailureResult(executionResult.stage, message, getProjectResult(context));
 		}
 		await trackCreateCompleted({
 			input,
 			context,
 			durationMs: Date.now() - startedAt
 		});
+		return executionResult.result;
 	} catch (error) {
 		process.exitCode = 1;
-		cancel(`Create command failed: ${error instanceof Error ? error.message : String(error)}`);
+		const message = getErrorMessage(error);
+		cancel(`Create command failed: ${message}`, { output });
 		await trackCreateFailed({
 			input,
 			context,
@@ -1531,50 +1655,75 @@ async function runCreateCommand(rawInput = {}) {
 			error,
 			stage: failureStage
 		});
+		return createCommandFailureResult(failureStage, message, context ? getProjectResult(context) : void 0);
 	}
 }
 async function collectCreateContext(input) {
 	const force = input.force === true;
-	const useDefaults = input.yes === true;
-	const projectNameInput = input.name ?? (useDefaults ? DEFAULT_PROJECT_NAME : await promptForProjectName());
-	if (projectNameInput === void 0) return;
+	const { 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);
-		return;
+		cancel(projectNameValidationError, { output });
+		return {
+			ok: false,
+			message: projectNameValidationError
+		};
 	}
-	const template = input.template ?? (useDefaults ? DEFAULT_TEMPLATE : await promptForCreateTemplate());
-	if (!template) return;
+	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) {
-		cancel(`Target path ${formatPathForDisplay(targetDirectory)} already exists and is not a directory. Choose a different project name.`);
-		return;
+		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
+		};
 	}
 	if (targetPathState.exists && !targetPathState.isEmptyDirectory && !force) {
-		cancel(`Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`);
-		return;
+		const message = `Target directory ${formatPathForDisplay(targetDirectory)} is not empty. Use --force to continue.`;
+		cancel(message, { output });
+		return {
+			ok: false,
+			message
+		};
 	}
 	const prismaSetupContext = await collectPrismaSetupContext(input, {
 		projectDir: targetDirectory,
 		template
 	});
-	if (!prismaSetupContext) return;
+	if (!prismaSetupContext) return {
+		ok: false,
+		message: "Operation cancelled."
+	};
 	return {
-		targetDirectory,
-		targetPathState,
-		force,
-		template,
-		projectPackageName: toPackageName(path.basename(targetDirectory)),
-		prismaSetupContext
+		ok: true,
+		context: {
+			targetDirectory,
+			targetPathState,
+			force,
+			template,
+			projectPackageName: toPackageName(path.basename(targetDirectory)),
+			prismaSetupContext
+		}
 	};
 }
 async function executeCreateContext(context) {
-	const createSpinner = context.prismaSetupContext.verbose ? void 0 : spinner();
+	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.`);
+		if (context.prismaSetupContext.verbose) log.step(`Scaffolding ${context.template} starter.`, { output });
 		await scaffoldCreateFrameworkTemplate({
 			projectDir: context.targetDirectory,
 			projectName: context.projectPackageName,
@@ -1583,7 +1732,7 @@ async function executeCreateContext(context) {
 			authoring: context.prismaSetupContext.authoring,
 			packageManager: context.prismaSetupContext.packageManager
 		});
-		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.");
+		if (context.prismaSetupContext.verbose) log.success("Starter files scaffolded.", { output });
 	} catch (error) {
 		createSpinner?.error("Could not create Prisma 8 project.");
 		return {
@@ -1606,13 +1755,14 @@ async function executeCreateContext(context) {
 			error
 		};
 	}
-	if (context.targetPathState.exists && !context.targetPathState.isEmptyDirectory && context.force) log.warn(`Used --force in non-empty directory ${formatPathForDisplay(context.targetDirectory)}.`);
+	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 {
-		if (!await executePrismaSetupContext(context.prismaSetupContext, {
+		const setupResult = await executePrismaSetupContext(context.prismaSetupContext, {
 			prependNextSteps: nextSteps,
 			projectDir: context.targetDirectory,
 			projectName: context.projectPackageName,
@@ -1621,9 +1771,25 @@ async function executeCreateContext(context) {
 			includeDevNextStep: true,
 			initializeGit: !context.targetPathState.exists || context.targetPathState.isEmptyDirectory,
 			progressSpinner: createSpinner
-		})) return {
+		});
+		if (!setupResult.ok) return {
 			ok: false,
-			stage: "prisma_setup"
+			stage: "prisma_setup",
+			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.");
@@ -1633,8 +1799,7 @@ async function executeCreateContext(context) {
 			error
 		};
 	}
-	return { ok: true };
 }
 
 //#endregion
-export { DatabaseProviderSchema as a, CreateTemplateSchema as i, AuthoringStyleSchema as n, PackageManagerSchema as o, CreateCommandInputSchema as r, runCreateCommand as t };
+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 };

package/dist/index.d.mts

@@ -2,7 +2,135 @@
 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/types.d.ts
+declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
+  postgres: "postgres";
+  postgresql: "postgresql";
+  mongo: "mongo";
+  mongodb: "mongodb";
+}>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>;
+type DatabaseProvider = z.infer<typeof DatabaseProviderSchema>;
+declare const PackageManagerSchema: z.ZodEnum<{
+  npm: "npm";
+  pnpm: "pnpm";
+  yarn: "yarn";
+  bun: "bun";
+  deno: "deno";
+}>;
+type PackageManager = z.infer<typeof PackageManagerSchema>;
+declare const AuthoringStyleSchema: z.ZodEnum<{
+  psl: "psl";
+  typescript: "typescript";
+}>;
+type AuthoringStyle = z.infer<typeof AuthoringStyleSchema>;
+declare const CreateTemplateSchema: z.ZodEnum<{
+  minimal: "minimal";
+  hono: "hono";
+  elysia: "elysia";
+  nest: "nest";
+  next: "next";
+  svelte: "svelte";
+  astro: "astro";
+  nuxt: "nuxt";
+  "tanstack-start": "tanstack-start";
+}>;
+type CreateTemplate = z.infer<typeof CreateTemplateSchema>;
+declare const CreateCommandInputSchema: z.ZodObject<{
+  yes: z.ZodOptional<z.ZodBoolean>;
+  verbose: z.ZodOptional<z.ZodBoolean>;
+  json: z.ZodOptional<z.ZodBoolean>;
+  provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+    postgres: "postgres";
+    postgresql: "postgresql";
+    mongo: "mongo";
+    mongodb: "mongodb";
+  }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
+  authoring: z.ZodOptional<z.ZodEnum<{
+    psl: "psl";
+    typescript: "typescript";
+  }>>;
+  packageManager: z.ZodOptional<z.ZodEnum<{
+    npm: "npm";
+    pnpm: "pnpm";
+    yarn: "yarn";
+    bun: "bun";
+    deno: "deno";
+  }>>;
+  deploy: z.ZodOptional<z.ZodBoolean>;
+  workspace: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  template: z.ZodOptional<z.ZodEnum<{
+    minimal: "minimal";
+    hono: "hono";
+    elysia: "elysia";
+    nest: "nest";
+    next: "next";
+    svelte: "svelte";
+    astro: "astro";
+    nuxt: "nuxt";
+    "tanstack-start": "tanstack-start";
+  }>>;
+  force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
+//#endregion
+//#region src/tasks/deploy-with-composer.d.ts
+type PrismaWorkspace = {
+  id: string;
+  name: string | null;
+};
+type ComposerDeployResult = {
+  appName: string;
+  appUrl?: string;
+  serviceId?: string;
+  workspace?: PrismaWorkspace;
+  project: {
+    id?: string;
+    name: string;
+    consoleUrl?: string;
+  };
+};
+//#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 = {
+  command: string;
+  description: string;
+};
+type CreateProjectResult = {
+  name: string;
+  path: string;
+  template: CreateTemplate;
+  databaseProvider: DatabaseProvider;
+  authoring: AuthoringStyle;
+  packageManager: PackageManager;
+};
+type CreateCommandFailureStage = CreateTelemetryFailureStage | "parse_arguments";
+type CreateCommandSuccessResult = {
+  schemaVersion: typeof CREATE_PRISMA_RESULT_SCHEMA_VERSION;
+  ok: true;
+  project: CreateProjectResult;
+  deployment: ComposerDeployResult | null;
+  nextSteps: CreateNextStep[];
+  warnings: string[];
+};
+type CreateCommandFailureResult = {
+  schemaVersion: typeof CREATE_PRISMA_RESULT_SCHEMA_VERSION;
+  ok: false;
+  error: {
+    stage: CreateCommandFailureStage;
+    message: string;
+  };
+  project?: CreateProjectResult;
+};
+type CreateCommandResult = CreateCommandSuccessResult | CreateCommandFailureResult;
+//#endregion
 //#region node_modules/@orpc/client/dist/index.d.mts
 declare const COMMON_ORPC_ERROR_DEFS: {
   readonly BAD_REQUEST: {
@@ -174,78 +302,12 @@ interface ErrorMapItem<TDataSchema extends AnySchema> {
 type ErrorMap = { [key in ORPCErrorCode]?: ErrorMapItem<AnySchema> };
 type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
 //#endregion
-//#region src/types.d.ts
-declare const DatabaseProviderSchema: z.ZodPipe<z.ZodEnum<{
-  postgres: "postgres";
-  postgresql: "postgresql";
-  mongo: "mongo";
-  mongodb: "mongodb";
-}>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>;
-declare const PackageManagerSchema: z.ZodEnum<{
-  npm: "npm";
-  pnpm: "pnpm";
-  yarn: "yarn";
-  bun: "bun";
-  deno: "deno";
-}>;
-declare const AuthoringStyleSchema: z.ZodEnum<{
-  psl: "psl";
-  typescript: "typescript";
-}>;
-declare const CreateTemplateSchema: z.ZodEnum<{
-  minimal: "minimal";
-  hono: "hono";
-  elysia: "elysia";
-  nest: "nest";
-  next: "next";
-  svelte: "svelte";
-  astro: "astro";
-  nuxt: "nuxt";
-  "tanstack-start": "tanstack-start";
-}>;
-declare const CreateCommandInputSchema: z.ZodObject<{
-  yes: z.ZodOptional<z.ZodBoolean>;
-  verbose: z.ZodOptional<z.ZodBoolean>;
-  provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
-    postgres: "postgres";
-    postgresql: "postgresql";
-    mongo: "mongo";
-    mongodb: "mongodb";
-  }>, z.ZodTransform<"postgres" | "mongo", "postgres" | "postgresql" | "mongo" | "mongodb">>>;
-  authoring: z.ZodOptional<z.ZodEnum<{
-    psl: "psl";
-    typescript: "typescript";
-  }>>;
-  packageManager: z.ZodOptional<z.ZodEnum<{
-    npm: "npm";
-    pnpm: "pnpm";
-    yarn: "yarn";
-    bun: "bun";
-    deno: "deno";
-  }>>;
-  deploy: z.ZodOptional<z.ZodBoolean>;
-  workspace: z.ZodOptional<z.ZodString>;
-  name: z.ZodOptional<z.ZodString>;
-  template: z.ZodOptional<z.ZodEnum<{
-    minimal: "minimal";
-    hono: "hono";
-    elysia: "elysia";
-    nest: "nest";
-    next: "next";
-    svelte: "svelte";
-    astro: "astro";
-    nuxt: "nuxt";
-    "tanstack-start": "tanstack-start";
-  }>>;
-  force: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
-//#endregion
 //#region src/index.d.ts
 declare const router: {
   create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodTuple<[z.ZodOptional<z.ZodString>, z.ZodObject<{
     yes: z.ZodOptional<z.ZodBoolean>;
     verbose: z.ZodOptional<z.ZodBoolean>;
+    json: z.ZodOptional<z.ZodBoolean>;
     provider: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
       postgres: "postgres";
       postgresql: "postgresql";
@@ -278,9 +340,9 @@ declare const router: {
       "tanstack-start": "tanstack-start";
     }>>;
     force: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>], null>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+  }, z.core.$strip>], null>, Schema<CreateCommandResult | undefined, CreateCommandResult | undefined>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
 };
 declare function createCreatePrismaCli(): trpc_cli0.TrpcCli;
 declare function create(input?: CreateCommandInput): Promise<void>;
 //#endregion
-export { AuthoringStyleSchema, type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, type CreateCommandFailureResult, type CreateCommandFailureStage, type CreateCommandInput, CreateCommandInputSchema, type CreateCommandResult, type CreateCommandSuccessResult, type CreateNextStep, type CreateProjectResult, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

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, t as runCreateCommand } from "./create-C2fGwZxV.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-JgaDOyzC.mjs";
 import { os } from "@orpc/server";
 import { createCli } from "trpc-cli";
 import { z } from "zod";
 
 //#region src/index.ts
-const CLI_VERSION = "0.9.5";
+const CLI_VERSION = "0.10.0-pr.72.261.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;
@@ -19,7 +19,9 @@ const router = os.router({ create: os.meta({
 	default: true,
 	negateBooleans: true
 }).input(CreateCliInputSchema).handler(async ({ input }) => {
-	await runCreateCommand(normalizeCreateCliInput(input));
+	const createInput = normalizeCreateCliInput(input);
+	const result = await runCreateCommand(createInput);
+	return createInput.json ? result : void 0;
 }) });
 function createCreatePrismaCli() {
 	return createCli({
@@ -33,4 +35,4 @@ async function create(input = {}) {
 }
 
 //#endregion
-export { AuthoringStyleSchema, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-prisma",
-  "version": "0.9.5",
+  "version": "0.10.0-pr.72.261.1",
   "private": false,
   "description": "Create Prisma 8 projects with first-party templates and great DX.",
   "homepage": "https://github.com/prisma/create-prisma",
@@ -37,7 +37,7 @@
     "dev": "tsdown --watch",
     "start": "bun run ./dist/cli.mjs",
     "test": "bun run test:unit && bun run test:e2e",
-    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/deploy-with-composer.test.ts ./tests/initialize-git.test.ts ./tests/install.test.ts ./tests/node-version.test.ts ./tests/setup-prisma.test.ts ./tests/telemetry.test.ts",
+    "test:unit": "bun test ./tests/dependencies.test.ts ./tests/deploy-with-composer.test.ts ./tests/initialize-git.test.ts ./tests/install.test.ts ./tests/json-output.test.ts ./tests/node-version.test.ts ./tests/setup-prisma.test.ts ./tests/telemetry.test.ts",
     "test:e2e": "bun test --timeout 180000 ./tests/e2e/create-prisma.e2e.test.ts",
     "check": "bun run format:check && bun run lint",
     "lint": "oxlint . --deny-warnings",

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" };