@prisma-next/cli 0.3.0-dev.7 → 0.3.0-dev.70

package/dist/result-handler-iA9JtUC7.mjs

@@ -0,0 +1,1186 @@
+import { relative, resolve } from "pathe";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { bgGreen, blue, bold, cyan, dim, green, magenta, red, yellow } from "colorette";
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+
+//#region src/utils/command-helpers.ts
+const longDescriptions = /* @__PURE__ */ new WeakMap();
+/**
+* Sets both short and long descriptions for a command.
+* The short description is used in command trees and headers.
+* The long description is shown at the bottom of help output.
+*/
+function setCommandDescriptions(command, shortDescription, longDescription) {
+	command.description(shortDescription);
+	if (longDescription) longDescriptions.set(command, longDescription);
+	return command;
+}
+/**
+* Gets the long description from a command if it was set via setCommandDescriptions.
+*/
+function getLongDescription(command) {
+	return longDescriptions.get(command);
+}
+/**
+* Resolves the absolute path to contract.json from the config.
+* Centralises the fallback logic shared by every command that reads the contract.
+*/
+function resolveContractPath(config) {
+	return config.contract?.output ? resolve(config.contract.output) : resolve("src/prisma/contract.json");
+}
+/**
+* Masks credentials in a database connection URL.
+* Handles standard URLs (username + password + query params) and libpq-style key=value strings.
+*/
+function maskConnectionUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.username) parsed.username = "****";
+		if (parsed.password) parsed.password = "****";
+		for (const key of [...parsed.searchParams.keys()]) if (/password/i.test(key)) parsed.searchParams.set(key, "****");
+		return parsed.toString();
+	} catch {
+		return url.replace(/password\s*=\s*\S+/gi, "password=****").replace(/user\s*=\s*\S+/gi, "user=****");
+	}
+}
+/**
+* Strips raw connection URL fragments from an error message to prevent credential leakage.
+* Call this before surfacing driver errors to the user.
+*/
+function sanitizeErrorMessage(message, connectionUrl) {
+	if (!connectionUrl) return message;
+	try {
+		const parsed = new URL(connectionUrl);
+		let sanitized = message;
+		sanitized = sanitized.replaceAll(connectionUrl, maskConnectionUrl(connectionUrl));
+		if (parsed.password) sanitized = sanitized.replaceAll(parsed.password, "****");
+		if (parsed.username) sanitized = sanitized.replaceAll(parsed.username, "****");
+		return sanitized;
+	} catch {
+		return message.replace(/password\s*=\s*\S+/gi, "password=****").replace(/user\s*=\s*\S+/gi, "user=****");
+	}
+}
+
+//#endregion
+//#region src/utils/global-flags.ts
+/**
+* Parses global flags from CLI options.
+* Handles verbosity flags (-v, -vv, --trace), JSON output, quiet mode, timestamps, and color.
+*/
+function parseGlobalFlags(options) {
+	const flags = {};
+	if (options.json === true || options.json === "object") flags.json = "object";
+	else if (options.json === "ndjson") flags.json = "ndjson";
+	if (options.quiet || options.q) flags.quiet = true;
+	if (options.vv || options.trace) flags.verbose = 2;
+	else if (options.verbose || options.v) flags.verbose = 1;
+	else flags.verbose = 0;
+	if (options.timestamps) flags.timestamps = true;
+	if (process.env["NO_COLOR"] || flags.json) flags.color = false;
+	else if (options["no-color"]) flags.color = false;
+	else if (options.color !== void 0) flags.color = options.color;
+	else flags.color = process.stdout.isTTY && !process.env["CI"];
+	return flags;
+}
+
+//#endregion
+//#region src/utils/output.ts
+/**
+* Formats a timestamp for output.
+*/
+function formatTimestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/**
+* Creates a prefix string if timestamps are enabled.
+*/
+function createPrefix(flags) {
+	return flags.timestamps ? `[${formatTimestamp()}] ` : "";
+}
+/**
+* Checks if verbose output is enabled at the specified level.
+*/
+function isVerbose(flags, level) {
+	return (flags.verbose ?? 0) >= level;
+}
+/**
+* Creates a color-aware formatter function.
+* Returns a function that applies the color only if colors are enabled.
+*/
+function createColorFormatter(useColor, colorFn) {
+	return useColor ? colorFn : (text) => text;
+}
+/**
+* Formats text with dim styling if colors are enabled.
+*/
+function formatDim(useColor, text) {
+	return useColor ? dim(text) : text;
+}
+/**
+* Formats human-readable output for contract emit.
+*/
+function formatEmitOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const jsonPath = relative(process.cwd(), result.files.json);
+	const dtsPath = relative(process.cwd(), result.files.dts);
+	lines.push(`${prefix}✔ Emitted contract.json → ${jsonPath}`);
+	lines.push(`${prefix}✔ Emitted contract.d.ts → ${dtsPath}`);
+	lines.push(`${prefix}  storageHash: ${result.storageHash}`);
+	if (result.executionHash) lines.push(`${prefix}  executionHash: ${result.executionHash}`);
+	if (result.profileHash) lines.push(`${prefix}  profileHash: ${result.profileHash}`);
+	if (isVerbose(flags, 1)) lines.push(`${prefix}  Total time: ${result.timings.total}ms`);
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for contract emit.
+*/
+function formatEmitJson(result) {
+	const output = {
+		ok: true,
+		storageHash: result.storageHash,
+		...ifDefined("executionHash", result.executionHash),
+		...result.profileHash ? { profileHash: result.profileHash } : {},
+		outDir: result.outDir,
+		files: result.files,
+		timings: result.timings
+	};
+	return JSON.stringify(output, null, 2);
+}
+/**
+* Formats error output for human-readable display.
+*/
+function formatErrorOutput(error, flags) {
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	lines.push(`${prefix}${formatRed("✖")} ${error.summary} (${error.code})`);
+	if (error.why) lines.push(`${prefix}${formatDimText(`  Why: ${error.why}`)}`);
+	if (error.fix) lines.push(`${prefix}${formatDimText(`  Fix: ${error.fix}`)}`);
+	if (error.where?.path) {
+		const whereLine = error.where.line ? `${error.where.path}:${error.where.line}` : error.where.path;
+		lines.push(`${prefix}${formatDimText(`  Where: ${whereLine}`)}`);
+	}
+	if (error.meta?.["conflicts"]) {
+		const conflicts = error.meta["conflicts"];
+		if (conflicts.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? conflicts.length : Math.min(3, conflicts.length);
+			const header = isVerbose(flags, 1) ? "  Conflicts:" : `  Conflicts (showing ${maxToShow} of ${conflicts.length}):`;
+			lines.push(`${prefix}${formatDimText(header)}`);
+			for (const conflict of conflicts.slice(0, maxToShow)) lines.push(`${prefix}${formatDimText(`    - [${conflict.kind}] ${conflict.summary}`)}`);
+			if (!isVerbose(flags, 1) && conflicts.length > maxToShow) lines.push(`${prefix}${formatDimText("  Re-run with -v/--verbose to see all conflicts")}`);
+		}
+	}
+	if (error.meta?.["issues"]) {
+		const issues = error.meta["issues"];
+		if (issues.length > 0) {
+			const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
+			const header = isVerbose(flags, 1) ? "  Issues:" : `  Issues (showing ${maxToShow} of ${issues.length}):`;
+			lines.push(`${prefix}${formatDimText(header)}`);
+			for (const issue of issues.slice(0, maxToShow)) {
+				const kind = issue.kind ?? "issue";
+				const message = issue.message ?? "";
+				lines.push(`${prefix}${formatDimText(`    - [${kind}] ${message}`)}`);
+			}
+			if (!isVerbose(flags, 1) && issues.length > maxToShow) lines.push(`${prefix}${formatDimText("  Re-run with -v/--verbose to see all issues")}`);
+		}
+	}
+	if (error.docsUrl && isVerbose(flags, 1)) lines.push(formatDimText(error.docsUrl));
+	if (isVerbose(flags, 2) && error.meta) lines.push(`${prefix}${formatDimText(`  Meta: ${JSON.stringify(error.meta, null, 2)}`)}`);
+	return lines.join("\n");
+}
+/**
+* Formats error output as JSON.
+*/
+function formatErrorJson(error) {
+	return JSON.stringify(error, null, 2);
+}
+/**
+* Formats human-readable output for database verify.
+*/
+function formatVerifyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		lines.push(`${prefix}${formatGreen("✔")} ${result.summary}`);
+		lines.push(`${prefix}${formatDimText(`  storageHash: ${result.contract.storageHash}`)}`);
+		if (result.contract.profileHash) lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+	} else lines.push(`${prefix}${formatRed("✖")} ${result.summary} (${result.code})`);
+	if (isVerbose(flags, 1)) {
+		if (result.codecCoverageSkipped) lines.push(`${prefix}${formatDimText("  Codec coverage check skipped (helper returned no supported types)")}`);
+		lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database verify.
+*/
+function formatVerifyJson(result) {
+	const output = {
+		ok: result.ok,
+		...result.code ? { code: result.code } : {},
+		summary: result.summary,
+		contract: result.contract,
+		...result.marker ? { marker: result.marker } : {},
+		target: result.target,
+		...result.missingCodecs ? { missingCodecs: result.missingCodecs } : {},
+		...result.meta ? { meta: result.meta } : {},
+		timings: result.timings
+	};
+	return JSON.stringify(output, null, 2);
+}
+/**
+* Formats JSON output for database introspection.
+*/
+function formatIntrospectJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Renders a schema tree structure from CoreSchemaView.
+* Matches the style of renderSchemaVerificationTree for consistency.
+*/
+function renderSchemaTree(node, flags, options) {
+	const { isLast, prefix, useColor, formatDimText, isRoot = false } = options;
+	const lines = [];
+	let formattedLabel = node.label;
+	if (useColor) switch (node.kind) {
+		case "root":
+			formattedLabel = bold(node.label);
+			break;
+		case "entity": {
+			const tableMatch = node.label.match(/^table\s+(.+)$/);
+			if (tableMatch?.[1]) {
+				const tableName = tableMatch[1];
+				formattedLabel = `${dim("table")} ${cyan(tableName)}`;
+			} else formattedLabel = cyan(node.label);
+			break;
+		}
+		case "collection":
+			formattedLabel = dim(node.label);
+			break;
+		case "field": {
+			const columnMatch = node.label.match(/^([^:]+):\s*(.+)$/);
+			if (columnMatch?.[1] && columnMatch[2]) {
+				const columnName = columnMatch[1];
+				const rest = columnMatch[2];
+				const typeMatch = rest.match(/^([^\s(]+)\s*(\([^)]+\))$/);
+				if (typeMatch?.[1] && typeMatch[2]) {
+					const typeDisplay = typeMatch[1];
+					const nullability = typeMatch[2];
+					formattedLabel = `${cyan(columnName)}: ${typeDisplay} ${dim(nullability)}`;
+				} else formattedLabel = `${cyan(columnName)}: ${rest}`;
+			} else formattedLabel = node.label;
+			break;
+		}
+		case "index": {
+			const pkMatch = node.label.match(/^primary key:\s*(.+)$/);
+			if (pkMatch?.[1]) {
+				const columnNames = pkMatch[1];
+				formattedLabel = `${dim("primary key")}: ${cyan(columnNames)}`;
+			} else {
+				const uniqueMatch = node.label.match(/^unique\s+(.+)$/);
+				if (uniqueMatch?.[1]) {
+					const name = uniqueMatch[1];
+					formattedLabel = `${dim("unique")} ${cyan(name)}`;
+				} else {
+					const indexMatch = node.label.match(/^(unique\s+)?index\s+(.+)$/);
+					if (indexMatch?.[2]) {
+						const prefix$1 = indexMatch[1] ? `${dim("unique")} ` : "";
+						const name = indexMatch[2];
+						formattedLabel = `${prefix$1}${dim("index")} ${cyan(name)}`;
+					} else formattedLabel = dim(node.label);
+				}
+			}
+			break;
+		}
+		case "extension": {
+			const extMatch = node.label.match(/^([^\s]+)\s+(extension is enabled)$/);
+			if (extMatch?.[1] && extMatch[2]) {
+				const extName = extMatch[1];
+				const rest = extMatch[2];
+				formattedLabel = `${cyan(extName)} ${dim(rest)}`;
+			} else formattedLabel = magenta(node.label);
+			break;
+		}
+		default:
+			formattedLabel = node.label;
+			break;
+	}
+	if (isRoot) lines.push(formattedLabel);
+	else {
+		const treePrefix = `${prefix}${formatDimText(isLast ? "└" : "├")}─ `;
+		const isRootChild = prefix === "";
+		const prefixHasVerticalBar = stripAnsi(prefix).includes("│");
+		if (isRootChild) lines.push(`${treePrefix}${formattedLabel}`);
+		else if (prefixHasVerticalBar) lines.push(`${treePrefix}${formattedLabel}`);
+		else lines.push(`${formatDimText("│")} ${treePrefix}${formattedLabel}`);
+	}
+	if (node.children && node.children.length > 0) {
+		const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("│")}  `;
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			if (!child) continue;
+			const childLines = renderSchemaTree(child, flags, {
+				isLast: i === node.children.length - 1,
+				prefix: childPrefix,
+				useColor,
+				formatDimText,
+				isRoot: false
+			});
+			lines.push(...childLines);
+		}
+	}
+	return lines;
+}
+/**
+* Formats human-readable output for database introspection.
+*/
+function formatIntrospectOutput(result, schemaView, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (schemaView) {
+		const prefixedTreeLines = renderSchemaTree(schemaView.root, flags, {
+			isLast: true,
+			prefix: "",
+			useColor,
+			formatDimText,
+			isRoot: true
+		}).map((line) => `${prefix}${line}`);
+		lines.push(...prefixedTreeLines);
+	} else {
+		lines.push(`${prefix}✔ ${result.summary}`);
+		if (isVerbose(flags, 1)) {
+			lines.push(`${prefix}  Target: ${result.target.familyId}/${result.target.id}`);
+			if (result.meta?.dbUrl) lines.push(`${prefix}  Database: ${result.meta.dbUrl}`);
+		}
+	}
+	if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	return lines.join("\n");
+}
+/**
+* Renders a schema verification tree structure from SchemaVerificationNode.
+* Similar to renderSchemaTree but for verification nodes with status-based colors and glyphs.
+*/
+function renderSchemaVerificationTree(node, flags, options) {
+	const { isLast, prefix, useColor, formatDimText, isRoot = false } = options;
+	const lines = [];
+	let statusGlyph = "";
+	let statusColor = (text) => text;
+	if (useColor) switch (node.status) {
+		case "pass":
+			statusGlyph = "✔";
+			statusColor = green;
+			break;
+		case "warn":
+			statusGlyph = "⚠";
+			statusColor = (text) => useColor ? yellow(text) : text;
+			break;
+		case "fail":
+			statusGlyph = "✖";
+			statusColor = red;
+			break;
+	}
+	else switch (node.status) {
+		case "pass":
+			statusGlyph = "✔";
+			break;
+		case "warn":
+			statusGlyph = "⚠";
+			break;
+		case "fail":
+			statusGlyph = "✖";
+			break;
+	}
+	let labelColor = (text) => text;
+	let formattedLabel = node.name;
+	if (useColor) switch (node.kind) {
+		case "contract":
+		case "schema":
+			labelColor = bold;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "table": {
+			const tableMatch = node.name.match(/^table\s+(.+)$/);
+			if (tableMatch?.[1]) {
+				const tableName = tableMatch[1];
+				formattedLabel = `${dim("table")} ${cyan(tableName)}`;
+			} else formattedLabel = dim(node.name);
+			break;
+		}
+		case "columns":
+			labelColor = dim;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "column": {
+			const columnMatch = node.name.match(/^([^:]+):\s*(.+)$/);
+			if (columnMatch?.[1] && columnMatch[2]) {
+				const columnName = columnMatch[1];
+				const rest = columnMatch[2];
+				const typeMatch = rest.match(/^([^\s→]+)\s*→\s*([^\s(]+)\s*(\([^)]+\))$/);
+				if (typeMatch?.[1] && typeMatch[2] && typeMatch[3]) {
+					const contractType = typeMatch[1];
+					const nativeType = typeMatch[2];
+					const nullability = typeMatch[3];
+					formattedLabel = `${cyan(columnName)}: ${contractType} → ${dim(nativeType)} ${dim(nullability)}`;
+				} else formattedLabel = `${cyan(columnName)}: ${rest}`;
+			} else formattedLabel = node.name;
+			break;
+		}
+		case "type":
+		case "nullability":
+			labelColor = (text) => text;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "primaryKey": {
+			const pkMatch = node.name.match(/^primary key:\s*(.+)$/);
+			if (pkMatch?.[1]) {
+				const columnNames = pkMatch[1];
+				formattedLabel = `${dim("primary key")}: ${cyan(columnNames)}`;
+			} else formattedLabel = dim(node.name);
+			break;
+		}
+		case "foreignKey":
+		case "unique":
+		case "index":
+			labelColor = dim;
+			formattedLabel = labelColor(node.name);
+			break;
+		case "extension": {
+			const dbMatch = node.name.match(/^database is\s+(.+)$/);
+			if (dbMatch?.[1]) {
+				const dbName = dbMatch[1];
+				formattedLabel = `${dim("database is")} ${cyan(dbName)}`;
+			} else {
+				const extMatch = node.name.match(/^([^\s]+)\s+(extension is enabled)$/);
+				if (extMatch?.[1] && extMatch[2]) {
+					const extName = extMatch[1];
+					const rest = extMatch[2];
+					formattedLabel = `${cyan(extName)} ${dim(rest)}`;
+				} else {
+					labelColor = magenta;
+					formattedLabel = labelColor(node.name);
+				}
+			}
+			break;
+		}
+		default:
+			formattedLabel = node.name;
+			break;
+	}
+	else formattedLabel = node.name;
+	const statusGlyphColored = statusColor(statusGlyph);
+	let nodeLabel = formattedLabel;
+	if ((node.status === "fail" || node.status === "warn") && node.message && node.message.length > 0) {
+		const messageText = formatDimText(`(${node.message})`);
+		nodeLabel = `${formattedLabel} ${messageText}`;
+	}
+	if (isRoot) lines.push(`${statusGlyphColored} ${nodeLabel}`);
+	else {
+		const treePrefix = `${prefix}${formatDimText(isLast ? "└" : "├")}─ `;
+		const isRootChild = prefix === "";
+		const prefixHasVerticalBar = stripAnsi(prefix).includes("│");
+		if (isRootChild) lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+		else if (prefixHasVerticalBar) lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+		else lines.push(`${formatDimText("│")} ${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+	}
+	if (node.children && node.children.length > 0) {
+		const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("│")}  `;
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			if (!child) continue;
+			const childLines = renderSchemaVerificationTree(child, flags, {
+				isLast: i === node.children.length - 1,
+				prefix: childPrefix,
+				useColor,
+				formatDimText,
+				isRoot: false
+			});
+			lines.push(...childLines);
+		}
+	}
+	return lines;
+}
+/**
+* Formats human-readable output for database schema verification.
+*/
+function formatSchemaVerifyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatRed = createColorFormatter(useColor, red);
+	const formatDimText = (text) => formatDim(useColor, text);
+	const prefixedTreeLines = renderSchemaVerificationTree(result.schema.root, flags, {
+		isLast: true,
+		prefix: "",
+		useColor,
+		formatDimText,
+		isRoot: true
+	}).map((line) => `${prefix}${line}`);
+	lines.push(...prefixedTreeLines);
+	if (isVerbose(flags, 1)) {
+		lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+		lines.push(`${prefix}${formatDimText(`  pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`);
+	}
+	lines.push("");
+	if (result.ok) lines.push(`${prefix}${formatGreen("✔")} ${result.summary}`);
+	else {
+		const codeText = result.code ? ` (${result.code})` : "";
+		lines.push(`${prefix}${formatRed("✖")} ${result.summary}${codeText}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database schema verification.
+*/
+function formatSchemaVerifyJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Formats human-readable output for database sign.
+*/
+function formatSignOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		lines.push(`${prefix}${formatGreen("✔")} Database signed`);
+		const previousHash = result.marker.previous?.storageHash ?? "none";
+		const currentHash = result.contract.storageHash;
+		lines.push(`${prefix}${formatDimText(`  from: ${previousHash}`)}`);
+		lines.push(`${prefix}${formatDimText(`  to:   ${currentHash}`)}`);
+		if (isVerbose(flags, 1)) {
+			if (result.contract.profileHash) lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+			if (result.marker.previous?.profileHash) lines.push(`${prefix}${formatDimText(`  previous profileHash: ${result.marker.previous.profileHash}`)}`);
+			lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for database sign.
+*/
+function formatSignJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Formats human-readable output for migration commands (db init, db update) in plan mode.
+*/
+function formatMigrationPlanOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	const operationCount = result.plan?.operations.length ?? 0;
+	lines.push(`${prefix}${formatGreen("✔")} Planned ${operationCount} operation(s)`);
+	if (result.plan?.operations && result.plan.operations.length > 0) {
+		const formatYellow = createColorFormatter(useColor, yellow);
+		lines.push(`${prefix}${formatDimText("│")}`);
+		for (let i = 0; i < result.plan.operations.length; i++) {
+			const op = result.plan.operations[i];
+			if (!op) continue;
+			const treeChar = i === result.plan.operations.length - 1 ? "└" : "├";
+			const opClassLabel = op.operationClass === "destructive" ? formatYellow(`[${op.operationClass}]`) : formatDimText(`[${op.operationClass}]`);
+			lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+		}
+		if (result.plan.operations.some((op) => op.operationClass === "destructive")) {
+			lines.push(`${prefix}`);
+			lines.push(`${prefix}${formatYellow("⚠")} This migration contains destructive operations that may cause data loss.`);
+		}
+	}
+	if (result.plan?.destination) {
+		lines.push(`${prefix}`);
+		lines.push(`${prefix}${formatDimText(`Destination hash: ${result.plan.destination.storageHash}`)}`);
+	}
+	const planSql = result.plan?.sql;
+	if (planSql) {
+		lines.push(`${prefix}`);
+		lines.push(`${prefix}${formatDimText("DDL preview")}`);
+		if (planSql.length === 0) lines.push(`${prefix}${formatDimText("No DDL operations.")}`);
+		else {
+			lines.push(`${prefix}`);
+			for (const statement of planSql) {
+				const trimmed = statement.trim();
+				if (!trimmed) continue;
+				const line = trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+				lines.push(`${prefix}${line}`);
+			}
+		}
+	}
+	if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`Total time: ${result.timings.total}ms`)}`);
+	lines.push(`${prefix}`);
+	lines.push(`${prefix}${formatDimText("This is a dry run. No changes were applied.")}`);
+	lines.push(`${prefix}${formatDimText("Run without --plan to apply changes.")}`);
+	return lines.join("\n");
+}
+function formatMigrationApplyCommandOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.migrationsApplied === 0) {
+		lines.push(`${formatGreen("✔")} ${result.summary}`);
+		lines.push(formatDimText(`  marker: ${result.markerHash}`));
+		return lines.join("\n");
+	}
+	lines.push(`${formatGreen("✔")} ${result.summary}`);
+	lines.push("");
+	for (let i = 0; i < result.applied.length; i++) {
+		const migration = result.applied[i];
+		const treeChar = i === result.applied.length - 1 ? "└" : "├";
+		lines.push(`${formatDimText(treeChar)}─ ${migration.dirName} ${formatDimText(`[${migration.operationsExecuted} op(s)]`)}`);
+	}
+	lines.push("");
+	lines.push(formatDimText(`marker: ${result.markerHash}`));
+	if (isVerbose(flags, 1) && result.timings) {
+		lines.push("");
+		lines.push(formatDimText(`Total time: ${result.timings.total}ms`));
+	}
+	return lines.join("\n");
+}
+function formatMigrationVerifyCommandOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatYellow = createColorFormatter(useColor, yellow);
+	const formatDimText = (text) => formatDim(useColor, text);
+	switch (result.status) {
+		case "verified":
+			lines.push(`${formatGreen("✔")} Migration verified`);
+			lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
+			break;
+		case "attested":
+			lines.push(`${formatYellow("◉")} Draft migration attested`);
+			lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
+			break;
+	}
+	return lines.join("\n");
+}
+function formatMigrationShowOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatYellow = createColorFormatter(useColor, yellow);
+	const formatDimText = (text) => formatDim(useColor, text);
+	lines.push(`${prefix}${formatGreen("✔")} ${result.dirName}`);
+	lines.push(`${prefix}${formatDimText(`  kind: ${result.kind}`)}`);
+	lines.push(`${prefix}${formatDimText(`  from: ${result.from}`)}`);
+	lines.push(`${prefix}${formatDimText(`  to:   ${result.to}`)}`);
+	if (result.migrationId) lines.push(`${prefix}${formatDimText(`  migrationId: ${result.migrationId}`)}`);
+	else lines.push(`${prefix}${formatYellow("  migrationId: (draft — not yet attested)")}`);
+	lines.push(`${prefix}${formatDimText(`  created: ${result.createdAt}`)}`);
+	lines.push(`${prefix}`);
+	lines.push(`${prefix}${result.operations.length} operation(s)`);
+	if (result.operations.length > 0) {
+		lines.push(`${prefix}${formatDimText("│")}`);
+		for (let i = 0; i < result.operations.length; i++) {
+			const op = result.operations[i];
+			const treeChar = i === result.operations.length - 1 ? "└" : "├";
+			const opClassLabel = op.operationClass === "destructive" ? formatYellow(`[${op.operationClass}]`) : formatDimText(`[${op.operationClass}]`);
+			lines.push(`${prefix}${formatDimText(treeChar)}─ ${op.label} ${opClassLabel}`);
+		}
+		if (result.operations.some((op) => op.operationClass === "destructive")) {
+			lines.push(`${prefix}`);
+			lines.push(`${prefix}${formatYellow("⚠")} This migration contains destructive operations that may cause data loss.`);
+		}
+	}
+	if (result.sql.length > 0) {
+		lines.push(`${prefix}`);
+		lines.push(`${prefix}${formatDimText("DDL preview")}`);
+		lines.push(`${prefix}`);
+		for (const statement of result.sql) {
+			const trimmed = statement.trim();
+			if (!trimmed) continue;
+			const line = trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+			lines.push(`${prefix}${line}`);
+		}
+	}
+	return lines.join("\n");
+}
+function formatMigrationStatusOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatYellow = createColorFormatter(useColor, yellow);
+	const formatDimText = (text) => formatDim(useColor, text);
+	const formatCyan = createColorFormatter(useColor, cyan);
+	if (result.migrations.length === 0) lines.push(`${prefix}${formatDimText("No migrations found")}`);
+	else {
+		lines.push(`${prefix}${formatDimText("∅ (empty)")}`);
+		lines.push(`${prefix}${formatDimText("│")}`);
+		for (let i = 0; i < result.migrations.length; i++) {
+			const entry = result.migrations[i];
+			const isLast = i === result.migrations.length - 1;
+			const treeChar = isLast ? "└" : "├";
+			const continueLine = isLast ? " " : "│";
+			let statusBadge = "";
+			if (entry.status === "applied") statusBadge = formatGreen("  ✓ Applied");
+			else if (entry.status === "pending") statusBadge = formatYellow("  ⧗ Pending");
+			let marker = "";
+			if (result.mode === "online") {
+				if (entry.status === "applied" && (i === result.migrations.length - 1 || result.migrations[i + 1]?.status !== "applied")) marker = formatCyan("  ◄ DB");
+			}
+			if (isLast && entry.to === result.contractHash) marker += `  ${formatCyan("◄ Contract")}`;
+			else if (isLast && result.contractHash !== entry.to) marker += `  ${formatYellow("◄ Contract is ahead — run migration plan")}`;
+			lines.push(`${prefix}${formatDimText(treeChar)}─ ${entry.dirName}${statusBadge}${marker}`);
+			const opsSummary = entry.hasDestructive ? formatYellow(entry.operationSummary) : formatDimText(entry.operationSummary);
+			lines.push(`${prefix}${formatDimText(continueLine)}    ${opsSummary}`);
+			const hashDisplay = entry.to.length > 20 ? `${entry.to.slice(0, 20)}...` : entry.to;
+			lines.push(`${prefix}${formatDimText(continueLine)}    ${formatDimText(`→ ${hashDisplay}`)}`);
+			if (!isLast) lines.push(`${prefix}${formatDimText("│")}`);
+		}
+		lines.push(`${prefix}`);
+		if (result.mode === "online") {
+			const hasUnknown = result.migrations.some((e) => e.status === "unknown");
+			const pendingCount = result.migrations.filter((e) => e.status === "pending").length;
+			if (hasUnknown) lines.push(`${prefix}${formatYellow("⚠")} ${result.summary}`);
+			else if (pendingCount === 0) lines.push(`${prefix}${formatGreen("✔")} ${result.summary}`);
+			else lines.push(`${prefix}${formatYellow("⧗")} ${result.summary}`);
+		} else lines.push(`${prefix}${result.summary}`);
+	}
+	const warnings = result.diagnostics?.filter((d) => d.severity === "warn") ?? [];
+	if (warnings.length > 0) {
+		lines.push("");
+		for (const diag of warnings) {
+			lines.push(`${prefix}${formatYellow("⚠")} ${diag.message}`);
+			for (const hint of diag.hints) lines.push(`${prefix}  ${formatDimText(hint)}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Formats human-readable output for migration commands (db init, db update) in apply mode.
+*/
+function formatMigrationApplyOutput(result, flags) {
+	if (flags.quiet) return "";
+	const lines = [];
+	const prefix = createPrefix(flags);
+	const useColor = flags.color !== false;
+	const formatGreen = createColorFormatter(useColor, green);
+	const formatDimText = (text) => formatDim(useColor, text);
+	if (result.ok) {
+		const executed = result.execution?.operationsExecuted ?? 0;
+		if (executed === 0) lines.push(`${prefix}${formatGreen("✔")} Database already matches contract`);
+		else lines.push(`${prefix}${formatGreen("✔")} Applied ${executed} operation(s)`);
+		if (result.marker) {
+			lines.push(`${prefix}${formatDimText(`  Signature: ${result.marker.storageHash}`)}`);
+			if (result.marker.profileHash) lines.push(`${prefix}${formatDimText(`  Profile hash: ${result.marker.profileHash}`)}`);
+		}
+		if (isVerbose(flags, 1)) lines.push(`${prefix}${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Formats JSON output for migration commands (db init, db update).
+*/
+function formatMigrationJson(result) {
+	return JSON.stringify(result, null, 2);
+}
+/**
+* Fixed width for left column in help output.
+*/
+const LEFT_COLUMN_WIDTH = 20;
+/**
+* Minimum width for right column wrapping in help output.
+*/
+const RIGHT_COLUMN_MIN_WIDTH = 40;
+/**
+* Maximum width for right column wrapping in help output (when terminal is wide enough).
+*/
+const RIGHT_COLUMN_MAX_WIDTH = 90;
+/**
+* Gets the terminal width, or returns a default if not available.
+*/
+function getTerminalWidth() {
+	const terminalWidth = process.stdout.columns;
+	const defaultWidth = Number.parseInt(process.env["CLI_WIDTH"] || "80", 10);
+	return terminalWidth || defaultWidth;
+}
+/**
+* Calculates the available width for the right column based on terminal width.
+* Format: "│ " (2) + left column (20) + "  " (2) + right column = total
+* So: right column = terminal width - 2 - 20 - 2 = terminal width - 24
+*/
+function calculateRightColumnWidth() {
+	const availableWidth = getTerminalWidth() - 2 - LEFT_COLUMN_WIDTH - 2;
+	return Math.max(RIGHT_COLUMN_MIN_WIDTH, Math.min(availableWidth, RIGHT_COLUMN_MAX_WIDTH));
+}
+/**
+* Creates an arrow segment badge with green background and white text.
+* Body: green background with white "prisma-next" text
+* Tip: dark grey arrow pointing right (Powerline separator)
+*/
+function createPrismaNextBadge(useColor) {
+	if (!useColor) return "prisma-next";
+	return `${bgGreen(bold(" prisma-next "))}${green("")}`;
+}
+/**
+* Creates a padding function.
+*/
+function createPadFunction() {
+	return (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+}
+/**
+* Formats a header line: brand + operation + intent
+*/
+function formatHeaderLine(options) {
+	if (options.operation) return `${options.brand} ${options.operation} → ${options.intent}`;
+	return `${options.brand} ${options.intent}`;
+}
+/**
+* Formats a "Read more" URL line.
+* The "Read more" label is in default color (not cyan), and the URL is blue.
+*/
+function formatReadMoreLine(options) {
+	const labelPadded = createPadFunction()("Read more", options.maxLabelWidth);
+	const valueColored = options.useColor ? blue(options.url) : options.url;
+	return `${options.formatDimText("│")} ${labelPadded}  ${valueColored}`;
+}
+/**
+* Pads text to a fixed width, accounting for ANSI escape codes.
+* Uses string-width to measure the actual display width.
+*/
+function padToFixedWidth(text, width) {
+	const actualWidth = stringWidth(text);
+	const padding = Math.max(0, width - actualWidth);
+	return text + " ".repeat(padding);
+}
+/**
+* Wraps text to fit within a specified width using wrap-ansi.
+* Preserves ANSI escape codes and breaks at word boundaries.
+*/
+function wrapTextAnsi(text, width) {
+	return wrapAnsi(text, width, {
+		hard: false,
+		trim: true
+	}).split("\n");
+}
+/**
+* Formats a default value as "default: <value>" with dimming.
+*/
+function formatDefaultValue(value, useColor) {
+	const defaultText = `default: ${String(value)}`;
+	return useColor ? dim(defaultText) : defaultText;
+}
+/**
+* Renders a command tree structure.
+* Handles both single-level (subcommands of a command) and multi-level (top-level commands with subcommands) trees.
+*/
+function renderCommandTree(options) {
+	const { commands, useColor, formatDimText, hasItemsAfter, continuationPrefix } = options;
+	const lines = [];
+	if (commands.length === 0) return lines;
+	for (let i = 0; i < commands.length; i++) {
+		const cmd = commands[i];
+		if (!cmd) continue;
+		const subcommands = cmd.commands.filter((subcmd) => !subcmd.name().startsWith("_"));
+		const isLastCommand = i === commands.length - 1;
+		if (subcommands.length > 0) {
+			const treePrefix = `${isLastCommand && !hasItemsAfter ? formatDimText("└") : formatDimText("├")}─ `;
+			const remainingWidth = LEFT_COLUMN_WIDTH - stringWidth(stripAnsi(treePrefix));
+			const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+			const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+			lines.push(`${formatDimText("│")} ${treePrefix}${commandNameColored}`);
+			for (let j = 0; j < subcommands.length; j++) {
+				const subcmd = subcommands[j];
+				if (!subcmd) continue;
+				const isLastSubcommand = j === subcommands.length - 1;
+				const shortDescription = subcmd.description() || "";
+				const treeChar = isLastSubcommand ? "└" : "├";
+				const continuation = continuationPrefix ?? (isLastCommand && isLastSubcommand && !hasItemsAfter ? " " : formatDimText("│"));
+				const subTreePrefix = `${continuation === " " ? " " : continuation}  ${formatDimText(treeChar)}─ `;
+				const subRemainingWidth = LEFT_COLUMN_WIDTH - stringWidth(stripAnsi(subTreePrefix));
+				const subcommandNamePadded = padToFixedWidth(subcmd.name(), subRemainingWidth);
+				const subcommandNameColored = useColor ? cyan(subcommandNamePadded) : subcommandNamePadded;
+				lines.push(`${formatDimText("│")} ${subTreePrefix}${subcommandNameColored}  ${shortDescription}`);
+			}
+		} else {
+			const treePrefix = `${isLastCommand && !hasItemsAfter ? formatDimText("└") : formatDimText("├")}─ `;
+			const remainingWidth = LEFT_COLUMN_WIDTH - stringWidth(stripAnsi(treePrefix));
+			const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+			const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+			const shortDescription = cmd.description() || "";
+			lines.push(`${formatDimText("│")} ${treePrefix}${commandNameColored}  ${shortDescription}`);
+		}
+	}
+	return lines;
+}
+/**
+* Formats multiline description with "Prisma Next" in green.
+* Wraps at the same right-hand boundary as the right column.
+* The right edge is defined by: left column (20) + gap (2) + right column (90) = 112 characters total.
+* Since the description line starts with "│ " (2 chars), the text wraps at 112 - 2 = 110 characters.
+*/
+function formatMultilineDescription(options) {
+	const lines = [];
+	const formatGreen = (text) => options.useColor ? green(text) : text;
+	const rightColumnWidth = calculateRightColumnWidth();
+	const wrapWidth = 2 + LEFT_COLUMN_WIDTH + 2 + rightColumnWidth - 2;
+	for (const descLine of options.descriptionLines) {
+		const wrappedLines = wrapTextAnsi(descLine.replace(/Prisma Next/g, (match) => formatGreen(match)), wrapWidth);
+		for (const wrappedLine of wrappedLines) lines.push(`${options.formatDimText("│")} ${wrappedLine}`);
+	}
+	return lines;
+}
+/**
+* Formats the header in the new experimental visual style.
+* This header appears at the start of command output, showing the operation,
+* intent, documentation link, and parameters.
+*/
+function formatStyledHeader(options) {
+	const lines = [];
+	const useColor = options.flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const brand = createPrismaNextBadge(useColor);
+	const operation = useColor ? bold(options.command) : options.command;
+	const intent = formatDimText(options.description);
+	lines.push(formatHeaderLine({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	for (const detail of options.details) {
+		const labelPadded = padToFixedWidth(`${detail.label}:`, LEFT_COLUMN_WIDTH);
+		const labelColored = useColor ? cyan(labelPadded) : labelPadded;
+		lines.push(`${formatDimText("│")} ${labelColored}  ${detail.value}`);
+	}
+	if (options.url) {
+		lines.push(formatDimText("│"));
+		lines.push(formatReadMoreLine({
+			url: options.url,
+			maxLabelWidth: LEFT_COLUMN_WIDTH,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Formats a success message in the styled output format.
+*/
+function formatSuccessMessage(flags) {
+	return `${createColorFormatter(flags.color !== false, green)("✔")} Success`;
+}
+/**
+* Maps command paths to their documentation URLs.
+*/
+function getCommandDocsUrl(commandPath) {
+	return {
+		"contract emit": "https://pris.ly/contract-emit",
+		"db verify": "https://pris.ly/db-verify",
+		"db update": "https://pris.ly/db-update"
+	}[commandPath];
+}
+/**
+* Builds the full command path from a command and its parents.
+*/
+function buildCommandPath(command) {
+	const parts = [];
+	let current = command;
+	while (current && current.name() !== "prisma-next") {
+		parts.unshift(current.name());
+		current = current.parent ?? void 0;
+	}
+	return parts.join(" ");
+}
+/**
+* Formats help output for a command using the styled format.
+*/
+function formatCommandHelp(options) {
+	const { command, flags } = options;
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const commandPath = buildCommandPath(command);
+	const shortDescription = command.description() || "";
+	const longDescription = getLongDescription(command);
+	const brand = createPrismaNextBadge(useColor);
+	const operation = useColor ? bold(commandPath) : commandPath;
+	const intent = formatDimText(shortDescription);
+	lines.push(formatHeaderLine({
+		brand,
+		operation,
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	const optionsList = command.options.map((opt) => {
+		return {
+			flags: opt.flags,
+			description: opt.description || "",
+			defaultValue: opt.defaultValue
+		};
+	});
+	const subcommands = command.commands.filter((cmd) => !cmd.name().startsWith("_"));
+	if (subcommands.length > 0) {
+		const treeLines = renderCommandTree({
+			commands: subcommands,
+			useColor,
+			formatDimText,
+			hasItemsAfter: optionsList.length > 0
+		});
+		lines.push(...treeLines);
+	}
+	if (subcommands.length > 0 && optionsList.length > 0) lines.push(formatDimText("│"));
+	if (optionsList.length > 0) for (const opt of optionsList) {
+		const flagsPadded = padToFixedWidth(opt.flags, LEFT_COLUMN_WIDTH);
+		let flagsColored = flagsPadded;
+		if (useColor) {
+			flagsColored = flagsPadded.replace(/(<[^>]+>)/g, (match) => magenta(match));
+			flagsColored = cyan(flagsColored);
+		}
+		const rightColumnWidth = calculateRightColumnWidth();
+		const wrappedDescription = wrapTextAnsi(opt.description, rightColumnWidth);
+		lines.push(`${formatDimText("│")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+		for (let i = 1; i < wrappedDescription.length; i++) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+		}
+		if (opt.defaultValue !== void 0) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${defaultText}`);
+		}
+	}
+	const docsUrl = getCommandDocsUrl(commandPath);
+	if (docsUrl) {
+		lines.push(formatDimText("│"));
+		lines.push(formatReadMoreLine({
+			url: docsUrl,
+			maxLabelWidth: LEFT_COLUMN_WIDTH,
+			useColor,
+			formatDimText
+		}));
+	}
+	if (longDescription) {
+		lines.push(formatDimText("│"));
+		const descriptionLines = longDescription.split("\n").filter((line) => line.trim().length > 0);
+		lines.push(...formatMultilineDescription({
+			descriptionLines,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Formats help output for the root program using the styled format.
+*/
+function formatRootHelp(options) {
+	const { program, flags } = options;
+	const lines = [];
+	const useColor = flags.color !== false;
+	const formatDimText = (text) => formatDim(useColor, text);
+	const brand = createPrismaNextBadge(useColor);
+	const intent = formatDimText("Manage your data layer");
+	lines.push(formatHeaderLine({
+		brand,
+		operation: "",
+		intent
+	}));
+	lines.push(formatDimText("│"));
+	const topLevelCommands = program.commands.filter((cmd) => !cmd.name().startsWith("_") && cmd.name() !== "help");
+	const globalOptions = program.options.map((opt) => {
+		return {
+			flags: opt.flags,
+			description: opt.description || "",
+			defaultValue: opt.defaultValue
+		};
+	});
+	if (topLevelCommands.length > 0) {
+		const treeLines = renderCommandTree({
+			commands: topLevelCommands,
+			useColor,
+			formatDimText,
+			hasItemsAfter: globalOptions.length > 0
+		});
+		lines.push(...treeLines);
+	}
+	if (topLevelCommands.length > 0 && globalOptions.length > 0) lines.push(formatDimText("│"));
+	if (globalOptions.length > 0) for (const opt of globalOptions) {
+		const flagsPadded = padToFixedWidth(opt.flags, LEFT_COLUMN_WIDTH);
+		let flagsColored = flagsPadded;
+		if (useColor) {
+			flagsColored = flagsPadded.replace(/(<[^>]+>)/g, (match) => magenta(match));
+			flagsColored = cyan(flagsColored);
+		}
+		const rightColumnWidth = calculateRightColumnWidth();
+		const wrappedDescription = wrapTextAnsi(opt.description, rightColumnWidth);
+		lines.push(`${formatDimText("│")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+		for (let i = 1; i < wrappedDescription.length; i++) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+		}
+		if (opt.defaultValue !== void 0) {
+			const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+			const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+			lines.push(`${formatDimText("│")} ${emptyLabel}  ${defaultText}`);
+		}
+	}
+	const formatGreen = (text) => useColor ? green(text) : text;
+	const descriptionLines = [`Use ${formatGreen("Prisma Next")} to define your data layer as a contract. Sign your database and application with the same contract to guarantee compatibility. Plan and apply migrations to safely evolve your schema.`];
+	if (descriptionLines.length > 0) {
+		lines.push(formatDimText("│"));
+		lines.push(...formatMultilineDescription({
+			descriptionLines,
+			useColor,
+			formatDimText
+		}));
+	}
+	lines.push(formatDimText("└"));
+	return `${lines.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/utils/result-handler.ts
+/**
+* Processes a CLI command result, handling both success and error cases.
+* Formats output appropriately and returns the exit code.
+* Never throws - returns exit code for commands to use with process.exit().
+*
+* @param result - The result from a CLI command
+* @param flags - Global flags for output formatting
+* @param onSuccess - Optional callback for successful results (for custom success output)
+* @returns The exit code that should be used (0 for success, non-zero for errors)
+*/
+function handleResult(result, flags, onSuccess) {
+	if (result.ok) {
+		if (onSuccess) onSuccess(result.value);
+		return 0;
+	}
+	const envelope = result.failure.toEnvelope();
+	if (flags.json) console.error(formatErrorJson(envelope));
+	else console.error(formatErrorOutput(envelope, flags));
+	return result.failure.domain === "CLI" ? 2 : 1;
+}
+
+//#endregion
+export { parseGlobalFlags as C, setCommandDescriptions as D, sanitizeErrorMessage as E, formatVerifyOutput as S, resolveContractPath as T, formatSignJson as _, formatIntrospectJson as a, formatSuccessMessage as b, formatMigrationApplyOutput as c, formatMigrationShowOutput as d, formatMigrationStatusOutput as f, formatSchemaVerifyOutput as g, formatSchemaVerifyJson as h, formatEmitOutput as i, formatMigrationJson as l, formatRootHelp as m, formatCommandHelp as n, formatIntrospectOutput as o, formatMigrationVerifyCommandOutput as p, formatEmitJson as r, formatMigrationApplyCommandOutput as s, handleResult as t, formatMigrationPlanOutput as u, formatSignOutput as v, maskConnectionUrl as w, formatVerifyJson as x, formatStyledHeader as y };
+//# sourceMappingURL=result-handler-iA9JtUC7.mjs.map