@prisma-next/cli 0.4.0-dev.9 → 0.5.0-dev.1

package/src/config-path-validation.ts

@@ -0,0 +1,75 @@
+import {
+  type ContractSourceProvider,
+  normalizeContractConfig,
+  type PrismaNextConfig,
+} from '@prisma-next/config/config-types';
+import { ConfigValidationError } from '@prisma-next/config/config-validation';
+import { getEmittedArtifactPaths } from '@prisma-next/emitter';
+import { resolve } from 'pathe';
+
+function throwValidation(field: string, why: string): never {
+  throw new ConfigValidationError(field, why);
+}
+
+function finalizeContractSource(
+  source: ContractSourceProvider,
+  configDir: string,
+): ContractSourceProvider {
+  const resolvedInputs = source.inputs?.map((input) => resolve(configDir, input));
+  if (resolvedInputs === undefined) {
+    return source;
+  }
+
+  return {
+    ...source,
+    inputs: resolvedInputs,
+  };
+}
+
+function validateNoOutputsAreInputs(
+  inputs: readonly string[] | undefined,
+  output: string | undefined,
+): void {
+  if (inputs === undefined || output === undefined) {
+    return;
+  }
+
+  let emittedArtifactPaths: ReturnType<typeof getEmittedArtifactPaths>;
+  try {
+    emittedArtifactPaths = getEmittedArtifactPaths(output);
+  } catch (error) {
+    throwValidation('contract.output', error instanceof Error ? error.message : String(error));
+  }
+
+  const emittedPaths = new Set([emittedArtifactPaths.jsonPath, emittedArtifactPaths.dtsPath]);
+
+  for (const input of inputs) {
+    if (emittedPaths.has(input)) {
+      throwValidation(
+        'contract.source.inputs[]',
+        'Config.contract.source.inputs must not include emitted artifact paths derived from contract.output',
+      );
+    }
+  }
+}
+
+export function finalizeConfig(config: PrismaNextConfig, configDir: string): PrismaNextConfig {
+  if (!config.contract) {
+    return config;
+  }
+
+  const contract = normalizeContractConfig(config.contract);
+  const source = finalizeContractSource(contract.source, configDir);
+  const output = resolve(configDir, contract.output);
+
+  validateNoOutputsAreInputs(source.inputs, output);
+
+  return {
+    ...config,
+    contract: {
+      ...contract,
+      source,
+      output,
+    },
+  };
+}

package/src/control-api/client.ts

@@ -496,8 +496,9 @@ class ControlClientImpl implements ControlClient {
         authoringContributions: stack.authoringContributions,
         codecLookup: stack.codecLookup,
         controlMutationDefaults: stack.controlMutationDefaults,
+        resolvedInputs: contractConfig.source.inputs ?? [],
       };
-      const providerResult = await contractConfig.sourceProvider(sourceContext);
+      const providerResult = await contractConfig.source.load(sourceContext);
       if (!providerResult.ok) {
         onProgress?.({
           action: 'emit',

package/src/control-api/operations/contract-emit.ts

@@ -1,10 +1,10 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import type { Contract } from '@prisma-next/contract/types';
-import { emit } from '@prisma-next/emitter';
+import { emit, getEmittedArtifactPaths } from '@prisma-next/emitter';
 import { createControlStack } from '@prisma-next/framework-components/control';
 import { abortable } from '@prisma-next/utils/abortable';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { dirname, isAbsolute, join, resolve } from 'pathe';
+import { dirname } from 'pathe';
 import { loadConfig } from '../../config-loader';
 import { errorContractConfigMissing, errorRuntime } from '../../utils/cli-errors';
 import { assertFrameworkComponentsCompatible } from '../../utils/framework-components';
@@ -72,27 +72,23 @@ export async function executeContractEmit(
       why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
     });
   }
-  if (!contractConfig.output.endsWith('.json')) {
+
+  // Validate source exists and is callable
+  if (typeof contractConfig.source?.load !== 'function') {
     throw errorContractConfigMissing({
-      why: 'Contract config output path must end with .json (e.g., "src/prisma/contract.json")',
+      why: 'Contract config must include a valid source provider object',
     });
   }
 
-  // Validate source exists and is callable
-  if (typeof contractConfig.source !== 'function') {
+  let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;
+  try {
+    outputPaths = getEmittedArtifactPaths(contractConfig.output);
+  } catch (error) {
     throw errorContractConfigMissing({
-      why: 'Contract config must include a valid source provider function',
+      why: error instanceof Error ? error.message : String(error),
     });
   }
-
-  // Normalize configPath and resolve artifact paths relative to config file directory
-  const normalizedConfigPath = resolve(configPath);
-  const configDir = dirname(normalizedConfigPath);
-  const outputJsonPath = isAbsolute(contractConfig.output)
-    ? contractConfig.output
-    : join(configDir, contractConfig.output);
-  // Colocate .d.ts with .json (contract.json → contract.d.ts)
-  const outputDtsPath = `${outputJsonPath.slice(0, -5)}.d.ts`;
+  const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = outputPaths;
 
   const stack = createControlStack(config);
 
@@ -102,39 +98,40 @@ export async function executeContractEmit(
     authoringContributions: stack.authoringContributions,
     codecLookup: stack.codecLookup,
     controlMutationDefaults: stack.controlMutationDefaults,
+    resolvedInputs: contractConfig.source.inputs ?? [],
   };
 
-  let providerResult: Awaited<ReturnType<typeof contractConfig.source>>;
+  let providerResult: Awaited<ReturnType<typeof contractConfig.source.load>>;
   try {
-    providerResult = await unlessAborted(contractConfig.source(sourceContext));
+    providerResult = await unlessAborted(contractConfig.source.load(sourceContext));
   } catch (error) {
     if (signal.aborted || isAbortError(error)) {
       throw error;
     }
     throw errorRuntime('Failed to resolve contract source', {
       why: error instanceof Error ? error.message : String(error),
-      fix: 'Ensure contract.source resolves to ok(Contract) or returns structured diagnostics.',
+      fix: 'Ensure contract.source.load resolves to ok(Contract) or returns structured diagnostics.',
     });
   }
 
   if (!isRecord(providerResult) || typeof providerResult.ok !== 'boolean') {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed result shape.',
-      fix: 'Ensure contract.source resolves to ok(Contract) or notOk({ summary, diagnostics }).',
+      fix: 'Ensure contract.source.load resolves to ok(Contract) or notOk({ summary, diagnostics }).',
     });
   }
 
   if (providerResult.ok && !('value' in providerResult)) {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed success result: missing value.',
-      fix: 'Ensure contract.source success payload is ok(Contract).',
+      fix: 'Ensure contract.source.load success payload is ok(Contract).',
     });
   }
 
   if (!providerResult.ok && !isProviderFailureLike(providerResult.failure)) {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed failure result: expected summary and diagnostics.',
-      fix: 'Ensure contract.source failure payload is notOk({ summary, diagnostics, meta? }).',
+      fix: 'Ensure contract.source.load failure payload is notOk({ summary, diagnostics, meta? }).',
     });
   }
 
@@ -160,7 +157,11 @@ export async function executeContractEmit(
   const enrichedIR = enrichContract(providerResult.value as Contract, frameworkComponents);
 
   familyInstance.validateContract(enrichedIR);
-  const emitResult = await unlessAborted(emit(enrichedIR, stack, config.family.emission));
+  const emitResult = await unlessAborted(
+    emit(enrichedIR, stack, config.family.emission, {
+      outputJsonPath: outputJsonPath,
+    }),
+  );
 
   // Create directory if needed and write files (both colocated)
   await unlessAborted(mkdir(dirname(outputJsonPath), { recursive: true }));

package/src/control-api/types.ts

@@ -248,7 +248,7 @@ export interface EmitContractConfig {
   /**
    * Contract source provider.
    */
-  readonly sourceProvider: ContractSourceProvider;
+  readonly source: ContractSourceProvider;
   /**
    * Output path for contract.json.
    * The .d.ts types file will be colocated (e.g., contract.json → contract.d.ts).

package/src/migration-cli.ts

@@ -0,0 +1,254 @@
+/**
+ * The migration-file CLI interface: the actor invoked when the author runs
+ * `node migration.ts` directly.
+ *
+ * Naming: this is *not* a "migration runner" in the apply-time sense. The
+ * apply-time runner is the thing `prisma-next migration apply` uses to
+ * execute migration JSON ops against a database. `MigrationCLI` is the
+ * tiny CLI surface owned by an authored `migration.ts` file: parse the
+ * file's argv, load the project's `prisma-next.config.ts`, assemble a
+ * `ControlStack`, instantiate the migration class, and serialize.
+ *
+ * The user authors a migration class, then calls
+ * `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope
+ * after the class definition. When the file is invoked as a node
+ * entrypoint (`node migration.ts`), the CLI:
+ *
+ * 1. Detects whether the file is the direct entrypoint (no-op when imported).
+ * 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`).
+ * 3. Loads the project's `prisma-next.config.ts` via the same `loadConfig`
+ *    the CLI commands use, walking up from the migration file's directory.
+ * 4. Probe-instantiates the migration class without a stack so it can read
+ *    `targetId` and verify it matches `config.target.targetId`
+ *    (`PN-MIG-2006` on mismatch) before any stack-driven adapter
+ *    construction runs.
+ * 5. Assembles a `ControlStack` from the loaded config descriptors and
+ *    constructs the migration with that stack.
+ * 6. Reads any previously-scaffolded `migration.json`, then calls
+ *    `buildMigrationArtifacts` from `@prisma-next/migration-tools` to
+ *    produce in-memory `ops.json` + `migration.json` content. Persists
+ *    the result to disk (or prints in dry-run mode).
+ *
+ * File I/O lives here, in `@prisma-next/cli`: this is the only place
+ * that legitimately combines config loading, stack assembly, and
+ * on-disk persistence. `@prisma-next/migration-tools` owns the pure
+ * conversion from a `Migration` instance to artifact strings; `Migration`
+ * stays a pure abstract class.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { CliStructuredError, errorMigrationCliInvalidConfigArg } from '@prisma-next/errors/control';
+import { errorMigrationTargetMismatch } from '@prisma-next/errors/migration';
+import { createControlStack } from '@prisma-next/framework-components/control';
+import {
+  buildMigrationArtifacts,
+  isDirectEntrypoint,
+  type Migration,
+  printMigrationHelp,
+} from '@prisma-next/migration-tools/migration';
+import type { MigrationManifest } from '@prisma-next/migration-tools/types';
+import { dirname, join } from 'pathe';
+import { loadConfig } from './config-loader';
+
+/**
+ * Constructor shape accepted by `MigrationCLI.run`. `Migration` subclasses
+ * accept an optional `ControlStack` in their constructor (each subclass
+ * narrows the stack to its own family/target generics); the CLI always
+ * passes one assembled from the loaded config. We use a rest-args `any[]`
+ * constructor signature so that subclass constructors with narrower
+ * parameter types remain assignable - constructor type compatibility in
+ * TS is contravariant in the parameter, and a wider `unknown` parameter
+ * on the alias side would reject any narrower subclass signature.
+ *
+ * The CLI only ever passes one argument (`new MigrationClass(stack)`);
+ * the rest-arity is purely a type-compatibility concession for subclass
+ * constructors that declare narrower parameter types, not an extension
+ * point for additional construction arguments.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: see JSDoc - rest args with any are the idiomatic TS pattern for accepting arbitrary subclass constructor signatures
+export type MigrationConstructor = new (...args: any[]) => Migration;
+
+interface ParsedArgs {
+  readonly help: boolean;
+  readonly dryRun: boolean;
+  readonly configPath: string | undefined;
+}
+
+/**
+ * Parse the subset of `process.argv` that `MigrationCLI.run` cares about.
+ * Recognised flags: `--help`, `--dry-run`, `--config <path>` /
+ * `--config=<path>`. Unknown flags are ignored to keep the surface
+ * forgiving for ad-hoc tooling that wraps a migration file.
+ *
+ * Throws `errorMigrationCliInvalidConfigArg` (`PN-CLI-4012`) when
+ * `--config` is missing its path argument or is followed by another flag
+ * (e.g. `--config --dry-run`); silently consuming the next flag would
+ * either drop dry-run handling or serialize against the wrong project.
+ *
+ * NOTE: this hand-rolled parser is a known wart, tracked separately by
+ * TML-2318 ("Migration CLI: replace handrolled arg parser with shared
+ * CLI library"). Until that lands the surface is intentionally tiny.
+ */
+function parseArgs(argv: readonly string[]): ParsedArgs {
+  let help = false;
+  let dryRun = false;
+  let configPath: string | undefined;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!;
+    if (arg === '--help' || arg === '-h') {
+      help = true;
+    } else if (arg === '--dry-run') {
+      dryRun = true;
+    } else if (arg === '--config') {
+      const next = argv[i + 1];
+      if (next === undefined) {
+        throw errorMigrationCliInvalidConfigArg();
+      }
+      if (next.startsWith('-')) {
+        throw errorMigrationCliInvalidConfigArg({ nextToken: next });
+      }
+      configPath = next;
+      i++;
+    } else if (arg.startsWith('--config=')) {
+      configPath = arg.slice('--config='.length);
+    }
+  }
+
+  return { help, dryRun, configPath };
+}
+
+/**
+ * The CLI surface invoked by an authored `migration.ts` file. Exposed as
+ * a class with a static `run` method (rather than a free function) to
+ * give the concept a stable identity in the ubiquitous language: this is
+ * the "migration-file CLI", distinct from the apply-time runner that
+ * executes migration JSON ops.
+ *
+ * Currently a single static method. Future surface (e.g. a programmatic
+ * `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can
+ * land here without changing the import shape used by every authored
+ * migration.
+ */
+// biome-ignore lint/complexity/noStaticOnlyClass: see JSDoc - intentional class facade for the migration-file CLI surface; future methods will share state derived from argv/config.
+export class MigrationCLI {
+  /**
+   * Orchestrates a class-flow `migration.ts` script run. Awaitable:
+   * callers may `await MigrationCLI.run(...)` to surface async failures
+   * from config loading, but the typical usage pattern (top-level call
+   * after the class definition) does not require awaiting because
+   * node's module evaluation keeps the promise alive until completion.
+   *
+   * Any throwable inside this function must surface through the internal
+   * try/catch — script callers do not await, so an unhandled rejection
+   * would silently exit 0. Treat the try/catch as load-bearing for the
+   * no-await usage pattern.
+   */
+  static async run(importMetaUrl: string, MigrationClass: MigrationConstructor): Promise<void> {
+    if (!importMetaUrl) return;
+    if (!isDirectEntrypoint(importMetaUrl)) return;
+
+    try {
+      const args = parseArgs(process.argv.slice(2));
+
+      if (args.help) {
+        printMigrationHelp();
+        return;
+      }
+
+      const migrationFile = fileURLToPath(importMetaUrl);
+      const migrationDir = dirname(migrationFile);
+
+      const config = await loadConfig(args.configPath);
+
+      // Probe-instantiate without a stack so we can read `targetId` before
+      // any target-specific constructor side effects (e.g.
+      // `PostgresMigration`'s `stack.adapter.create(stack)`) run. Concrete
+      // subclasses are required to accept the no-arg form; the abstract
+      // `Migration` constructor declares `stack?` and target subclasses
+      // (Postgres, Mongo) propagate that optionality. This makes the
+      // target-mismatch guard fail fast with `PN-MIG-2006` before any
+      // stack-driven adapter construction begins, even if the wrong-target
+      // adapter's `create` would otherwise succeed and silently misshapen
+      // the stored adapter cast.
+      const probe = new MigrationClass();
+
+      if (probe.targetId !== config.target.targetId) {
+        throw errorMigrationTargetMismatch({
+          migrationTargetId: probe.targetId,
+          configTargetId: config.target.targetId,
+        });
+      }
+
+      const stack = createControlStack(config);
+      const instance = new MigrationClass(stack);
+
+      serializeMigrationToDisk(instance, migrationDir, args.dryRun);
+    } catch (err) {
+      if (CliStructuredError.is(err)) {
+        process.stderr.write(`${err.message}: ${err.why}\n`);
+      } else {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+      }
+      process.exitCode = 1;
+    }
+  }
+}
+
+/**
+ * Read a previously-scaffolded `migration.json` from disk, returning
+ * `null` when the file is missing or unparseable. The CLI feeds this into
+ * `buildMigrationArtifacts` so the pure builder can preserve fields owned
+ * by `migration plan` (contract bookends, hints, labels, `createdAt`)
+ * across re-emits.
+ */
+function readExistingManifest(manifestPath: string): Partial<MigrationManifest> | null {
+  let raw: string;
+  try {
+    raw = readFileSync(manifestPath, 'utf-8');
+  } catch {
+    return null;
+  }
+  try {
+    return JSON.parse(raw) as Partial<MigrationManifest>;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist a migration instance's artifacts to `migrationDir`. In
+ * `dryRun` mode the artifacts are printed to stdout (with the same
+ * `--- migration.json --- / --- ops.json ---` framing the legacy
+ * `serializeMigration` helper used) and no files are written. Otherwise
+ * `ops.json` and `migration.json` are written next to `migration.ts` and
+ * a confirmation line is printed.
+ *
+ * File I/O lives in the CLI rather than `@prisma-next/migration-tools`
+ * so the migration-tools package stays focused on the pure
+ * `Migration` → in-memory artifact conversion. The CLI is the only
+ * legitimate site for combining config loading, stack assembly, and
+ * filesystem persistence.
+ */
+function serializeMigrationToDisk(
+  instance: Migration,
+  migrationDir: string,
+  dryRun: boolean,
+): void {
+  const manifestPath = join(migrationDir, 'migration.json');
+  const existing = readExistingManifest(manifestPath);
+  const { opsJson, manifestJson } = buildMigrationArtifacts(instance, existing);
+
+  if (dryRun) {
+    process.stdout.write(`--- migration.json ---\n${manifestJson}\n`);
+    process.stdout.write('--- ops.json ---\n');
+    process.stdout.write(`${opsJson}\n`);
+    return;
+  }
+
+  writeFileSync(join(migrationDir, 'ops.json'), opsJson);
+  writeFileSync(manifestPath, manifestJson);
+
+  process.stdout.write(`Wrote ops.json + migration.json to ${migrationDir}\n`);
+}

package/src/utils/cli-errors.ts

@@ -14,6 +14,7 @@ export {
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,
+  errorMigrationCliInvalidConfigArg,
   errorMigrationPlanningFailed,
   errorQueryRunnerFactoryRequired,
   errorTargetMigrationNotSupported,

package/src/utils/command-helpers.ts

@@ -4,12 +4,7 @@ import { hasMigrations } from '@prisma-next/framework-components/control';
 import type { PathDecision } from '@prisma-next/migration-tools/dag';
 import { reconstructGraph } from '@prisma-next/migration-tools/dag';
 import { readMigrationsDir } from '@prisma-next/migration-tools/io';
-import type {
-  AttestedMigrationBundle,
-  DraftMigrationBundle,
-  MigrationGraph,
-} from '@prisma-next/migration-tools/types';
-import { isAttested, isDraft } from '@prisma-next/migration-tools/types';
+import type { MigrationBundle, MigrationGraph } from '@prisma-next/migration-tools/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Command } from 'commander';
 import { relative, resolve } from 'pathe';
@@ -150,32 +145,33 @@ export function getTargetMigrations(target: ControlTargetDescriptor<string, stri
 }
 
 /**
- * Reads the migrations directory, filters to attested bundles, and builds
- * the migration graph. Throws on I/O or graph errors — callers handle
- * error mapping.
+ * Reads the migrations directory and builds the migration graph from all
+ * bundles. Throws on I/O or graph errors — callers handle error mapping.
+ *
+ * Every on-disk bundle is content-addressed (`migrationId` is always a
+ * string); there is no draft state to filter out.
  */
 export async function loadMigrationBundles(migrationsDir: string): Promise<{
-  bundles: readonly AttestedMigrationBundle[];
+  bundles: readonly MigrationBundle[];
   graph: MigrationGraph;
 }> {
-  const allBundles = await readMigrationsDir(migrationsDir);
-  const bundles = allBundles.filter(isAttested);
+  const bundles = await readMigrationsDir(migrationsDir);
   const graph = reconstructGraph(bundles);
   return { bundles, graph };
 }
 
 export interface MigrationBundleSet {
-  readonly attested: readonly AttestedMigrationBundle[];
-  readonly drafts: readonly DraftMigrationBundle[];
+  readonly bundles: readonly MigrationBundle[];
   readonly graph: MigrationGraph;
 }
 
+/**
+ * Alias of `loadMigrationBundles` retained for naming-clarity in commands
+ * that previously needed both attested and draft splits. With the
+ * collapse of the draft state, both helpers do the same thing.
+ */
 export async function loadAllBundles(migrationsDir: string): Promise<MigrationBundleSet> {
-  const all = await readMigrationsDir(migrationsDir);
-  const attested = all.filter(isAttested);
-  const drafts = all.filter(isDraft);
-  const graph = reconstructGraph(attested);
-  return { attested, drafts, graph };
+  return loadMigrationBundles(migrationsDir);
 }
 
 /**

package/src/utils/formatters/graph-migration-mapper.ts

@@ -39,12 +39,6 @@ export interface EdgeStatus {
   readonly status: EdgeStatusKind;
 }
 
-export interface DraftEdge {
-  readonly from: string;
-  readonly to: string;
-  readonly dirName: string;
-}
-
 export interface MigrationGraphInput {
   readonly graph: MigrationGraph;
   readonly mode: 'online' | 'offline';
@@ -58,8 +52,6 @@ export interface MigrationGraphInput {
    * icons (✓/⧗) are baked into edge labels. Undefined in offline mode.
    */
   readonly edgeStatuses?: readonly EdgeStatus[] | undefined;
-  /** Draft migrations to render as dashed edges. */
-  readonly draftEdges?: readonly DraftEdge[] | undefined;
 }
 
 export interface MigrationRenderInput {
@@ -204,7 +196,9 @@ export function migrationGraphToRenderInput(input: MigrationGraphInput): Migrati
     spineTargetHash = lastEdge?.to ?? EMPTY_CONTRACT_HASH;
   }
 
-  // Contract not in attested graph — connect from spine target with a dashed edge
+  // Contract not in the migration graph — connect from spine target with a
+  // dashed edge so the user can see the gap (contract has changed but no
+  // migration has been planned yet).
   if (contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash)) {
     const contractMarkers: NodeMarker[] = [];
     if (mode === 'online' && markerHash === contractHash) {
@@ -216,13 +210,10 @@ export function migrationGraphToRenderInput(input: MigrationGraphInput): Migrati
       markers: contractMarkers,
     });
 
-    const matchingDraft = input.draftEdges?.find((d) => d.to === contractHash);
-    const fromHash = matchingDraft?.from ?? spineTargetHash;
-    if (graph.nodes.has(fromHash) || fromHash === spineTargetHash) {
+    if (graph.nodes.has(spineTargetHash) || spineTargetHash === EMPTY_CONTRACT_HASH) {
       edgeList.push({
-        from: toShortId(fromHash),
+        from: toShortId(spineTargetHash),
         to: shortHash(contractHash),
-        ...ifDefined('label', matchingDraft ? `${matchingDraft.dirName} [draft]` : undefined),
         style: 'dashed',
       });
     }

package/src/utils/formatters/help.ts

@@ -137,7 +137,6 @@ function getCommandDocsUrl(commandPath: string): string | undefined {
     'migration apply': 'https://pris.ly/migration-apply',
     'migration show': 'https://pris.ly/migration-show',
     'migration status': 'https://pris.ly/migration-status',
-    'migration emit': 'https://pris.ly/migration-emit',
   };
   return docsMap[commandPath];
 }

package/src/utils/formatters/migrations.ts

@@ -136,10 +136,6 @@ export interface MigrationApplyCommandOutputResult {
   };
 }
 
-export interface MigrationEmitCommandOutputResult {
-  readonly migrationId: string;
-}
-
 export function formatMigrationApplyCommandOutput(
   result: MigrationApplyCommandOutputResult,
   flags: GlobalFlags,
@@ -182,31 +178,12 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-export function formatMigrationEmitCommandOutput(
-  result: MigrationEmitCommandOutputResult,
-  flags: GlobalFlags,
-): string {
-  if (flags.quiet) {
-    return '';
-  }
-
-  const lines: string[] = [];
-  const useColor = flags.color !== false;
-  const formatGreen = createColorFormatter(useColor, green);
-  const formatDimText = (text: string) => formatDim(useColor, text);
-
-  lines.push(`${formatGreen('✔')} Emitted ops.json and attested migration`);
-  lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
-
-  return lines.join('\n');
-}
-
 interface MigrationShowResult {
   readonly dirName: string;
   readonly dirPath: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
@@ -234,11 +211,7 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   lines.push(`${formatDimText(`  kind: ${result.kind}`)}`);
   lines.push(`${formatDimText(`  from: ${result.from}`)}`);
   lines.push(`${formatDimText(`  to:   ${result.to}`)}`);
-  if (result.migrationId) {
-    lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
-  } else {
-    lines.push(`${formatYellow('  migrationId: (draft — not yet attested)')}`);
-  }
+  lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
   lines.push(`${formatDimText(`  created: ${result.createdAt}`)}`);
 
   lines.push('');

package/dist/cli-errors-BUuJr6py.mjs

@@ -1,5 +0,0 @@
-import { CliStructuredError, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorMigrationPlanningFailed, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
-import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
-import { errorMigrationFileMissing } from "@prisma-next/errors/migration";
-
-export { errorTargetMismatch as _, errorContractValidationFailed as a, errorDriverRequired as c, errorMarkerMissing as d, errorMigrationFileMissing as f, errorTargetMigrationNotSupported as g, errorRuntime$1 as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorRunnerFailed as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorMigrationPlanningFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError as t, errorHashMismatch as u, errorUnexpected$1 as v };

package/dist/cli-errors-Dic2eADK.d.mts

@@ -1,4 +0,0 @@
-import { CliStructuredError } from "@prisma-next/errors/control";
-import "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-export { CliStructuredError as t };