@prisma-next/cli 0.11.0-dev.9 → 0.12.0-dev.1

package/src/utils/formatters/migrations.ts

@@ -1,7 +1,7 @@
 import type { OperationPreview } from '@prisma-next/framework-components/control';
 import { cyan, green, yellow } from 'colorette';
 
-import type { AggregatePerSpaceExecutionEntry } from '../../control-api/types';
+import type { PerSpaceExecutionEntry } from '../../control-api/types';
 import type { GlobalFlags } from '../global-flags';
 import { createColorFormatter, formatDim, isVerbose } from './helpers';
 
@@ -79,9 +79,9 @@ export interface MigrationCommandResult {
    * (extensions alphabetically, then app). Surfaces per-space markers
    * and the ops grouped by space, so the CLI summary can name which
    * space each op and marker belongs to instead of flattening them
-   * into a single ambiguous list. See {@link AggregatePerSpaceExecutionEntry}.
+   * into a single ambiguous list. See {@link PerSpaceExecutionEntry}.
    */
-  readonly perSpace?: ReadonlyArray<AggregatePerSpaceExecutionEntry>;
+  readonly perSpace?: ReadonlyArray<PerSpaceExecutionEntry>;
   readonly advancedRef?: { readonly name: string; readonly hash: string } | null;
   readonly plannedAdvanceRef?: { readonly name: string; readonly hash: string } | null;
   readonly summary: string;
@@ -101,7 +101,7 @@ export interface MigrationCommandResult {
  * entirely (no marker has been written yet).
  */
 export function formatPerSpaceBlock(
-  perSpace: ReadonlyArray<AggregatePerSpaceExecutionEntry>,
+  perSpace: ReadonlyArray<PerSpaceExecutionEntry>,
   mode: 'plan' | 'apply',
   useColor: boolean,
 ): readonly string[] {
@@ -182,7 +182,7 @@ export function formatMigrationPlanOutput(
       );
     }
   } else if (result.plan?.operations && result.plan.operations.length > 0) {
-    // Single-space fallback (no aggregate breakdown). Same flat tree
+    // App-only / no-aggregate-breakdown fallback. Same flat tree
     // we've always rendered.
     lines.push(`${formatDimText('│')}`);
     for (let i = 0; i < result.plan.operations.length; i++) {
@@ -267,7 +267,7 @@ export interface MigrationApplyCommandOutputResult {
    * alphabetically, then app). Always present for the aggregate-walking
    * `migrate` command.
    */
-  readonly perSpace: readonly AggregatePerSpaceExecutionEntry[];
+  readonly perSpace: readonly PerSpaceExecutionEntry[];
   readonly timings?: {
     readonly total: number;
   };
@@ -314,9 +314,7 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-interface MigrationShowSpacePresent {
-  readonly kind: 'present';
-  readonly spaceId: string;
+interface MigrationShowPresent {
   readonly dirName: string;
   readonly dirPath: string;
   readonly from: string | null;
@@ -332,22 +330,11 @@ interface MigrationShowSpacePresent {
   readonly summary: string;
 }
 
-interface MigrationShowSpaceMissing {
-  readonly kind: 'missing';
-  readonly spaceId: string;
-  readonly summary: string;
-}
-
-type MigrationShowSpaceResult = MigrationShowSpacePresent | MigrationShowSpaceMissing;
-
 interface MigrationShowResult {
-  readonly spaces: readonly MigrationShowSpaceResult[];
+  readonly migration: MigrationShowPresent;
 }
 
-function formatSpaceShowBlock(
-  space: MigrationShowSpacePresent,
-  useColor: boolean,
-): readonly string[] {
+function formatSpaceShowBlock(space: MigrationShowPresent, useColor: boolean): readonly string[] {
   const formatGreen = createColorFormatter(useColor, green);
   const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
@@ -403,28 +390,7 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   }
 
   const useColor = flags.color !== false;
-  const formatDimText = (text: string) => formatDim(useColor, text);
-  const multipleSpaces = result.spaces.length > 1;
-  const lines: string[] = [];
-
-  for (let i = 0; i < result.spaces.length; i++) {
-    const space = result.spaces[i]!;
-    if (multipleSpaces) {
-      lines.push(formatDimText(`── ${space.spaceId} ──`));
-    }
-    if (space.kind === 'missing') {
-      lines.push(formatDimText(`  ${space.summary}`));
-    } else {
-      for (const line of formatSpaceShowBlock(space, useColor)) {
-        lines.push(line);
-      }
-    }
-    if (i < result.spaces.length - 1) {
-      lines.push('');
-    }
-  }
-
-  return lines.join('\n');
+  return formatSpaceShowBlock(result.migration, useColor).join('\n');
 }
 
 /**
@@ -475,8 +441,8 @@ export function formatMigrationApplyOutput(
         ),
       );
     } else if (result.marker) {
-      // Single-space fallback (no aggregate breakdown surfaced — e.g.
-      // older callers / non-aggregate code paths). The label is
+      // App-only / no-aggregate-breakdown fallback (e.g. older callers
+      // / non-aggregate code paths). The label is
       // `App-space marker` (not `Signature`) so that when only one
       // marker is observable we still name what it covers explicitly.
       lines.push(`${formatDimText(`  App-space marker: ${result.marker.storageHash}`)}`);

package/src/utils/glyph-mode.ts

@@ -0,0 +1,22 @@
+export type GlyphMode = 'unicode' | 'ascii';
+
+export interface GlyphModeInput {
+  readonly isTTY: boolean;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+function localeString(env: Readonly<Record<string, string | undefined>>): string {
+  return env['LC_ALL'] ?? env['LC_CTYPE'] ?? env['LANG'] ?? '';
+}
+
+function isUtf8Locale(env: Readonly<Record<string, string | undefined>>): boolean {
+  const locale = localeString(env);
+  if (locale.length === 0) return false;
+  return /UTF-8|utf8/i.test(locale);
+}
+
+export function detectGlyphMode(input: GlyphModeInput): GlyphMode {
+  if (!input.isTTY) return 'ascii';
+  if (!isUtf8Locale(input.env)) return 'ascii';
+  return 'unicode';
+}

package/src/utils/integrity-violation-to-check-failure.ts

@@ -0,0 +1,130 @@
+import type { IntegrityViolation } from '@prisma-next/migration-tools/aggregate';
+import { join, relative } from 'pathe';
+
+export interface CheckFailure {
+  readonly pnCode: string;
+  readonly where: string;
+  readonly why: string;
+  readonly fix: string;
+}
+
+function migrationPathRelative(dirPath: string): string {
+  return relative(process.cwd(), dirPath);
+}
+
+function migrationFileRelative(dirPath: string, fileName: string): string {
+  return join(migrationPathRelative(dirPath), fileName);
+}
+
+/**
+ * Map one {@link IntegrityViolation} onto a `migration check` failure row.
+ * Sole catalogue mapping from integrity violations to `PN-MIG-CHECK-*`.
+ */
+export function integrityViolationToCheckFailure(
+  violation: IntegrityViolation,
+  migrationsDir: string,
+): CheckFailure {
+  const spaceRelative = (spaceId: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId));
+  const packageRelative = (spaceId: string, dirName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, dirName));
+  const refRelative = (spaceId: string, refName: string): string =>
+    migrationPathRelative(join(migrationsDir, spaceId, 'refs', `${refName}.json`));
+
+  switch (violation.kind) {
+    case 'hashMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-001',
+        where: migrationFileRelative(
+          join(migrationsDir, violation.spaceId, violation.dirName),
+          'migration.json',
+        ),
+        why: `Stored hash ${violation.stored} does not match recomputed hash ${violation.computed}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'providedInvariantsMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" providedInvariants in migration.json disagrees with ops.json.`,
+        fix: 'Re-emit the migration package so migration.json and ops.json agree.',
+      };
+    case 'packageUnloadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-002',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" could not be loaded: ${violation.detail}`,
+        fix: 'Re-emit the migration package or restore from version control.',
+      };
+    case 'sameSourceAndTarget':
+      return {
+        pnCode: 'PN-MIG-CHECK-007',
+        where: packageRelative(violation.spaceId, violation.dirName),
+        why: `Migration "${violation.dirName}" in space "${violation.spaceId}" has source equal to target (${violation.hash}) with no data invariant — a true no-op self-edge.`,
+        fix: 'Add a data operation if this self-edge was meant to carry a data invariant, or delete the migration if it is a true no-op.',
+      };
+    case 'orphanSpaceDir':
+      return {
+        pnCode: 'PN-MIG-CHECK-008',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract-space directory "${violation.spaceId}" exists on disk but no extension declares it.`,
+        fix: 'Remove the orphan directory, or declare the extension in `extensionPacks`.',
+      };
+    case 'declaredButUnmigrated':
+      return {
+        pnCode: 'PN-MIG-CHECK-009',
+        where: spaceRelative(violation.spaceId),
+        why: `Extension "${violation.spaceId}" is declared in \`extensionPacks\` but has no on-disk migrations directory.`,
+        fix: 'Re-emit the extension contract-space artefacts with `prisma-next contract emit` and migration planning, or remove the extension from `extensionPacks` if it is unused.',
+      };
+    case 'headRefMissing':
+      return {
+        pnCode: 'PN-MIG-CHECK-010',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref \`refs/head.json\` is missing for contract space "${violation.spaceId}".`,
+        fix: 'Re-emit the contract-space migrations and head ref artefacts, or restore `refs/head.json` from version control.',
+      };
+    case 'headRefNotInGraph':
+      return {
+        pnCode: 'PN-MIG-CHECK-011',
+        where: refRelative(violation.spaceId, 'head'),
+        why: `Head ref ${violation.hash} for contract space "${violation.spaceId}" is not present in its migration graph.`,
+        fix: 'Re-emit the contract space migrations, or restore the missing migration package.',
+      };
+    case 'refUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-012',
+        where: refRelative(violation.spaceId, violation.refName),
+        why: `Ref "${violation.refName}" for contract space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Repair or remove the corrupt ref file.',
+      };
+    case 'targetMismatch':
+      return {
+        pnCode: 'PN-MIG-CHECK-013',
+        where: spaceRelative(violation.spaceId),
+        why: `Contract space "${violation.spaceId}" targets "${violation.actual}" but the project targets "${violation.expected}".`,
+        fix: 'Update the extension to target the configured database, or change the project target.',
+      };
+    case 'disjointness':
+      return {
+        pnCode: 'PN-MIG-CHECK-014',
+        where: migrationPathRelative(migrationsDir),
+        why: `Storage element "${violation.element}" is claimed by multiple contract spaces: ${violation.claimedBy.join(', ')}.`,
+        fix: 'Update the contracts so each storage element is owned by exactly one contract space.',
+      };
+    case 'contractUnreadable':
+      return {
+        pnCode: 'PN-MIG-CHECK-015',
+        where: migrationFileRelative(join(migrationsDir, violation.spaceId), 'contract.json'),
+        why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+        fix: 'Re-emit the extension contract artefacts, or fix the descriptor producing the invalid contract.',
+      };
+    case 'duplicateMigrationHash':
+      return {
+        pnCode: 'PN-MIG-CHECK-016',
+        where: spaceRelative(violation.spaceId),
+        why: `Multiple migrations in space "${violation.spaceId}" share migrationHash "${violation.migrationHash}" (${violation.dirNames.join(', ')}).`,
+        fix: 'Re-emit one of the conflicting packages so each migrationHash is unique.',
+      };
+  }
+}

package/src/utils/plan-resolution.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '@prisma-next/contract/types';
-import type { ControlFamilyInstance } from '@prisma-next/framework-components/control';
+import type { ContractSpaceMember } from '@prisma-next/migration-tools/aggregate';
 import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import {
@@ -7,20 +7,17 @@ import {
   findLatestMigration,
   isGraphNode,
 } from '@prisma-next/migration-tools/migration-graph';
-import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
+import type { ContractRef } from '@prisma-next/migration-tools/ref-resolution';
 import { parseContractRef } from '@prisma-next/migration-tools/ref-resolution';
 import type { Refs } from '@prisma-next/migration-tools/refs';
-import { readRefSnapshot, readRefs } from '@prisma-next/migration-tools/refs';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import {
   CliStructuredError,
-  errorContractValidationFailed,
   errorPlanForgotTheFlag,
   errorSnapshotMissing,
-  errorUnexpected,
-  mapMigrationToolsError,
   mapRefResolutionError,
 } from './cli-errors';
+import { mapContractAtError } from './contract-at-errors';
 
 const FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;
 
@@ -48,15 +45,11 @@ export type FromResolution =
 
 export interface ResolveFromForPlanInput {
   readonly optionsFrom?: string | undefined;
-  readonly refsDir: string;
-  readonly bundles: readonly OnDiskMigrationPackage[];
-  readonly graph: MigrationGraph;
-  readonly familyInstance: ControlFamilyInstance<string, unknown>;
-  readonly readBundleEndContract: (migrationDir: string) => Promise<Contract>;
+  readonly member: ContractSpaceMember;
 }
 
-function graphIsEmpty(bundles: readonly OnDiskMigrationPackage[]): boolean {
-  return bundles.length === 0;
+function graphIsEmpty(member: ContractSpaceMember): boolean {
+  return member.packages.length === 0;
 }
 
 function getReachableRefs(
@@ -86,158 +79,136 @@ export function assertFromIsGraphNode(
   }
 }
 
-async function deserializeSnapshotContract(
-  familyInstance: ControlFamilyInstance<string, unknown>,
-  contract: unknown,
-): Promise<Result<Contract, CliStructuredError>> {
-  try {
-    return ok(familyInstance.deserializeContract(contract));
-  } catch (error) {
-    if (CliStructuredError.is(error)) {
-      return notOk(error);
+type RefContractResolution =
+  | {
+      kind: 'snapshot';
+      hash: string;
+      contract: Contract;
+      contractJson: unknown;
+      contractDts: string;
     }
-    return notOk(
-      errorContractValidationFailed(
-        `Ref snapshot contract failed to deserialize: ${error instanceof Error ? error.message : String(error)}`,
-        { where: { path: 'ref-snapshot' } },
-      ),
-    );
-  }
-}
+  | {
+      kind: 'graph-node';
+      hash: string;
+      contract: Contract;
+      contractJson: unknown;
+      contractDts: string;
+      sourceDir: string;
+    };
+
+async function resolveContractRef(
+  parsed: ContractRef,
+  member: ContractSpaceMember,
+  options?: { readonly explicitLabel?: string; readonly artifactRole?: 'from' | 'to' },
+): Promise<Result<RefContractResolution, CliStructuredError>> {
+  const { hash, provenance } = parsed;
+  const refName = provenance.kind === 'ref' ? provenance.refName : undefined;
 
-async function resolveGraphNodeFromBundle(
-  fromHash: string,
-  bundles: readonly OnDiskMigrationPackage[],
-  readBundleEndContract: (migrationDir: string) => Promise<Contract>,
-  explicitFromLabel?: string,
-): Promise<Result<Extract<FromResolution, { kind: 'graph-node' }>, CliStructuredError>> {
-  const matchingBundle = bundles.find((pkg) => pkg.metadata.to === fromHash);
-  if (!matchingBundle) {
-    return notOk(
-      errorUnexpected(
-        explicitFromLabel
-          ? `No migration bundle found for --from "${explicitFromLabel}" (resolved hash: ${fromHash})`
-          : `No migration bundle found for graph node ${fromHash}`,
-        {
-          why: `The hash ${fromHash} is a graph node but no on-disk migration package has an end-contract hash matching it.`,
-          fix: 'Provide a ref or hash that corresponds to an existing migration package, or run `migration list` to see available migrations.',
-        },
-      ),
-    );
-  }
   try {
-    const fromContract = await readBundleEndContract(matchingBundle.dirPath);
+    const at = await member.contractAt(hash, refName !== undefined ? { refName } : undefined);
+
+    if (at.provenance === 'snapshot') {
+      return ok({
+        kind: 'snapshot',
+        hash: at.hash,
+        contract: at.contract,
+        contractJson: at.contractJson,
+        contractDts: at.contractDts,
+      });
+    }
+
     return ok({
       kind: 'graph-node',
-      fromHash,
-      fromContract,
-      sourceDir: matchingBundle.dirPath,
+      hash: at.hash,
+      contract: at.contract,
+      contractJson: at.contractJson,
+      contractDts: at.contractDts,
+      sourceDir: at.sourceDir,
     });
   } catch (error) {
-    if (CliStructuredError.is(error)) {
-      return notOk(error);
-    }
-    throw error;
+    return mapContractAtError(
+      error,
+      options?.artifactRole !== undefined ? { artifactRole: options.artifactRole } : undefined,
+    );
   }
 }
 
-async function resolveFromRefName(
-  refName: string,
-  fromHash: string,
+async function resolveFromPolicy(
+  parsed: ContractRef,
   input: ResolveFromForPlanInput,
   refs: Refs,
+  explicitFromLabel?: string,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const { refsDir, bundles, graph, familyInstance, readBundleEndContract } = input;
-  const empty = graphIsEmpty(bundles);
-  const graphTip = findLatestMigration(graph)?.to ?? null;
-
-  let snapshot: Awaited<ReturnType<typeof readRefSnapshot>>;
-  try {
-    snapshot = await readRefSnapshot(refsDir, refName);
-  } catch (error) {
-    if (MigrationToolsError.is(error)) {
-      return notOk(mapMigrationToolsError(error));
-    }
-    throw error;
+  const resolution = await resolveContractRef(parsed, input.member, {
+    ...(explicitFromLabel !== undefined ? { explicitLabel: explicitFromLabel } : {}),
+    artifactRole: 'from',
+  });
+  if (!resolution.ok) {
+    return resolution;
   }
 
-  if (snapshot) {
-    const contractResult = await deserializeSnapshotContract(familyInstance, snapshot.contract);
-    if (!contractResult.ok) {
-      return contractResult;
-    }
-    const fromContract = contractResult.value;
-    const { contractDts, contract: contractJson } = snapshot;
-    if (empty) {
-      return ok({ kind: 'auto-baseline', fromHash, fromContract, contractDts, contractJson });
-    }
-    try {
-      assertFromIsGraphNode(fromHash, graph, refs, graphTip);
-    } catch (error) {
-      if (CliStructuredError.is(error)) {
-        return notOk(error);
-      }
-      throw error;
-    }
-    return ok({ kind: 'snapshot', fromHash, fromContract, contractDts, contractJson });
+  if (resolution.value.kind === 'graph-node') {
+    return ok({
+      kind: 'graph-node',
+      fromHash: resolution.value.hash,
+      fromContract: resolution.value.contract,
+      sourceDir: resolution.value.sourceDir,
+    });
   }
 
-  if (isGraphNode(fromHash, graph)) {
-    return resolveGraphNodeFromBundle(fromHash, bundles, readBundleEndContract);
+  const { hash, contract, contractJson, contractDts } = resolution.value;
+  if (graphIsEmpty(input.member)) {
+    return ok({
+      kind: 'auto-baseline',
+      fromHash: hash,
+      fromContract: contract,
+      contractDts,
+      contractJson,
+    });
   }
 
-  return notOk(errorSnapshotMissing(refName));
-}
-
-async function resolveFromHashProvenance(
-  fromHash: string,
-  input: ResolveFromForPlanInput,
-  _refs: Refs,
-  explicitFromLabel?: string,
-): Promise<Result<FromResolution, CliStructuredError>> {
-  const { bundles, graph } = input;
-
-  if (isGraphNode(fromHash, graph)) {
-    return resolveGraphNodeFromBundle(
-      fromHash,
-      bundles,
-      input.readBundleEndContract,
-      explicitFromLabel,
-    );
+  const graph = input.member.graph();
+  const graphTip = findLatestMigration(graph)?.to ?? null;
+  try {
+    assertFromIsGraphNode(hash, graph, refs, graphTip);
+  } catch (error) {
+    if (CliStructuredError.is(error)) {
+      return notOk(error);
+    }
+    throw error;
   }
-
-  throw new Error(
-    `resolveFromHashProvenance: non-graph-node hash ${fromHash} should be refused via looksLikeFullHash before this helper is called`,
-  );
+  return ok({
+    kind: 'snapshot',
+    fromHash: hash,
+    fromContract: contract,
+    contractDts,
+    contractJson,
+  });
 }
 
 export async function resolveFromForPlan(
   input: ResolveFromForPlanInput,
 ): Promise<Result<FromResolution, CliStructuredError>> {
-  const { optionsFrom, refsDir, graph } = input;
-
-  let refs: Refs;
-  try {
-    refs = await readRefs(refsDir);
-  } catch (error) {
-    if (MigrationToolsError.is(error)) {
-      return notOk(mapMigrationToolsError(error));
-    }
-    throw error;
-  }
+  const { optionsFrom, member } = input;
+  const graph = member.graph();
+  const refs = member.refs;
 
   if (optionsFrom === undefined) {
     const dbRef = refs['db'];
     if (!dbRef) {
       return ok({ kind: 'greenfield', fromHash: null, fromContract: null });
     }
-    return resolveFromRefName('db', dbRef.hash, input, refs);
+    return resolveFromPolicy(
+      { hash: dbRef.hash, provenance: { kind: 'ref', refName: 'db' } },
+      input,
+      refs,
+    );
   }
 
   const refResult = parseContractRef(optionsFrom, { graph, refs });
   if (!refResult.ok) {
     if (looksLikeFullHash(optionsFrom)) {
-      const empty = graphIsEmpty(input.bundles);
+      const empty = graphIsEmpty(member);
       const graphTip = findLatestMigration(graph)?.to ?? null;
       if (empty) {
         return notOk(errorSnapshotMissing(optionsFrom, { viaRef: false }));
@@ -247,11 +218,41 @@ export async function resolveFromForPlan(
     return notOk(mapRefResolutionError(refResult.failure));
   }
 
-  const { hash: fromHash, provenance } = refResult.value;
+  return resolveFromPolicy(refResult.value, input, refs, optionsFrom);
+}
+
+export interface ResolveToForPlanInput {
+  readonly member: ContractSpaceMember;
+}
+
+export interface ResolvedContractRef {
+  readonly hash: string;
+  readonly contract: Contract;
+  readonly contractJson: unknown;
+  readonly contractDts: string;
+}
+
+export async function resolveToForPlan(
+  optionsTo: string,
+  input: ResolveToForPlanInput,
+): Promise<Result<ResolvedContractRef, CliStructuredError>> {
+  const { member } = input;
+  const graph = member.graph();
+  const refs = member.refs;
+
+  const refResult = parseContractRef(optionsTo, { graph, refs });
+  if (!refResult.ok) {
+    return notOk(mapRefResolutionError(refResult.failure));
+  }
 
-  if (provenance.kind === 'ref') {
-    return resolveFromRefName(provenance.refName, fromHash, input, refs);
+  const resolution = await resolveContractRef(refResult.value, member, {
+    explicitLabel: optionsTo,
+    artifactRole: 'to',
+  });
+  if (!resolution.ok) {
+    return resolution;
   }
 
-  return resolveFromHashProvenance(fromHash, input, refs, optionsFrom);
+  const { hash, contract, contractJson, contractDts } = resolution.value;
+  return ok({ hash, contract, contractJson, contractDts });
 }