@prisma-next/cli 0.0.1

package/dist/cli.js

@@ -0,0 +1,1872 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/contract-emit.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, relative as relative2, resolve as resolve2 } from "path";
+import { errorContractConfigMissing as errorContractConfigMissing2 } from "@prisma-next/core-control-plane/errors";
+import { Command } from "commander";
+
+// src/config-loader.ts
+import { dirname, resolve } from "path";
+import { validateConfig } from "@prisma-next/core-control-plane/config-validation";
+import { errorConfigFileNotFound, errorUnexpected } from "@prisma-next/core-control-plane/errors";
+import { loadConfig as loadConfigC12 } from "c12";
+async function loadConfig(configPath) {
+  try {
+    const cwd = process.cwd();
+    const resolvedConfigPath = configPath ? resolve(cwd, configPath) : void 0;
+    const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
+    const result = await loadConfigC12({
+      name: "prisma-next",
+      ...resolvedConfigPath ? { configFile: resolvedConfigPath } : {},
+      cwd: configCwd
+    });
+    if (!result.config || Object.keys(result.config).length === 0) {
+      const displayPath = result.configFile || resolvedConfigPath || configPath;
+      throw errorConfigFileNotFound(displayPath);
+    }
+    validateConfig(result.config);
+    return result.config;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && typeof error.code === "string") {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.message.includes("not found") || error.message.includes("Cannot find") || error.message.includes("ENOENT")) {
+        const displayPath = configPath ? resolve(process.cwd(), configPath) : void 0;
+        throw errorConfigFileNotFound(displayPath, {
+          why: error.message
+        });
+      }
+      throw errorUnexpected(error.message, {
+        why: `Failed to load config: ${error.message}`
+      });
+    }
+    throw errorUnexpected(String(error));
+  }
+}
+
+// src/utils/command-helpers.ts
+function setCommandDescriptions(command, shortDescription, longDescription) {
+  command.description(shortDescription);
+  if (longDescription) {
+    command._longDescription = longDescription;
+  }
+  return command;
+}
+function getLongDescription(command) {
+  return command._longDescription;
+}
+
+// src/utils/global-flags.ts
+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.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;
+}
+
+// src/utils/output.ts
+import { relative } from "path";
+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";
+function formatTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createPrefix(flags) {
+  return flags.timestamps ? `[${formatTimestamp()}] ` : "";
+}
+function isVerbose(flags, level) {
+  return (flags.verbose ?? 0) >= level;
+}
+function createColorFormatter(useColor, colorFn) {
+  return useColor ? colorFn : (text) => text;
+}
+function formatDim(useColor, text) {
+  return useColor ? dim(text) : text;
+}
+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}\u2714 Emitted contract.json \u2192 ${jsonPath}`);
+  lines.push(`${prefix}\u2714 Emitted contract.d.ts \u2192 ${dtsPath}`);
+  lines.push(`${prefix}  coreHash: ${result.coreHash}`);
+  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");
+}
+function formatEmitJson(result) {
+  const output = {
+    ok: true,
+    coreHash: result.coreHash,
+    ...result.profileHash ? { profileHash: result.profileHash } : {},
+    outDir: result.outDir,
+    files: result.files,
+    timings: result.timings
+  };
+  return JSON.stringify(output, null, 2);
+}
+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("\u2716")} ${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.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");
+}
+function formatErrorJson(error) {
+  return JSON.stringify(error, null, 2);
+}
+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("\u2714")} ${result.summary}`);
+    lines.push(`${prefix}${formatDimText(`  coreHash: ${result.contract.coreHash}`)}`);
+    if (result.contract.profileHash) {
+      lines.push(`${prefix}${formatDimText(`  profileHash: ${result.contract.profileHash}`)}`);
+    }
+  } else {
+    lines.push(`${prefix}${formatRed("\u2716")} ${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");
+}
+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);
+}
+function formatIntrospectJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+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 prefix2 = indexMatch[1] ? `${dim("unique")} ` : "";
+              const name = indexMatch[2];
+              formattedLabel = `${prefix2}${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 treeChar = isLast ? "\u2514" : "\u251C";
+    const treePrefix = `${prefix}${formatDimText(treeChar)}\u2500 `;
+    const isRootChild = prefix === "";
+    const prefixWithoutAnsi = stripAnsi(prefix);
+    const prefixHasVerticalBar = prefixWithoutAnsi.includes("\u2502");
+    if (isRootChild) {
+      lines.push(`${treePrefix}${formattedLabel}`);
+    } else if (prefixHasVerticalBar) {
+      lines.push(`${treePrefix}${formattedLabel}`);
+    } else {
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${formattedLabel}`);
+    }
+  }
+  if (node.children && node.children.length > 0) {
+    const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("\u2502")}  `;
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (!child) continue;
+      const isLastChild = i === node.children.length - 1;
+      const childLines = renderSchemaTree(child, flags, {
+        isLast: isLastChild,
+        prefix: childPrefix,
+        useColor,
+        formatDimText,
+        isRoot: false
+      });
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+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 treeLines = renderSchemaTree(schemaView.root, flags, {
+      isLast: true,
+      prefix: "",
+      useColor,
+      formatDimText,
+      isRoot: true
+    });
+    const prefixedTreeLines = treeLines.map((line) => `${prefix}${line}`);
+    lines.push(...prefixedTreeLines);
+  } else {
+    lines.push(`${prefix}\u2714 ${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");
+}
+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 = "\u2714";
+        statusColor = green;
+        break;
+      case "warn":
+        statusGlyph = "\u26A0";
+        statusColor = (text) => useColor ? yellow(text) : text;
+        break;
+      case "fail":
+        statusGlyph = "\u2716";
+        statusColor = red;
+        break;
+    }
+  } else {
+    switch (node.status) {
+      case "pass":
+        statusGlyph = "\u2714";
+        break;
+      case "warn":
+        statusGlyph = "\u26A0";
+        break;
+      case "fail":
+        statusGlyph = "\u2716";
+        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} \u2192 ${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 treeChar = isLast ? "\u2514" : "\u251C";
+    const treePrefix = `${prefix}${formatDimText(treeChar)}\u2500 `;
+    const isRootChild = prefix === "";
+    const prefixWithoutAnsi = stripAnsi(prefix);
+    const prefixHasVerticalBar = prefixWithoutAnsi.includes("\u2502");
+    if (isRootChild) {
+      lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    } else if (prefixHasVerticalBar) {
+      lines.push(`${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    } else {
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${statusGlyphColored} ${nodeLabel}`);
+    }
+  }
+  if (node.children && node.children.length > 0) {
+    const childPrefix = isRoot ? "" : isLast ? `${prefix}   ` : `${prefix}${formatDimText("\u2502")}  `;
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (!child) continue;
+      const isLastChild = i === node.children.length - 1;
+      const childLines = renderSchemaVerificationTree(child, flags, {
+        isLast: isLastChild,
+        prefix: childPrefix,
+        useColor,
+        formatDimText,
+        isRoot: false
+      });
+      lines.push(...childLines);
+    }
+  }
+  return lines;
+}
+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 treeLines = renderSchemaVerificationTree(result.schema.root, flags, {
+    isLast: true,
+    prefix: "",
+    useColor,
+    formatDimText,
+    isRoot: true
+  });
+  const prefixedTreeLines = treeLines.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("\u2714")} ${result.summary}`);
+  } else {
+    const codeText = result.code ? ` (${result.code})` : "";
+    lines.push(`${prefix}${formatRed("\u2716")} ${result.summary}${codeText}`);
+  }
+  return lines.join("\n");
+}
+function formatSchemaVerifyJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+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("\u2714")} Database signed`);
+    const previousHash = result.marker.previous?.coreHash ?? "none";
+    const currentHash = result.contract.coreHash;
+    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");
+}
+function formatSignJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+var LEFT_COLUMN_WIDTH = 20;
+var RIGHT_COLUMN_MIN_WIDTH = 40;
+var RIGHT_COLUMN_MAX_WIDTH = 90;
+function getTerminalWidth() {
+  const terminalWidth = process.stdout.columns;
+  const defaultWidth = Number.parseInt(process.env["CLI_WIDTH"] || "80", 10);
+  return terminalWidth || defaultWidth;
+}
+function calculateRightColumnWidth() {
+  const terminalWidth = getTerminalWidth();
+  const availableWidth = terminalWidth - 2 - LEFT_COLUMN_WIDTH - 2;
+  return Math.max(RIGHT_COLUMN_MIN_WIDTH, Math.min(availableWidth, RIGHT_COLUMN_MAX_WIDTH));
+}
+function createPrismaNextBadge(useColor) {
+  if (!useColor) {
+    return "prisma-next";
+  }
+  const text = " prisma-next ";
+  const body = bgGreen(bold(text));
+  const separator = "\uE0B0";
+  const tip = green(separator);
+  return `${body}${tip}`;
+}
+function createPadFunction() {
+  return (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+}
+function formatHeaderLine(options) {
+  if (options.operation) {
+    return `${options.brand} ${options.operation} \u2192 ${options.intent}`;
+  }
+  return `${options.brand} ${options.intent}`;
+}
+function formatReadMoreLine(options) {
+  const pad = createPadFunction();
+  const labelPadded = pad("Read more", options.maxLabelWidth);
+  const valueColored = options.useColor ? blue(options.url) : options.url;
+  return `${options.formatDimText("\u2502")} ${labelPadded}  ${valueColored}`;
+}
+function padToFixedWidth(text, width) {
+  const actualWidth = stringWidth(text);
+  const padding = Math.max(0, width - actualWidth);
+  return text + " ".repeat(padding);
+}
+function wrapTextAnsi(text, width) {
+  const wrapped = wrapAnsi(text, width, { hard: false, trim: true });
+  return wrapped.split("\n");
+}
+function formatDefaultValue(value, useColor) {
+  const valueStr = String(value);
+  const defaultText = `default: ${valueStr}`;
+  return useColor ? dim(defaultText) : defaultText;
+}
+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 prefix = isLastCommand && !hasItemsAfter ? formatDimText("\u2514") : formatDimText("\u251C");
+      const treePrefix = `${prefix}\u2500 `;
+      const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+      const remainingWidth = LEFT_COLUMN_WIDTH - treePrefixWidth;
+      const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+      const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+      lines.push(`${formatDimText("\u2502")} ${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 ? "\u2514" : "\u251C";
+        const continuation = continuationPrefix ?? (isLastCommand && isLastSubcommand && !hasItemsAfter ? " " : formatDimText("\u2502"));
+        const continuationStr = continuation === " " ? " " : continuation;
+        const subTreePrefix = `${continuationStr}  ${formatDimText(treeChar)}\u2500 `;
+        const subTreePrefixWidth = stringWidth(stripAnsi(subTreePrefix));
+        const subRemainingWidth = LEFT_COLUMN_WIDTH - subTreePrefixWidth;
+        const subcommandNamePadded = padToFixedWidth(subcmd.name(), subRemainingWidth);
+        const subcommandNameColored = useColor ? cyan(subcommandNamePadded) : subcommandNamePadded;
+        lines.push(
+          `${formatDimText("\u2502")} ${subTreePrefix}${subcommandNameColored}  ${shortDescription}`
+        );
+      }
+    } else {
+      const prefix = isLastCommand && !hasItemsAfter ? formatDimText("\u2514") : formatDimText("\u251C");
+      const treePrefix = `${prefix}\u2500 `;
+      const treePrefixWidth = stringWidth(stripAnsi(treePrefix));
+      const remainingWidth = LEFT_COLUMN_WIDTH - treePrefixWidth;
+      const commandNamePadded = padToFixedWidth(cmd.name(), remainingWidth);
+      const commandNameColored = useColor ? cyan(commandNamePadded) : commandNamePadded;
+      const shortDescription = cmd.description() || "";
+      lines.push(`${formatDimText("\u2502")} ${treePrefix}${commandNameColored}  ${shortDescription}`);
+    }
+  }
+  return lines;
+}
+function formatMultilineDescription(options) {
+  const lines = [];
+  const formatGreen = (text) => options.useColor ? green(text) : text;
+  const rightColumnWidth = calculateRightColumnWidth();
+  const totalWidth = 2 + LEFT_COLUMN_WIDTH + 2 + rightColumnWidth;
+  const wrapWidth = totalWidth - 2;
+  for (const descLine of options.descriptionLines) {
+    const formattedLine = descLine.replace(/Prisma Next/g, (match) => formatGreen(match));
+    const wrappedLines = wrapTextAnsi(formattedLine, wrapWidth);
+    for (const wrappedLine of wrappedLines) {
+      lines.push(`${options.formatDimText("\u2502")} ${wrappedLine}`);
+    }
+  }
+  return lines;
+}
+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("\u2502"));
+  for (const detail of options.details) {
+    const labelWithColon = `${detail.label}:`;
+    const labelPadded = padToFixedWidth(labelWithColon, LEFT_COLUMN_WIDTH);
+    const labelColored = useColor ? cyan(labelPadded) : labelPadded;
+    lines.push(`${formatDimText("\u2502")} ${labelColored}  ${detail.value}`);
+  }
+  if (options.url) {
+    lines.push(formatDimText("\u2502"));
+    lines.push(
+      formatReadMoreLine({
+        url: options.url,
+        maxLabelWidth: LEFT_COLUMN_WIDTH,
+        useColor,
+        formatDimText
+      })
+    );
+  }
+  lines.push(formatDimText("\u2514"));
+  return `${lines.join("\n")}
+`;
+}
+function formatSuccessMessage(flags) {
+  const useColor = flags.color !== false;
+  const formatGreen = createColorFormatter(useColor, green);
+  return `${formatGreen("\u2714")} Success`;
+}
+function getCommandDocsUrl(commandPath) {
+  const docsMap = {
+    "contract emit": "https://pris.ly/contract-emit",
+    "db verify": "https://pris.ly/db-verify"
+  };
+  return docsMap[commandPath];
+}
+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(" ");
+}
+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("\u2502"));
+  const optionsList = command.options.map((opt) => {
+    const flags2 = opt.flags;
+    const description = opt.description || "";
+    const defaultValue = opt.defaultValue;
+    return { flags: flags2, description, defaultValue };
+  });
+  const subcommands = command.commands.filter((cmd) => !cmd.name().startsWith("_"));
+  if (subcommands.length > 0) {
+    const hasItemsAfter = optionsList.length > 0;
+    const treeLines = renderCommandTree({
+      commands: subcommands,
+      useColor,
+      formatDimText,
+      hasItemsAfter
+    });
+    lines.push(...treeLines);
+  }
+  if (subcommands.length > 0 && optionsList.length > 0) {
+    lines.push(formatDimText("\u2502"));
+  }
+  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("\u2502")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+      for (let i = 1; i < wrappedDescription.length; i++) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        lines.push(`${formatDimText("\u2502")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+      }
+      if (opt.defaultValue !== void 0) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+        lines.push(`${formatDimText("\u2502")} ${emptyLabel}  ${defaultText}`);
+      }
+    }
+  }
+  const docsUrl = getCommandDocsUrl(commandPath);
+  if (docsUrl) {
+    lines.push(formatDimText("\u2502"));
+    lines.push(
+      formatReadMoreLine({
+        url: docsUrl,
+        maxLabelWidth: LEFT_COLUMN_WIDTH,
+        useColor,
+        formatDimText
+      })
+    );
+  }
+  if (longDescription) {
+    lines.push(formatDimText("\u2502"));
+    const descriptionLines = longDescription.split("\n").filter((line) => line.trim().length > 0);
+    lines.push(...formatMultilineDescription({ descriptionLines, useColor, formatDimText }));
+  }
+  lines.push(formatDimText("\u2514"));
+  return `${lines.join("\n")}
+`;
+}
+function formatRootHelp(options) {
+  const { program: program2, flags } = options;
+  const lines = [];
+  const useColor = flags.color !== false;
+  const formatDimText = (text) => formatDim(useColor, text);
+  const brand = createPrismaNextBadge(useColor);
+  const shortDescription = "Manage your data layer";
+  const intent = formatDimText(shortDescription);
+  lines.push(formatHeaderLine({ brand, operation: "", intent }));
+  lines.push(formatDimText("\u2502"));
+  const topLevelCommands = program2.commands.filter(
+    (cmd) => !cmd.name().startsWith("_") && cmd.name() !== "help"
+  );
+  const globalOptions = program2.options.map((opt) => {
+    const flags2 = opt.flags;
+    const description = opt.description || "";
+    const defaultValue = opt.defaultValue;
+    return { flags: flags2, description, defaultValue };
+  });
+  if (topLevelCommands.length > 0) {
+    const hasItemsAfter = globalOptions.length > 0;
+    const treeLines = renderCommandTree({
+      commands: topLevelCommands,
+      useColor,
+      formatDimText,
+      hasItemsAfter
+    });
+    lines.push(...treeLines);
+  }
+  if (topLevelCommands.length > 0 && globalOptions.length > 0) {
+    lines.push(formatDimText("\u2502"));
+  }
+  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("\u2502")} ${flagsColored}  ${wrappedDescription[0] || ""}`);
+      for (let i = 1; i < wrappedDescription.length; i++) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        lines.push(`${formatDimText("\u2502")} ${emptyLabel}  ${wrappedDescription[i] || ""}`);
+      }
+      if (opt.defaultValue !== void 0) {
+        const emptyLabel = " ".repeat(LEFT_COLUMN_WIDTH);
+        const defaultText = formatDefaultValue(opt.defaultValue, useColor);
+        lines.push(`${formatDimText("\u2502")} ${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("\u2502"));
+    lines.push(...formatMultilineDescription({ descriptionLines, useColor, formatDimText }));
+  }
+  lines.push(formatDimText("\u2514"));
+  return `${lines.join("\n")}
+`;
+}
+
+// src/utils/cli-errors.ts
+import {
+  CliStructuredError,
+  errorConfigFileNotFound as errorConfigFileNotFound2,
+  errorConfigValidation,
+  errorContractConfigMissing,
+  errorContractValidationFailed,
+  errorDatabaseUrlRequired,
+  errorDriverRequired,
+  errorFamilyReadMarkerSqlRequired,
+  errorFileNotFound,
+  errorHashMismatch,
+  errorMarkerMissing,
+  errorQueryRunnerFactoryRequired,
+  errorRuntime,
+  errorTargetMismatch,
+  errorUnexpected as errorUnexpected2
+} from "@prisma-next/core-control-plane/errors";
+
+// src/utils/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+async function performAction(fn) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (error) {
+    if (error instanceof CliStructuredError) {
+      return err(error);
+    }
+    throw error;
+  }
+}
+
+// src/utils/result-handler.ts
+function handleResult(result, flags, onSuccess) {
+  if (result.ok) {
+    if (onSuccess) {
+      onSuccess(result.value);
+    }
+    return 0;
+  }
+  const envelope = result.error.toEnvelope();
+  if (flags.json === "object") {
+    console.error(formatErrorJson(envelope));
+  } else {
+    console.error(formatErrorOutput(envelope, flags));
+  }
+  const exitCode = result.error.domain === "CLI" ? 2 : 1;
+  return exitCode;
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+async function withSpinner(operation, options) {
+  const { message, flags, delayThreshold = 100 } = options;
+  const shouldShowSpinner = !flags.quiet && flags.json !== "object" && process.stdout.isTTY;
+  if (!shouldShowSpinner) {
+    return operation();
+  }
+  const startTime = Date.now();
+  let spinner = null;
+  let timeoutId = null;
+  let operationCompleted = false;
+  timeoutId = setTimeout(() => {
+    if (!operationCompleted) {
+      spinner = ora({
+        text: message,
+        color: flags.color !== false ? "cyan" : false
+      }).start();
+    }
+  }, delayThreshold);
+  try {
+    const result = await operation();
+    operationCompleted = true;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (spinner !== null) {
+      const elapsed = Date.now() - startTime;
+      spinner.succeed(`${message} (${elapsed}ms)`);
+    }
+    return result;
+  } catch (error) {
+    operationCompleted = true;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (spinner !== null) {
+      spinner.fail(
+        `${message} failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/commands/contract-emit.ts
+function createContractEmitCommand() {
+  const command = new Command("emit");
+  setCommandDescriptions(
+    command,
+    "Write your contract to JSON and sign it",
+    "Reads your contract source (TypeScript or Prisma schema) and emits contract.json and\ncontract.d.ts. The contract.json contains the canonical contract structure, and\ncontract.d.ts provides TypeScript types for type-safe query building."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--config <path>", "Path to prisma-next.config.ts").option("--json [format]", "Output as JSON (object or ndjson)", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const result = await performAction(async () => {
+      const config = await loadConfig(options.config);
+      if (!config.contract) {
+        throw errorContractConfigMissing2({
+          why: "Config.contract is required for emit. Define it in your config: contract: { source: ..., output: ..., types: ... }"
+        });
+      }
+      const contractConfig = config.contract;
+      if (!contractConfig.output || !contractConfig.types) {
+        throw errorContractConfigMissing2({
+          why: "Contract config must have output and types paths. This should not happen if defineConfig() was used."
+        });
+      }
+      const outputJsonPath = resolve2(contractConfig.output);
+      const outputDtsPath = resolve2(contractConfig.types);
+      if (flags.json !== "object" && !flags.quiet) {
+        const configPath = options.config ? relative2(process.cwd(), resolve2(options.config)) : "prisma-next.config.ts";
+        const contractPath = relative2(process.cwd(), outputJsonPath);
+        const typesPath = relative2(process.cwd(), outputDtsPath);
+        const header = formatStyledHeader({
+          command: "contract emit",
+          description: "Write your contract to JSON and sign it",
+          url: "https://pris.ly/contract-emit",
+          details: [
+            { label: "config", value: configPath },
+            { label: "contract", value: contractPath },
+            { label: "types", value: typesPath }
+          ],
+          flags
+        });
+        console.log(header);
+      }
+      if (!config.driver) {
+        throw errorContractConfigMissing2({
+          why: "Config.driver is required. Even though emit does not use the driver, it is required by ControlFamilyDescriptor.create()"
+        });
+      }
+      const familyInstance = config.family.create({
+        target: config.target,
+        adapter: config.adapter,
+        driver: config.driver,
+        extensions: config.extensions ?? []
+      });
+      let contractRaw;
+      if (typeof contractConfig.source === "function") {
+        contractRaw = await contractConfig.source();
+      } else {
+        contractRaw = contractConfig.source;
+      }
+      const emitResult = await withSpinner(
+        () => familyInstance.emitContract({ contractIR: contractRaw }),
+        {
+          message: "Emitting contract...",
+          flags
+        }
+      );
+      mkdirSync(dirname2(outputJsonPath), { recursive: true });
+      mkdirSync(dirname2(outputDtsPath), { recursive: true });
+      writeFileSync(outputJsonPath, emitResult.contractJson, "utf-8");
+      writeFileSync(outputDtsPath, emitResult.contractDts, "utf-8");
+      if (!flags.quiet && flags.json !== "object" && process.stdout.isTTY) {
+        console.log("");
+      }
+      return {
+        coreHash: emitResult.coreHash,
+        profileHash: emitResult.profileHash,
+        outDir: dirname2(outputJsonPath),
+        files: {
+          json: outputJsonPath,
+          dts: outputDtsPath
+        },
+        timings: {
+          total: 0
+          // Timing is handled by emitContract internally if needed
+        }
+      };
+    });
+    const exitCode = handleResult(result, flags, (emitResult) => {
+      if (flags.json === "object") {
+        console.log(formatEmitJson(emitResult));
+      } else {
+        const output = formatEmitOutput(emitResult, flags);
+        if (output) {
+          console.log(output);
+        }
+        if (!flags.quiet) {
+          console.log(formatSuccessMessage(flags));
+        }
+      }
+    });
+    process.exit(exitCode);
+  });
+  return command;
+}
+
+// src/commands/db-introspect.ts
+import { readFile } from "fs/promises";
+import { relative as relative3, resolve as resolve3 } from "path";
+import {
+  errorDatabaseUrlRequired as errorDatabaseUrlRequired2,
+  errorDriverRequired as errorDriverRequired2,
+  errorRuntime as errorRuntime2,
+  errorUnexpected as errorUnexpected3
+} from "@prisma-next/core-control-plane/errors";
+import { Command as Command2 } from "commander";
+function createDbIntrospectCommand() {
+  const command = new Command2("introspect");
+  setCommandDescriptions(
+    command,
+    "Inspect the database schema",
+    "Reads the live database schema and displays it as a tree structure. This command\ndoes not check the schema against your contract - it only shows what exists in\nthe database. Use `db verify` or `db schema-verify` to compare against your contract."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--json [format]", "Output as JSON (object or ndjson)", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const result = await performAction(async () => {
+      const startTime = Date.now();
+      const config = await loadConfig(options.config);
+      const configPath = options.config ? relative3(process.cwd(), resolve3(options.config)) : "prisma-next.config.ts";
+      let contractIR;
+      if (config.contract?.output) {
+        const contractPath = resolve3(config.contract.output);
+        try {
+          const contractJsonContent = await readFile(contractPath, "utf-8");
+          const contractJson = JSON.parse(contractJsonContent);
+          contractIR = contractJson;
+        } catch (error) {
+          if (error instanceof Error && error.code !== "ENOENT") {
+            throw errorUnexpected3(error.message, {
+              why: `Failed to read contract file: ${error.message}`
+            });
+          }
+        }
+      }
+      if (flags.json !== "object" && !flags.quiet) {
+        const details = [
+          { label: "config", value: configPath }
+        ];
+        if (options.db) {
+          const maskedUrl = options.db.replace(/:([^:@]+)@/, ":****@");
+          details.push({ label: "database", value: maskedUrl });
+        } else if (config.db?.url) {
+          const maskedUrl = config.db.url.replace(/:([^:@]+)@/, ":****@");
+          details.push({ label: "database", value: maskedUrl });
+        }
+        const header = formatStyledHeader({
+          command: "db introspect",
+          description: "Inspect the database schema",
+          url: "https://pris.ly/db-introspect",
+          details,
+          flags
+        });
+        console.log(header);
+      }
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired2();
+      }
+      if (!config.driver) {
+        throw errorDriverRequired2();
+      }
+      const driverDescriptor = config.driver;
+      const driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
+        message: "Connecting to database...",
+        flags
+      });
+      try {
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: driverDescriptor,
+          extensions: config.extensions ?? []
+        });
+        const typedFamilyInstance = familyInstance;
+        if (contractIR) {
+          contractIR = typedFamilyInstance.validateContractIR(contractIR);
+        }
+        let schemaIR;
+        try {
+          schemaIR = await withSpinner(
+            () => typedFamilyInstance.introspect({
+              driver,
+              contractIR
+            }),
+            {
+              message: "Introspecting database schema...",
+              flags
+            }
+          );
+        } catch (error) {
+          throw errorRuntime2(error instanceof Error ? error.message : String(error), {
+            why: `Failed to introspect database: ${error instanceof Error ? error.message : String(error)}`
+          });
+        }
+        let schemaView;
+        if (typedFamilyInstance.toSchemaView) {
+          try {
+            schemaView = typedFamilyInstance.toSchemaView(schemaIR);
+          } catch (error) {
+            if (flags.verbose) {
+              console.error(
+                `Warning: Failed to project schema to view: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+        }
+        const totalTime = Date.now() - startTime;
+        if (!flags.quiet && flags.json !== "object" && process.stdout.isTTY) {
+          console.log("");
+        }
+        const introspectResult = {
+          ok: true,
+          summary: "Schema introspected successfully",
+          target: {
+            familyId: config.family.familyId,
+            id: config.target.targetId
+          },
+          schema: schemaIR,
+          ...configPath || options.db || config.db?.url ? {
+            meta: {
+              ...configPath ? { configPath } : {},
+              ...options.db || config.db?.url ? {
+                dbUrl: (options.db ?? config.db?.url ?? "").replace(
+                  /:([^:@]+)@/,
+                  ":****@"
+                )
+              } : {}
+            }
+          } : {},
+          timings: {
+            total: totalTime
+          }
+        };
+        return { introspectResult, schemaView };
+      } finally {
+        await driver.close();
+      }
+    });
+    const exitCode = handleResult(result, flags, (value) => {
+      const { introspectResult, schemaView } = value;
+      if (flags.json === "object") {
+        console.log(formatIntrospectJson(introspectResult));
+      } else {
+        const output = formatIntrospectOutput(introspectResult, schemaView, flags);
+        if (output) {
+          console.log(output);
+        }
+      }
+    });
+    process.exit(exitCode);
+  });
+  return command;
+}
+
+// src/commands/db-schema-verify.ts
+import { readFile as readFile2 } from "fs/promises";
+import { relative as relative4, resolve as resolve4 } from "path";
+import {
+  errorDatabaseUrlRequired as errorDatabaseUrlRequired3,
+  errorDriverRequired as errorDriverRequired3,
+  errorFileNotFound as errorFileNotFound2,
+  errorRuntime as errorRuntime3,
+  errorUnexpected as errorUnexpected4
+} from "@prisma-next/core-control-plane/errors";
+import { Command as Command3 } from "commander";
+function createDbSchemaVerifyCommand() {
+  const command = new Command3("schema-verify");
+  setCommandDescriptions(
+    command,
+    "Check whether the database schema satisfies your contract",
+    "Verifies that your database schema satisfies the emitted contract. Compares table structures,\ncolumn types, constraints, and extensions. Reports any mismatches via a contract-shaped\nverification tree. This is a read-only operation that does not modify the database."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--json [format]", "Output as JSON (object or ndjson)", false).option("--strict", "Strict mode: extra schema elements cause failures", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const result = await performAction(async () => {
+      const config = await loadConfig(options.config);
+      const configPath = options.config ? relative4(process.cwd(), resolve4(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve4(config.contract.output) : resolve4("src/prisma/contract.json");
+      const contractPath = relative4(process.cwd(), contractPathAbsolute);
+      if (flags.json !== "object" && !flags.quiet) {
+        const details = [
+          { label: "config", value: configPath },
+          { label: "contract", value: contractPath }
+        ];
+        if (options.db) {
+          details.push({ label: "database", value: options.db });
+        }
+        const header = formatStyledHeader({
+          command: "db schema-verify",
+          description: "Check whether the database schema satisfies your contract",
+          url: "https://pris.ly/db-schema-verify",
+          details,
+          flags
+        });
+        console.log(header);
+      }
+      let contractJsonContent;
+      try {
+        contractJsonContent = await readFile2(contractPathAbsolute, "utf-8");
+      } catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+          throw errorFileNotFound2(contractPathAbsolute, {
+            why: `Contract file not found at ${contractPathAbsolute}`
+          });
+        }
+        throw errorUnexpected4(error instanceof Error ? error.message : String(error), {
+          why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      const contractJson = JSON.parse(contractJsonContent);
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired3();
+      }
+      if (!config.driver) {
+        throw errorDriverRequired3();
+      }
+      const driverDescriptor = config.driver;
+      const driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
+        message: "Connecting to database...",
+        flags
+      });
+      try {
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: driverDescriptor,
+          extensions: config.extensions ?? []
+        });
+        const typedFamilyInstance = familyInstance;
+        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
+        let schemaVerifyResult;
+        try {
+          schemaVerifyResult = await withSpinner(
+            () => typedFamilyInstance.schemaVerify({
+              driver,
+              contractIR,
+              strict: options.strict ?? false,
+              contractPath: contractPathAbsolute,
+              configPath
+            }),
+            {
+              message: "Verifying database schema...",
+              flags
+            }
+          );
+        } catch (error) {
+          throw errorRuntime3(error instanceof Error ? error.message : String(error), {
+            why: `Failed to verify database schema: ${error instanceof Error ? error.message : String(error)}`
+          });
+        }
+        if (!flags.quiet && flags.json !== "object" && process.stdout.isTTY) {
+          console.log("");
+        }
+        return schemaVerifyResult;
+      } finally {
+        await driver.close();
+      }
+    });
+    const exitCode = handleResult(result, flags, (schemaVerifyResult) => {
+      if (flags.json === "object") {
+        console.log(formatSchemaVerifyJson(schemaVerifyResult));
+      } else {
+        const output = formatSchemaVerifyOutput(schemaVerifyResult, flags);
+        if (output) {
+          console.log(output);
+        }
+      }
+    });
+    if (result.ok && !result.value.ok) {
+      process.exit(1);
+    } else {
+      process.exit(exitCode);
+    }
+  });
+  return command;
+}
+
+// src/commands/db-sign.ts
+import { readFile as readFile3 } from "fs/promises";
+import { relative as relative5, resolve as resolve5 } from "path";
+import {
+  errorDatabaseUrlRequired as errorDatabaseUrlRequired4,
+  errorDriverRequired as errorDriverRequired4,
+  errorFileNotFound as errorFileNotFound3,
+  errorRuntime as errorRuntime4,
+  errorUnexpected as errorUnexpected5
+} from "@prisma-next/core-control-plane/errors";
+import { Command as Command4 } from "commander";
+function createDbSignCommand() {
+  const command = new Command4("sign");
+  setCommandDescriptions(
+    command,
+    "Sign the database with your contract so you can safely run queries",
+    "Verifies that your database schema satisfies the emitted contract, and if so, writes or\nupdates the contract marker in the database. This command is idempotent and safe to run\nin CI/deployment pipelines. The marker records that this database instance is aligned\nwith a specific contract version."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--json [format]", "Output as JSON (object or ndjson)", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const result = await performAction(async () => {
+      const config = await loadConfig(options.config);
+      const configPath = options.config ? relative5(process.cwd(), resolve5(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve5(config.contract.output) : resolve5("src/prisma/contract.json");
+      const contractPath = relative5(process.cwd(), contractPathAbsolute);
+      if (flags.json !== "object" && !flags.quiet) {
+        const details = [
+          { label: "config", value: configPath },
+          { label: "contract", value: contractPath }
+        ];
+        if (options.db) {
+          details.push({ label: "database", value: options.db });
+        }
+        const header = formatStyledHeader({
+          command: "db sign",
+          description: "Sign the database with your contract so you can safely run queries",
+          url: "https://pris.ly/db-sign",
+          details,
+          flags
+        });
+        console.log(header);
+      }
+      let contractJsonContent;
+      try {
+        contractJsonContent = await readFile3(contractPathAbsolute, "utf-8");
+      } catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+          throw errorFileNotFound3(contractPathAbsolute, {
+            why: `Contract file not found at ${contractPathAbsolute}`
+          });
+        }
+        throw errorUnexpected5(error instanceof Error ? error.message : String(error), {
+          why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      const contractJson = JSON.parse(contractJsonContent);
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired4();
+      }
+      if (!config.driver) {
+        throw errorDriverRequired4();
+      }
+      const driverDescriptor = config.driver;
+      const driver = await driverDescriptor.create(dbUrl);
+      try {
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: driverDescriptor,
+          extensions: config.extensions ?? []
+        });
+        const typedFamilyInstance = familyInstance;
+        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
+        let schemaVerifyResult;
+        try {
+          schemaVerifyResult = await withSpinner(
+            async () => {
+              return await typedFamilyInstance.schemaVerify({
+                driver,
+                contractIR,
+                strict: false,
+                contractPath: contractPathAbsolute,
+                configPath
+              });
+            },
+            {
+              message: "Verifying database satisfies contract",
+              flags
+            }
+          );
+        } catch (error) {
+          throw errorRuntime4(error instanceof Error ? error.message : String(error), {
+            why: `Failed to verify database schema: ${error instanceof Error ? error.message : String(error)}`
+          });
+        }
+        if (!schemaVerifyResult.ok) {
+          return { schemaVerifyResult, signResult: void 0 };
+        }
+        let signResult;
+        try {
+          signResult = await withSpinner(
+            async () => {
+              return await typedFamilyInstance.sign({
+                driver,
+                contractIR,
+                contractPath: contractPathAbsolute,
+                configPath
+              });
+            },
+            {
+              message: "Signing database...",
+              flags
+            }
+          );
+        } catch (error) {
+          throw errorRuntime4(error instanceof Error ? error.message : String(error), {
+            why: `Failed to sign database: ${error instanceof Error ? error.message : String(error)}`
+          });
+        }
+        if (!flags.quiet && flags.json !== "object" && process.stdout.isTTY) {
+          console.log("");
+        }
+        return { schemaVerifyResult: void 0, signResult };
+      } finally {
+        await driver.close();
+      }
+    });
+    const exitCode = handleResult(result, flags, (value) => {
+      const { schemaVerifyResult, signResult } = value;
+      if (schemaVerifyResult && !schemaVerifyResult.ok) {
+        if (flags.json === "object") {
+          console.log(formatSchemaVerifyJson(schemaVerifyResult));
+        } else {
+          const output = formatSchemaVerifyOutput(schemaVerifyResult, flags);
+          if (output) {
+            console.log(output);
+          }
+        }
+        return;
+      }
+      if (signResult) {
+        if (flags.json === "object") {
+          console.log(formatSignJson(signResult));
+        } else {
+          const output = formatSignOutput(signResult, flags);
+          if (output) {
+            console.log(output);
+          }
+        }
+      }
+    });
+    if (result.ok && result.value.schemaVerifyResult && !result.value.schemaVerifyResult.ok) {
+      process.exit(1);
+    } else {
+      process.exit(exitCode);
+    }
+  });
+  return command;
+}
+
+// src/commands/db-verify.ts
+import { readFile as readFile4 } from "fs/promises";
+import { relative as relative6, resolve as resolve6 } from "path";
+import {
+  errorDatabaseUrlRequired as errorDatabaseUrlRequired5,
+  errorDriverRequired as errorDriverRequired5,
+  errorFileNotFound as errorFileNotFound4,
+  errorHashMismatch as errorHashMismatch2,
+  errorMarkerMissing as errorMarkerMissing2,
+  errorRuntime as errorRuntime5,
+  errorTargetMismatch as errorTargetMismatch2,
+  errorUnexpected as errorUnexpected6
+} from "@prisma-next/core-control-plane/errors";
+import { Command as Command5 } from "commander";
+function createDbVerifyCommand() {
+  const command = new Command5("verify");
+  setCommandDescriptions(
+    command,
+    "Check whether the database has been signed with your contract",
+    "Verifies that your database schema matches the emitted contract. Checks table structures,\ncolumn types, constraints, and codec coverage. Reports any mismatches or missing codecs."
+  );
+  command.configureHelp({
+    formatHelp: (cmd) => {
+      const flags = parseGlobalFlags({});
+      return formatCommandHelp({ command: cmd, flags });
+    }
+  }).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--json [format]", "Output as JSON (object or ndjson)", false).option("-q, --quiet", "Quiet mode: errors only").option("-v, --verbose", "Verbose output: debug info, timings").option("-vv, --trace", "Trace output: deep internals, stack traces").option("--timestamps", "Add timestamps to output").option("--color", "Force color output").option("--no-color", "Disable color output").action(async (options) => {
+    const flags = parseGlobalFlags(options);
+    const result = await performAction(async () => {
+      const config = await loadConfig(options.config);
+      const configPath = options.config ? relative6(process.cwd(), resolve6(options.config)) : "prisma-next.config.ts";
+      const contractPathAbsolute = config.contract?.output ? resolve6(config.contract.output) : resolve6("src/prisma/contract.json");
+      const contractPath = relative6(process.cwd(), contractPathAbsolute);
+      if (flags.json !== "object" && !flags.quiet) {
+        const details = [
+          { label: "config", value: configPath },
+          { label: "contract", value: contractPath }
+        ];
+        if (options.db) {
+          details.push({ label: "database", value: options.db });
+        }
+        const header = formatStyledHeader({
+          command: "db verify",
+          description: "Check whether the database has been signed with your contract",
+          url: "https://pris.ly/db-verify",
+          details,
+          flags
+        });
+        console.log(header);
+      }
+      let contractJsonContent;
+      try {
+        contractJsonContent = await readFile4(contractPathAbsolute, "utf-8");
+      } catch (error) {
+        if (error instanceof Error && error.code === "ENOENT") {
+          throw errorFileNotFound4(contractPathAbsolute, {
+            why: `Contract file not found at ${contractPathAbsolute}`
+          });
+        }
+        throw errorUnexpected6(error instanceof Error ? error.message : String(error), {
+          why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+      const contractJson = JSON.parse(contractJsonContent);
+      const dbUrl = options.db ?? config.db?.url;
+      if (!dbUrl) {
+        throw errorDatabaseUrlRequired5();
+      }
+      if (!config.driver) {
+        throw errorDriverRequired5();
+      }
+      const driverDescriptor = config.driver;
+      const driver = await withSpinner(() => driverDescriptor.create(dbUrl), {
+        message: "Connecting to database...",
+        flags
+      });
+      try {
+        const familyInstance = config.family.create({
+          target: config.target,
+          adapter: config.adapter,
+          driver: driverDescriptor,
+          extensions: config.extensions ?? []
+        });
+        const typedFamilyInstance = familyInstance;
+        const contractIR = typedFamilyInstance.validateContractIR(contractJson);
+        let verifyResult;
+        try {
+          verifyResult = await withSpinner(
+            () => typedFamilyInstance.verify({
+              driver,
+              contractIR,
+              expectedTargetId: config.target.targetId,
+              contractPath: contractPathAbsolute,
+              configPath
+            }),
+            {
+              message: "Verifying database schema...",
+              flags
+            }
+          );
+        } catch (error) {
+          throw errorUnexpected6(error instanceof Error ? error.message : String(error), {
+            why: `Failed to verify database: ${error instanceof Error ? error.message : String(error)}`
+          });
+        }
+        if (!verifyResult.ok && verifyResult.code) {
+          if (verifyResult.code === "PN-RTM-3001") {
+            throw errorMarkerMissing2();
+          }
+          if (verifyResult.code === "PN-RTM-3002") {
+            throw errorHashMismatch2({
+              expected: verifyResult.contract.coreHash,
+              ...verifyResult.marker?.coreHash ? { actual: verifyResult.marker.coreHash } : {}
+            });
+          }
+          if (verifyResult.code === "PN-RTM-3003") {
+            throw errorTargetMismatch2(
+              verifyResult.target.expected,
+              verifyResult.target.actual ?? "unknown"
+            );
+          }
+          throw errorRuntime5(verifyResult.summary);
+        }
+        if (!flags.quiet && flags.json !== "object" && process.stdout.isTTY) {
+          console.log("");
+        }
+        return verifyResult;
+      } finally {
+        await driver.close();
+      }
+    });
+    const exitCode = handleResult(result, flags, (verifyResult) => {
+      if (flags.json === "object") {
+        console.log(formatVerifyJson(verifyResult));
+      } else {
+        const output = formatVerifyOutput(verifyResult, flags);
+        if (output) {
+          console.log(output);
+        }
+      }
+    });
+    process.exit(exitCode);
+  });
+  return command;
+}
+
+// src/cli.ts
+var program = new Command6();
+program.name("prisma-next").description("Prisma Next CLI").version("0.0.1");
+var versionOption = program.options.find((opt) => opt.flags.includes("--version"));
+if (versionOption) {
+  versionOption.description = "Output the version number";
+}
+program.configureOutput({
+  writeErr: () => {
+  },
+  writeOut: () => {
+  }
+});
+var rootHelpFormatter = (cmd) => {
+  const flags = parseGlobalFlags({});
+  return formatRootHelp({ program: cmd, flags });
+};
+program.configureHelp({
+  formatHelp: rootHelpFormatter,
+  subcommandDescription: () => ""
+});
+program.exitOverride((err2) => {
+  if (err2) {
+    const errorCode = err2.code;
+    const errorMessage = String(err2.message ?? "");
+    const errorName = err2.name ?? "";
+    const isUnknownCommandError = errorCode === "commander.unknownCommand" || errorCode === "commander.unknownArgument" || errorName === "CommanderError" && (errorMessage.includes("unknown command") || errorMessage.includes("unknown argument"));
+    if (isUnknownCommandError) {
+      const flags = parseGlobalFlags({});
+      const match = errorMessage.match(/unknown command ['"]([^'"]+)['"]/);
+      const commandName = match ? match[1] : process.argv[3] || process.argv[2] || "unknown";
+      const firstArg = process.argv[2];
+      const parentCommand = firstArg ? program.commands.find((cmd) => cmd.name() === firstArg) : void 0;
+      if (parentCommand && commandName !== firstArg) {
+        console.error(`Unknown command: ${commandName}`);
+        console.error("");
+        const helpText = formatCommandHelp({ command: parentCommand, flags });
+        console.log(helpText);
+      } else {
+        console.error(`Unknown command: ${commandName}`);
+        console.error("");
+        const helpText = formatRootHelp({ program, flags });
+        console.log(helpText);
+      }
+      process.exit(1);
+      return;
+    }
+    const isHelpError = errorCode === "commander.help" || errorCode === "commander.helpDisplayed" || errorCode === "outputHelp" || errorMessage === "(outputHelp)" || errorMessage.includes("outputHelp") || errorName === "CommanderError" && errorMessage.includes("outputHelp");
+    if (isHelpError) {
+      process.exit(0);
+      return;
+    }
+    const isMissingArgumentError = errorCode === "commander.missingArgument" || errorCode === "commander.missingMandatoryOptionValue" || errorName === "CommanderError" && (errorMessage.includes("missing") || errorMessage.includes("required"));
+    if (isMissingArgumentError) {
+      process.exit(0);
+      return;
+    }
+    console.error(`Unhandled error: ${err2.message}`);
+    if (err2.stack) {
+      console.error(err2.stack);
+    }
+    process.exit(1);
+  }
+  process.exit(0);
+});
+var contractCommand = new Command6("contract");
+setCommandDescriptions(
+  contractCommand,
+  "Contract management commands",
+  "Define and emit your application data contract. The contract describes your schema as a\ndeclarative data structure that can be signed and verified against your database."
+);
+contractCommand.configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  },
+  subcommandDescription: () => ""
+});
+var contractEmitCommand = createContractEmitCommand();
+contractCommand.addCommand(contractEmitCommand);
+program.addCommand(contractCommand);
+var dbCommand = new Command6("db");
+setCommandDescriptions(
+  dbCommand,
+  "Database management commands",
+  "Verify and sign your database with your contract. Ensure your database schema matches\nyour contract, and sign it to record the contract hash for future verification."
+);
+dbCommand.configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  },
+  subcommandDescription: () => ""
+});
+var dbVerifyCommand = createDbVerifyCommand();
+dbCommand.addCommand(dbVerifyCommand);
+var dbIntrospectCommand = createDbIntrospectCommand();
+dbCommand.addCommand(dbIntrospectCommand);
+var dbSchemaVerifyCommand = createDbSchemaVerifyCommand();
+dbCommand.addCommand(dbSchemaVerifyCommand);
+var dbSignCommand = createDbSignCommand();
+dbCommand.addCommand(dbSignCommand);
+program.addCommand(dbCommand);
+var helpCommand = new Command6("help").description("Show usage instructions").configureHelp({
+  formatHelp: (cmd) => {
+    const flags = parseGlobalFlags({});
+    return formatCommandHelp({ command: cmd, flags });
+  }
+}).action(() => {
+  const flags = parseGlobalFlags({});
+  const helpText = formatRootHelp({ program, flags });
+  console.log(helpText);
+  process.exit(0);
+});
+program.addCommand(helpCommand);
+program.action(() => {
+  const flags = parseGlobalFlags({});
+  const helpText = formatRootHelp({ program, flags });
+  console.log(helpText);
+  process.exit(0);
+});
+var args = process.argv.slice(2);
+if (args.length > 0) {
+  const commandName = args[0];
+  if (commandName === "--version" || commandName === "-V") {
+    console.log(program.version());
+    process.exit(0);
+  }
+  const isGlobalOption = commandName === "--help" || commandName === "-h";
+  if (!isGlobalOption) {
+    const command = program.commands.find((cmd) => cmd.name() === commandName);
+    if (!command) {
+      const flags = parseGlobalFlags({});
+      console.error(`Unknown command: ${commandName}`);
+      console.error("");
+      const helpText = formatRootHelp({ program, flags });
+      console.log(helpText);
+      process.exit(1);
+    } else if (command.commands.length > 0 && args.length === 1) {
+      const flags = parseGlobalFlags({});
+      const helpText = formatCommandHelp({ command, flags });
+      console.log(helpText);
+      process.exit(0);
+    }
+  }
+}
+program.parse();
+//# sourceMappingURL=cli.js.map