@prisma-next/cli 0.4.0-dev.9 → 0.4.2

package/src/commands/migration-ref.ts

@@ -1,17 +1,22 @@
+import type { RefEntry } from '@prisma-next/migration-tools/refs';
 import {
+  deleteRef,
+  readRef,
   readRefs,
-  resolveRef,
   validateRefName,
   validateRefValue,
-  writeRefs,
+  writeRef,
 } from '@prisma-next/migration-tools/refs';
 import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
 import { CliStructuredError, errorRuntime, errorUnexpected } from '../utils/cli-errors';
-import { addGlobalOptions, setCommandDescriptions } from '../utils/command-helpers';
+import {
+  addGlobalOptions,
+  resolveMigrationPaths,
+  setCommandDescriptions,
+} from '../utils/command-helpers';
 import { formatCommandHelp } from '../utils/formatters/help';
 import { parseGlobalFlags } from '../utils/global-flags';
 import { handleResult } from '../utils/result-handler';
@@ -21,12 +26,14 @@ interface RefSetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefGetResult {
   readonly ok: true;
   readonly ref: string;
   readonly hash: string;
+  readonly invariants: readonly string[];
 }
 
 interface RefDeleteResult {
@@ -37,12 +44,7 @@ interface RefDeleteResult {
 
 interface RefListResult {
   readonly ok: true;
-  readonly refs: Record<string, string>;
-}
-
-function resolveRefsPath(configPath?: string, config?: { migrations?: { dir?: string } }): string {
-  const base = configPath ? resolve(configPath, '..') : process.cwd();
-  return resolve(base, config?.migrations?.dir ?? 'migrations', 'refs.json');
+  readonly refs: Record<string, RefEntry>;
 }
 
 function mapError(error: unknown): CliStructuredError {
@@ -70,13 +72,6 @@ function cliErrorInvalidRefValue(hash: string): CliStructuredError {
   });
 }
 
-function errorRefNotFound(name: string): CliStructuredError {
-  return errorRuntime(`Ref "${name}" does not exist`, {
-    why: `No ref named "${name}" found in refs.json`,
-    fix: `Run \`prisma-next migration ref list\` to see available refs, or \`prisma-next migration ref set ${name} <hash>\` to create it`,
-  });
-}
-
 async function executeRefSetCommand(
   name: string,
   hash: string,
@@ -91,11 +86,10 @@ async function executeRefSetCommand(
 
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const updated = { ...refs, [name]: hash };
-    await writeRefs(refsPath, updated);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry: RefEntry = { hash, invariants: [] };
+    await writeRef(refsDir, name, entry);
+    return ok({ ok: true as const, ref: name, hash, invariants: [] });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -108,10 +102,9 @@ async function executeRefGetCommand(
 ): Promise<Result<RefGetResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    const hash = resolveRef(refs, name);
-    return ok({ ok: true as const, ref: name, hash });
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const entry = await readRef(refsDir, name);
+    return ok({ ok: true as const, ref: name, hash: entry.hash, invariants: entry.invariants });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
     return notOk(mapError(error));
@@ -124,13 +117,8 @@ async function executeRefDeleteCommand(
 ): Promise<Result<RefDeleteResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
-    if (!Object.hasOwn(refs, name)) {
-      return notOk(errorRefNotFound(name));
-    }
-    const { [name]: _, ...remaining } = refs;
-    await writeRefs(refsPath, remaining);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    await deleteRef(refsDir, name);
     return ok({ ok: true as const, ref: name, deleted: true as const });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -143,8 +131,8 @@ async function executeRefListCommand(options: {
 }): Promise<Result<RefListResult, CliStructuredError>> {
   try {
     const config = await loadConfig(options.config);
-    const refsPath = resolveRefsPath(options.config, config);
-    const refs = await readRefs(refsPath);
+    const { refsDir } = resolveMigrationPaths(options.config, config);
+    const refs = await readRefs(refsDir);
     return ok({ ok: true as const, refs });
   } catch (error) {
     if (error instanceof CliStructuredError) return notOk(error);
@@ -157,7 +145,7 @@ function createRefSetCommand(): Command {
   setCommandDescriptions(
     command,
     'Set a ref to a contract hash',
-    'Sets a named ref to point to a contract hash in migrations/refs.json.',
+    'Sets a named ref to point to a contract hash in migrations/refs/.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name (e.g., staging, production)')
@@ -190,7 +178,7 @@ function createRefGetCommand(): Command {
   setCommandDescriptions(
     command,
     'Get the hash for a ref',
-    'Reads a named ref from migrations/refs.json and prints its contract hash.',
+    'Reads a named ref from migrations/refs/ and prints its contract hash.',
   );
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to look up')
@@ -218,7 +206,7 @@ function createRefGetCommand(): Command {
 
 function createRefDeleteCommand(): Command {
   const command = new Command('delete');
-  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs.json.');
+  setCommandDescriptions(command, 'Delete a ref', 'Removes a named ref from migrations/refs/.');
   addGlobalOptions(command)
     .argument('<name>', 'Ref name to delete')
     .option('--config <path>', 'Path to prisma-next.config.ts')
@@ -245,11 +233,7 @@ function createRefDeleteCommand(): Command {
 
 function createRefListCommand(): Command {
   const command = new Command('list');
-  setCommandDescriptions(
-    command,
-    'List all refs',
-    'Lists all named refs from migrations/refs.json.',
-  );
+  setCommandDescriptions(command, 'List all refs', 'Lists all named refs from migrations/refs/.');
   addGlobalOptions(command)
     .option('--config <path>', 'Path to prisma-next.config.ts')
     .action(async (options: { config?: string; json?: string | boolean; quiet?: boolean }) => {
@@ -264,8 +248,10 @@ function createRefListCommand(): Command {
           if (entries.length === 0) {
             ui.output('No refs defined');
           } else {
-            for (const [refName, hash] of entries) {
-              ui.output(`${refName} → ${hash}`);
+            for (const [refName, entry] of entries) {
+              const invariantsSuffix =
+                entry.invariants.length > 0 ? ` [invariants: ${entry.invariants.join(', ')}]` : '';
+              ui.output(`${refName} → ${entry.hash}${invariantsSuffix}`);
             }
           }
         }
@@ -282,7 +268,6 @@ export {
   executeRefListCommand,
   cliErrorInvalidRefName,
   cliErrorInvalidRefValue,
-  errorRefNotFound,
 };
 
 export function createMigrationRefCommand(): Command {
@@ -290,7 +275,7 @@ export function createMigrationRefCommand(): Command {
   setCommandDescriptions(
     command,
     'Manage migration refs',
-    'Manage named refs in migrations/refs.json. Refs map logical environment\n' +
+    'Manage named refs in migrations/refs/. Refs map logical environment\n' +
       'names (e.g., staging, production) to contract hashes.',
   );
   addGlobalOptions(command).configureHelp({

package/src/commands/migration-show.ts

@@ -2,7 +2,7 @@ import type { MigrationPlanOperation } from '@prisma-next/framework-components/c
 import { findLatestMigration, reconstructGraph } from '@prisma-next/migration-tools/dag';
 import { readMigrationPackage, readMigrationsDir } from '@prisma-next/migration-tools/io';
 import type { MigrationBundle } from '@prisma-next/migration-tools/types';
-import { isAttested, MigrationToolsError } from '@prisma-next/migration-tools/types';
+import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { relative, resolve } from 'pathe';
@@ -31,7 +31,7 @@ export interface MigrationShowResult {
   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 {
@@ -52,8 +52,7 @@ export function resolveByHashPrefix(
   prefix: string,
 ): Result<MigrationBundle, CliStructuredError> {
   const normalizedPrefix = prefix.startsWith('sha256:') ? prefix : `sha256:${prefix}`;
-  const attested = packages.filter((p) => typeof p.manifest.migrationId === 'string');
-  const matches = attested.filter((p) => p.manifest.migrationId!.startsWith(normalizedPrefix));
+  const matches = packages.filter((p) => p.manifest.migrationId.startsWith(normalizedPrefix));
 
   if (matches.length === 1) {
     return ok(matches[0]!);
@@ -62,7 +61,7 @@ export function resolveByHashPrefix(
   if (matches.length === 0) {
     return notOk(
       errorRuntime('No migration found matching prefix', {
-        why: `No attested migration has a migrationId starting with "${normalizedPrefix}"`,
+        why: `No migration has a migrationId starting with "${normalizedPrefix}"`,
         fix: 'Run `prisma-next migration show` (no argument) to see the latest migration, or check the migrations directory for available packages.',
       }),
     );
@@ -132,16 +131,7 @@ async function executeMigrationShowCommand(
         if (!resolved.ok) return resolved;
         pkg = resolved.value;
       } else {
-        const attested = allPackages.filter(isAttested);
-        if (attested.length === 0) {
-          return notOk(
-            errorRuntime('No attested migrations found', {
-              why: `All migrations in ${migrationsRelative} are drafts (migrationId: null)`,
-              fix: 'Run `prisma-next migration emit --dir <path>` to attest a draft migration.',
-            }),
-          );
-        }
-        const graph = reconstructGraph(attested);
+        const graph = reconstructGraph(allPackages);
         const latestMigration = findLatestMigration(graph);
         if (!latestMigration) {
           return notOk(
@@ -151,7 +141,7 @@ async function executeMigrationShowCommand(
             }),
           );
         }
-        const leafPkg = attested.find(
+        const leafPkg = allPackages.find(
           (p) => p.manifest.migrationId === latestMigration.migrationId,
         );
         if (!leafPkg) {

package/src/commands/migration-status.ts

@@ -8,8 +8,7 @@ import {
 import type { Refs } from '@prisma-next/migration-tools/refs';
 import { readRefs, resolveRef } from '@prisma-next/migration-tools/refs';
 import type {
-  AttestedMigrationBundle,
-  DraftMigrationBundle,
+  MigrationBundle,
   MigrationChainEntry,
   MigrationGraph,
 } from '@prisma-next/migration-tools/types';
@@ -62,7 +61,7 @@ export interface MigrationStatusEntry {
   readonly dirName: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly operationCount: number;
   readonly operationSummary: string;
   readonly hasDestructive: boolean;
@@ -87,7 +86,7 @@ export interface MigrationStatusResult {
     readonly refName?: string;
     readonly selectedPath: readonly {
       readonly dirName: string;
-      readonly migrationId: string | null;
+      readonly migrationId: string;
       readonly from: string;
       readonly to: string;
     }[];
@@ -95,8 +94,7 @@ export interface MigrationStatusResult {
   readonly summary: string;
   readonly diagnostics: readonly StatusDiagnostic[];
   readonly graph?: MigrationGraph;
-  readonly bundles?: readonly AttestedMigrationBundle[];
-  readonly drafts?: readonly DraftMigrationBundle[];
+  readonly bundles?: readonly MigrationBundle[];
   readonly edgeStatuses?: readonly EdgeStatus[];
   readonly activeRefHash?: string;
   readonly activeRefName?: string;
@@ -227,7 +225,7 @@ export function deriveEdgeStatuses(
  */
 function buildMigrationEntries(
   chain: readonly MigrationChainEntry[],
-  packages: readonly AttestedMigrationBundle[],
+  packages: readonly MigrationBundle[],
   mode: 'online' | 'offline',
   markerHash: string | undefined,
   edgeStatuses?: readonly EdgeStatus[],
@@ -347,7 +345,7 @@ async function executeMigrationStatusCommand(
   ui: TerminalUI,
 ): Promise<Result<MigrationStatusResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsPath } = resolveMigrationPaths(
+  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -359,7 +357,7 @@ async function executeMigrationStatusCommand(
   let activeRefHash: string | undefined;
   let allRefs: Refs = {};
   try {
-    allRefs = await readRefs(refsPath);
+    allRefs = await readRefs(refsDir);
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(
@@ -375,30 +373,25 @@ async function executeMigrationStatusCommand(
 
   if (options.ref) {
     activeRefName = options.ref;
-    const refHash = allRefs[activeRefName];
-    if (refHash) {
-      activeRefHash = refHash;
-    } else {
-      try {
-        activeRefHash = resolveRef(allRefs, activeRefName);
-      } catch (error) {
-        if (MigrationToolsError.is(error)) {
-          return notOk(
-            errorRuntime(error.message, {
-              why: error.why,
-              fix: error.fix,
-              meta: { code: error.code },
-            }),
-          );
-        }
-        throw error;
+    try {
+      activeRefHash = resolveRef(allRefs, activeRefName).hash;
+    } catch (error) {
+      if (MigrationToolsError.is(error)) {
+        return notOk(
+          errorRuntime(error.message, {
+            why: error.why,
+            fix: error.fix,
+            meta: { code: error.code },
+          }),
+        );
       }
+      throw error;
     }
   }
 
-  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, hash]) => ({
+  const statusRefs: StatusRef[] = Object.entries(allRefs).map(([name, entry]) => ({
     name,
-    hash,
+    hash: entry.hash,
     active: name === activeRefName,
   }));
 
@@ -436,11 +429,10 @@ async function executeMigrationStatusCommand(
     });
   }
 
-  let attested: readonly AttestedMigrationBundle[];
-  let drafts: readonly DraftMigrationBundle[];
+  let bundles: readonly MigrationBundle[];
   let graph: MigrationGraph;
   try {
-    ({ attested, drafts, graph } = await loadAllBundles(migrationsDir));
+    ({ bundles, graph } = await loadAllBundles(migrationsDir));
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(
@@ -454,18 +446,7 @@ async function executeMigrationStatusCommand(
     );
   }
 
-  if (drafts.length > 0) {
-    diagnostics.push({
-      code: 'MIGRATION.DRAFTS',
-      severity: 'warn',
-      message: `${drafts.length} draft migration(s) found: ${drafts.map((d) => d.dirName).join(', ')}`,
-      hints: [
-        "Run 'prisma-next migration emit --dir <path>' to attest draft migrations before applying",
-      ],
-    });
-  }
-
-  if (attested.length === 0) {
+  if (bundles.length === 0) {
     if (contractHash !== EMPTY_CONTRACT_HASH) {
       diagnostics.push({
         code: 'CONTRACT.AHEAD',
@@ -576,7 +557,7 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       markerHash,
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
@@ -616,12 +597,12 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       ...ifDefined('markerHash', markerHash),
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
       graph,
-      bundles: attested,
+      bundles,
       diverged: true,
     });
   }
@@ -638,7 +619,7 @@ async function executeMigrationStatusCommand(
   }
 
   const edgeStatuses = deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode);
-  const entries = buildMigrationEntries(chain, attested, mode, markerHash, edgeStatuses);
+  const entries = buildMigrationEntries(chain, bundles, mode, markerHash, edgeStatuses);
 
   const pendingCount = edgeStatuses.filter((e) => e.status === 'pending').length;
   const appliedCount = edgeStatuses.filter((e) => e.status === 'applied').length;
@@ -646,7 +627,7 @@ async function executeMigrationStatusCommand(
   let summary: string;
   if (mode === 'online') {
     if (markerHash !== undefined && !graph.nodes.has(markerHash) && markerHash === contractHash) {
-      summary = `${attested.length} migration(s) on disk`;
+      summary = `${bundles.length} migration(s) on disk`;
     } else if (activeRefHash && markerHash !== undefined) {
       summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName!);
     } else if (pendingCount === 0) {
@@ -706,8 +687,7 @@ async function executeMigrationStatusCommand(
     ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
     ...ifDefined('pathDecision', pathDecision),
     graph,
-    bundles: attested,
-    ...(drafts.length > 0 ? { drafts } : {}),
+    bundles,
     edgeStatuses,
     ...ifDefined('activeRefHash', activeRefHash),
     ...ifDefined('activeRefName', activeRefName),
@@ -768,11 +748,6 @@ export function createMigrationStatusCommand(): Command {
               activeRefHash: statusResult.activeRefHash,
               activeRefName: statusResult.activeRefName,
               edgeStatuses: statusResult.edgeStatuses,
-              draftEdges: statusResult.drafts?.map((d) => ({
-                from: d.manifest.from,
-                to: d.manifest.to,
-                dirName: d.dirName,
-              })),
             });
 
             const graphToRender =

package/src/config-loader.ts

@@ -1,4 +1,3 @@
-import { dirname, resolve } from 'node:path';
 import type { PrismaNextConfig } from '@prisma-next/config/config-types';
 import { ConfigValidationError, validateConfig } from '@prisma-next/config/config-validation';
 import {
@@ -6,7 +5,41 @@ import {
   errorConfigValidation,
   errorUnexpected,
 } from '@prisma-next/errors/control';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { loadConfig as loadConfigC12 } from 'c12';
+import { dirname, resolve } from 'pathe';
+import { finalizeConfig } from './config-path-validation';
+
+async function loadValidatedConfig(configPath?: string): Promise<PrismaNextConfig> {
+  const cwd = process.cwd();
+  const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
+  const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
+
+  const result = await loadConfigC12<PrismaNextConfig>({
+    name: 'prisma-next',
+    ...ifDefined('configFile', resolvedConfigPath),
+    cwd: configCwd,
+  });
+
+  // When a specific config file was requested, verify it was actually loaded
+  // (c12 falls back to searching by name if the specified file doesn't exist)
+  if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
+    throw errorConfigFileNotFound(resolvedConfigPath);
+  }
+
+  // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
+  if (!result.config || Object.keys(result.config).length === 0) {
+    // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
+    const displayPath = result.configFile || resolvedConfigPath || configPath;
+    throw errorConfigFileNotFound(displayPath);
+  }
+
+  // Validate config structure
+  validateConfig(result.config);
+
+  const loadedConfigDir = result.configFile ? dirname(result.configFile) : configCwd;
+  return finalizeConfig(result.config, loadedConfigDir);
+}
 
 /**
  * Loads the Prisma Next config from a TypeScript file.
@@ -19,34 +52,7 @@ import { loadConfig as loadConfigC12 } from 'c12';
  */
 export async function loadConfig(configPath?: string): Promise<PrismaNextConfig> {
   try {
-    const cwd = process.cwd();
-    // Resolve config path to absolute path and set cwd to config directory when path is provided
-    const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
-    const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
-
-    const result = await loadConfigC12<PrismaNextConfig>({
-      name: 'prisma-next',
-      ...(resolvedConfigPath ? { configFile: resolvedConfigPath } : {}),
-      cwd: configCwd,
-    });
-
-    // When a specific config file was requested, verify it was actually loaded
-    // (c12 falls back to searching by name if the specified file doesn't exist)
-    if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
-      throw errorConfigFileNotFound(resolvedConfigPath);
-    }
-
-    // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
-    if (!result.config || Object.keys(result.config).length === 0) {
-      // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
-      const displayPath = result.configFile || resolvedConfigPath || configPath;
-      throw errorConfigFileNotFound(displayPath);
-    }
-
-    // Validate config structure
-    validateConfig(result.config);
-
-    return result.config;
+    return await loadValidatedConfig(configPath);
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       throw errorConfigValidation(error.field, {

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',