@prisma-next/core-control-plane 0.3.0-dev.13 → 0.3.0-dev.131

package/package.json

@@ -1,65 +1,53 @@
 {
   "name": "@prisma-next/core-control-plane",
-  "version": "0.3.0-dev.13",
+  "version": "0.3.0-dev.131",
   "type": "module",
   "sideEffects": false,
-  "description": "Control plane domain actions, config types, validation, and error factories for Prisma Next",
+  "description": "Control-plane migration/emission primitives and structured error utilities",
   "dependencies": {
     "arktype": "^2.1.26",
     "prettier": "^3.3.3",
-    "@prisma-next/contract": "0.3.0-dev.13",
-    "@prisma-next/operations": "0.3.0-dev.13",
-    "@prisma-next/utils": "0.3.0-dev.13"
+    "@prisma-next/operations": "0.3.0-dev.131",
+    "@prisma-next/contract": "0.3.0-dev.131",
+    "@prisma-next/utils": "0.3.0-dev.131"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@prisma-next/test-utils": "0.0.1"
+    "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "exports": {
-    "./config-types": {
-      "types": "./dist/exports/config-types.d.ts",
-      "import": "./dist/exports/config-types.js"
-    },
-    "./config-validation": {
-      "types": "./dist/exports/config-validation.d.ts",
-      "import": "./dist/exports/config-validation.js"
-    },
-    "./errors": {
-      "types": "./dist/exports/errors.d.ts",
-      "import": "./dist/exports/errors.js"
-    },
-    "./types": {
-      "types": "./dist/exports/types.d.ts",
-      "import": "./dist/exports/types.js"
-    },
-    "./stack": {
-      "types": "./dist/exports/stack.d.ts",
-      "import": "./dist/exports/stack.js"
-    },
-    "./emission": {
-      "types": "./dist/exports/emission.d.ts",
-      "import": "./dist/exports/emission.js"
-    },
-    "./schema-view": {
-      "types": "./dist/exports/schema-view.d.ts",
-      "import": "./dist/exports/schema-view.js"
-    }
+    "./constants": "./dist/constants.mjs",
+    "./emission": "./dist/emission.mjs",
+    "./errors": "./dist/errors.mjs",
+    "./schema-view": "./dist/schema-view.mjs",
+    "./stack": "./dist/stack.mjs",
+    "./types": "./dist/types.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/1-framework/1-core/migration/control-plane"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "typecheck": "tsc --noEmit",
     "lint": "biome check . --error-on-warnings",
     "lint:fix": "biome check --write .",
     "lint:fix:unsafe": "biome check --write --unsafe .",
-    "clean": "node ../../../../../scripts/clean.mjs"
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * Sentinel value representing the absence of a contract (empty/new project).
+ * This is a human-readable marker, not a real SHA-256 hash.
+ */
+export const EMPTY_CONTRACT_HASH = 'sha256:empty' as const;

package/src/emission/canonicalization.ts

@@ -1,19 +1,39 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
+import { bigintJsonReplacer } from '@prisma-next/contract/types';
 import { isArrayEqual } from '@prisma-next/utils/array-equal';
+import { ifDefined } from '@prisma-next/utils/defined';
 
 type NormalizedContract = {
   schemaVersion: string;
   targetFamily: string;
   target: string;
-  coreHash?: string;
+  storageHash?: string;
+  executionHash?: string;
   profileHash?: string;
+  roots?: Record<string, string>;
   models: Record<string, unknown>;
-  relations: Record<string, unknown>;
+  relations?: Record<string, unknown>;
   storage: Record<string, unknown>;
+  execution?: Record<string, unknown>;
   extensionPacks: Record<string, unknown>;
   capabilities: Record<string, Record<string, boolean>>;
   meta: Record<string, unknown>;
-  sources: Record<string, unknown>;
+};
+
+export type CanonicalContractInput = {
+  schemaVersion: string;
+  targetFamily: string;
+  target: string;
+  roots?: Record<string, string>;
+  models: Record<string, unknown>;
+  relations?: Record<string, unknown>;
+  storage: Record<string, unknown>;
+  execution?: Record<string, unknown>;
+  extensionPacks: Record<string, unknown>;
+  capabilities: Record<string, Record<string, boolean>>;
+  meta: Record<string, unknown>;
+  storageHash?: string;
+  executionHash?: string;
+  profileHash?: string;
 };
 
 const TOP_LEVEL_ORDER = [
@@ -21,19 +41,23 @@ const TOP_LEVEL_ORDER = [
   'canonicalVersion',
   'targetFamily',
   'target',
-  'coreHash',
+  'storageHash',
+  'executionHash',
   'profileHash',
+  'roots',
   'models',
+  'relations',
   'storage',
+  'execution',
   'capabilities',
   'extensionPacks',
   'meta',
-  'sources',
 ] as const;
 
 function isDefaultValue(value: unknown): boolean {
   if (value === false) return true;
   if (value === null) return false;
+  if (value instanceof Date) return false;
   if (Array.isArray(value) && value.length === 0) return true;
   if (typeof value === 'object' && value !== null) {
     const keys = Object.keys(value);
@@ -47,6 +71,10 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
     return obj;
   }
 
+  if (obj instanceof Date) {
+    return obj;
+  }
+
   if (Array.isArray(obj)) {
     return obj.map((item) => omitDefaults(item, path));
   }
@@ -69,14 +97,30 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       continue;
     }
 
+    // Strip 'noAction' referential actions (the database default) for hash stability.
+    // A contract with explicit `onDelete: 'noAction'` is semantically identical to
+    // one that omits `onDelete` entirely, so they should produce the same hash.
+    if ((key === 'onDelete' || key === 'onUpdate') && value === 'noAction') {
+      continue;
+    }
+
     if (isDefaultValue(value)) {
       const isRequiredModels = isArrayEqual(currentPath, ['models']);
       const isRequiredTables = isArrayEqual(currentPath, ['storage', 'tables']);
+      const isRequiredCollections = isArrayEqual(currentPath, ['storage', 'collections']);
+      const isCollectionEntry =
+        currentPath.length === 3 &&
+        isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'collections']);
       const isRequiredRelations = isArrayEqual(currentPath, ['relations']);
+      const isRequiredRoots = isArrayEqual(currentPath, ['roots']);
       const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);
       const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);
       const isRequiredMeta = isArrayEqual(currentPath, ['meta']);
-      const isRequiredSources = isArrayEqual(currentPath, ['sources']);
+      const isRequiredExecutionDefaults = isArrayEqual(currentPath, [
+        'execution',
+        'mutations',
+        'defaults',
+      ]);
       const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === 'extensionPacks';
       const isModelRelations =
         currentPath.length === 3 &&
@@ -100,19 +144,33 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
           ['storage', 'tables', 'foreignKeys'],
         );
 
+      // Preserve per-FK `constraint` and `index` booleans (even when `false`)
+      // so that hash distinguishes `false` from absent.
+      // Path: ['storage', 'tables', <tableName>, 'foreignKeys', 'constraint' | 'index']
+      const isFkBooleanField =
+        currentPath.length === 5 &&
+        currentPath[0] === 'storage' &&
+        currentPath[1] === 'tables' &&
+        currentPath[3] === 'foreignKeys' &&
+        (key === 'constraint' || key === 'index');
+
       if (
         !isRequiredModels &&
         !isRequiredTables &&
+        !isRequiredCollections &&
+        !isCollectionEntry &&
         !isRequiredRelations &&
+        !isRequiredRoots &&
         !isRequiredExtensionPacks &&
         !isRequiredCapabilities &&
         !isRequiredMeta &&
-        !isRequiredSources &&
+        !isRequiredExecutionDefaults &&
         !isExtensionNamespace &&
         !isModelRelations &&
         !isTableUniques &&
         !isTableIndexes &&
-        !isTableForeignKeys
+        !isTableForeignKeys &&
+        !isFkBooleanField
       ) {
         continue;
       }
@@ -129,6 +187,10 @@ function sortObjectKeys(obj: unknown): unknown {
     return obj;
   }
 
+  if (obj instanceof Date) {
+    return obj;
+  }
+
   if (Array.isArray(obj)) {
     return obj.map((item) => sortObjectKeys(item));
   }
@@ -219,29 +281,26 @@ function orderTopLevel(obj: Record<string, unknown>): Record<string, unknown> {
   return ordered;
 }
 
-export function canonicalizeContract(
-  ir: ContractIR & { coreHash?: string; profileHash?: string },
-): string {
+export function canonicalizeContract(ir: CanonicalContractInput): string {
   const normalized: NormalizedContract = {
     schemaVersion: ir.schemaVersion,
     targetFamily: ir.targetFamily,
     target: ir.target,
+    ...ifDefined('roots', ir.roots),
     models: ir.models,
-    relations: ir.relations,
+    ...ifDefined('relations', ir.relations),
     storage: ir.storage,
+    ...ifDefined('execution', ir.execution),
     extensionPacks: ir.extensionPacks,
     capabilities: ir.capabilities,
     meta: ir.meta,
-    sources: ir.sources,
   };
-
-  if (ir.coreHash !== undefined) {
-    normalized.coreHash = ir.coreHash;
-  }
-
-  if (ir.profileHash !== undefined) {
-    normalized.profileHash = ir.profileHash;
-  }
+  Object.assign(
+    normalized,
+    ifDefined('storageHash', ir.storageHash),
+    ifDefined('executionHash', ir.executionHash),
+    ifDefined('profileHash', ir.profileHash),
+  );
 
   const withDefaultsOmitted = omitDefaults(normalized, []) as NormalizedContract;
   const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted.storage);
@@ -249,5 +308,5 @@ export function canonicalizeContract(
   const withSortedKeys = sortObjectKeys(withSortedStorage) as Record<string, unknown>;
   const withOrderedTopLevel = orderTopLevel(withSortedKeys);
 
-  return JSON.stringify(withOrderedTopLevel, null, 2);
+  return JSON.stringify(withOrderedTopLevel, bigintJsonReplacer, 2);
 }

package/src/emission/emit.ts

@@ -1,10 +1,117 @@
 import type { ContractIR } from '@prisma-next/contract/ir';
 import type { TargetFamilyHook, ValidationContext } from '@prisma-next/contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { type } from 'arktype';
 import { format } from 'prettier';
 import { canonicalizeContract } from './canonicalization';
-import { computeCoreHash, computeProfileHash } from './hashing';
+import { computeExecutionHash, computeProfileHash, computeStorageHash } from './hashing';
 import type { EmitOptions, EmitResult } from './types';
 
+function stripStrategyFromRelations(
+  relations: Record<string, Record<string, unknown>> | undefined,
+): Record<string, Record<string, unknown>> | undefined {
+  if (!relations) return undefined;
+  const result: Record<string, Record<string, unknown>> = {};
+  for (const [relName, rel] of Object.entries(relations)) {
+    const { strategy: _, ...rest } = rel;
+    result[relName] = rest;
+  }
+  return result;
+}
+
+function toDomainModel(models: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [modelName, modelUnknown] of Object.entries(models)) {
+    const model = modelUnknown as Record<string, unknown>;
+    const relations = model['relations'] as Record<string, Record<string, unknown>> | undefined;
+    const cleanedRelations = stripStrategyFromRelations(relations);
+
+    const fields = model['fields'] as Record<string, Record<string, unknown>> | undefined;
+    if (!fields) {
+      result[modelName] = {
+        ...model,
+        ...(cleanedRelations !== undefined ? { relations: cleanedRelations } : {}),
+      };
+      continue;
+    }
+
+    const hasEnrichedFields = Object.values(fields).some((f) => f['codecId'] !== undefined);
+    if (!hasEnrichedFields) {
+      result[modelName] = {
+        ...model,
+        ...(cleanedRelations !== undefined ? { relations: cleanedRelations } : {}),
+      };
+      continue;
+    }
+
+    const storage = (model['storage'] ?? {}) as Record<string, unknown>;
+    const existingStorageFields = (storage['fields'] ?? {}) as Record<
+      string,
+      Record<string, unknown>
+    >;
+    const mergedStorageFields: Record<string, Record<string, unknown>> = {
+      ...existingStorageFields,
+    };
+
+    const cleanedFields: Record<string, Record<string, unknown>> = {};
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const { column, ...domainOnly } = field;
+      if (domainOnly['nullable'] === undefined) {
+        domainOnly['nullable'] = false;
+      }
+      cleanedFields[fieldName] = domainOnly;
+
+      if (column !== undefined && !mergedStorageFields[fieldName]) {
+        mergedStorageFields[fieldName] = { column };
+      }
+    }
+
+    result[modelName] = {
+      ...model,
+      fields: cleanedFields,
+      ...(cleanedRelations !== undefined ? { relations: cleanedRelations } : {}),
+      storage: { ...storage, fields: mergedStorageFields },
+    };
+  }
+  return result;
+}
+
+const CanonicalMetaSchema = type({
+  '[string]': 'unknown',
+});
+
+const CanonicalContractSchema = type({
+  '+': 'reject',
+  schemaVersion: 'string',
+  targetFamily: 'string',
+  target: 'string',
+  models: type({ '[string]': 'unknown' }),
+  'relations?': type({ '[string]': 'unknown' }),
+  'roots?': 'Record<string, string>',
+  storage: type({ '[string]': 'unknown' }),
+  'execution?': type({ '[string]': 'unknown' }),
+  extensionPacks: type({ '[string]': 'unknown' }),
+  capabilities: type({
+    '[string]': type({
+      '[string]': 'boolean',
+    }),
+  }),
+  meta: CanonicalMetaSchema,
+});
+
+function assertCanonicalArtifactShape(value: unknown): void {
+  const result = CanonicalContractSchema(value);
+  if (result instanceof type.errors) {
+    const issues = result
+      .map((error) => {
+        const path = error.path?.toString() ?? '<root>';
+        return `${path}: ${error.message}`;
+      })
+      .join('; ');
+    throw new Error(`ContractIR canonical artifact validation failed: ${issues}`);
+  }
+}
+
 function validateCoreStructure(ir: ContractIR): void {
   if (!ir.targetFamily) {
     throw new Error('ContractIR must have targetFamily');
@@ -21,8 +128,8 @@ function validateCoreStructure(ir: ContractIR): void {
   if (!ir.storage || typeof ir.storage !== 'object') {
     throw new Error('ContractIR must have storage');
   }
-  if (!ir.relations || typeof ir.relations !== 'object') {
-    throw new Error('ContractIR must have relations');
+  if (ir.relations !== undefined && typeof ir.relations !== 'object') {
+    throw new Error('ContractIR relations must be an object when provided');
   }
   if (!ir.extensionPacks || typeof ir.extensionPacks !== 'object') {
     throw new Error('ContractIR must have extensionPacks');
@@ -33,9 +140,6 @@ function validateCoreStructure(ir: ContractIR): void {
   if (!ir.meta || typeof ir.meta !== 'object') {
     throw new Error('ContractIR must have meta');
   }
-  if (!ir.sources || typeof ir.sources !== 'object') {
-    throw new Error('ContractIR must have sources');
-  }
 }
 
 export async function emit(
@@ -43,40 +147,53 @@ export async function emit(
   options: EmitOptions,
   targetFamily: TargetFamilyHook,
 ): Promise<EmitResult> {
-  const { operationRegistry, codecTypeImports, operationTypeImports, extensionIds } = options;
+  const {
+    operationRegistry,
+    codecTypeImports,
+    operationTypeImports,
+    extensionIds,
+    parameterizedRenderers,
+    parameterizedTypeImports,
+    queryOperationTypeImports,
+  } = options;
 
   validateCoreStructure(ir);
 
   const ctx: ValidationContext = {
-    ...(operationRegistry ? { operationRegistry } : {}),
-    ...(codecTypeImports ? { codecTypeImports } : {}),
-    ...(operationTypeImports ? { operationTypeImports } : {}),
-    ...(extensionIds ? { extensionIds } : {}),
+    ...ifDefined('operationRegistry', operationRegistry),
+    ...ifDefined('codecTypeImports', codecTypeImports),
+    ...ifDefined('operationTypeImports', operationTypeImports),
+    ...ifDefined('extensionIds', extensionIds),
   };
   targetFamily.validateTypes(ir, ctx);
 
   targetFamily.validateStructure(ir);
 
-  const contractJson = {
+  const canonicalContract = {
     schemaVersion: ir.schemaVersion,
     targetFamily: ir.targetFamily,
     target: ir.target,
-    models: ir.models,
-    relations: ir.relations,
+    ...ifDefined('roots', ir.roots),
+    models: toDomainModel(ir.models as Record<string, unknown>),
+    ...ifDefined('relations', ir.relations),
     storage: ir.storage,
+    ...ifDefined('execution', ir.execution),
     extensionPacks: ir.extensionPacks,
     capabilities: ir.capabilities,
     meta: ir.meta,
-    sources: ir.sources,
-  } as const;
+  };
+  assertCanonicalArtifactShape(canonicalContract);
 
-  const coreHash = computeCoreHash(contractJson);
-  const profileHash = computeProfileHash(contractJson);
+  const storageHash = computeStorageHash(canonicalContract);
+  const executionHash = canonicalContract.execution
+    ? computeExecutionHash(canonicalContract)
+    : undefined;
+  const profileHash = computeProfileHash(canonicalContract);
 
-  const contractWithHashes: ContractIR & { coreHash?: string; profileHash?: string } = {
-    ...ir,
-    schemaVersion: contractJson.schemaVersion,
-    coreHash,
+  const contractWithHashes = {
+    ...canonicalContract,
+    storageHash,
+    ...ifDefined('executionHash', executionHash),
     profileHash,
   };
 
@@ -91,16 +208,32 @@ export async function emit(
     ...contractJsonObj,
     _generated: {
       warning: '⚠️  GENERATED FILE - DO NOT EDIT',
-      message: 'This file is automatically generated by "prisma-next emit".',
-      regenerate: 'To regenerate, run: prisma-next emit',
+      message: 'This file is automatically generated by "prisma-next contract emit".',
+      regenerate: 'To regenerate, run: prisma-next contract emit',
     },
   };
   const contractJsonString = JSON.stringify(contractJsonWithMeta, null, 2);
 
+  const generateOptions =
+    parameterizedRenderers || parameterizedTypeImports || queryOperationTypeImports
+      ? {
+          ...ifDefined('parameterizedRenderers', parameterizedRenderers),
+          ...ifDefined('parameterizedTypeImports', parameterizedTypeImports),
+          ...ifDefined('queryOperationTypeImports', queryOperationTypeImports),
+        }
+      : undefined;
+
+  const contractTypeHashes = {
+    storageHash,
+    ...ifDefined('executionHash', executionHash),
+    profileHash,
+  };
   const contractDtsRaw = targetFamily.generateContractTypes(
     ir,
     codecTypeImports ?? [],
     operationTypeImports ?? [],
+    contractTypeHashes,
+    generateOptions,
   );
   const contractDts = await format(contractDtsRaw, {
     parser: 'typescript',
@@ -112,7 +245,8 @@ export async function emit(
   return {
     contractJson: contractJsonString,
     contractDts,
-    coreHash,
+    storageHash,
+    ...ifDefined('executionHash', executionHash),
     profileHash,
   };
 }

package/src/emission/hashing.ts

@@ -1,46 +1,32 @@
 import { createHash } from 'node:crypto';
-import type { ContractIR } from '@prisma-next/contract/ir';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { CanonicalContractInput } from './canonicalization';
 import { canonicalizeContract } from './canonicalization';
 
-type ContractInput = {
-  schemaVersion: string;
-  targetFamily: string;
-  target: string;
-  models: Record<string, unknown>;
-  relations: Record<string, unknown>;
-  storage: Record<string, unknown>;
-  extensionPacks: Record<string, unknown>;
-  sources: Record<string, unknown>;
-  capabilities: Record<string, Record<string, boolean>>;
-  meta: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
 function computeHash(content: string): string {
   const hash = createHash('sha256');
   hash.update(content);
   return `sha256:${hash.digest('hex')}`;
 }
 
-export function computeCoreHash(contract: ContractInput): string {
-  const coreContract: ContractIR = {
+export function computeStorageHash(contract: CanonicalContractInput): string {
+  const storageContract = {
     schemaVersion: contract.schemaVersion,
     targetFamily: contract.targetFamily,
     target: contract.target,
-    models: contract.models,
-    relations: contract.relations,
     storage: contract.storage,
-    extensionPacks: contract.extensionPacks,
-    sources: contract.sources,
-    capabilities: contract.capabilities,
-    meta: contract.meta,
+    models: {},
+    relations: {},
+    extensionPacks: {},
+    capabilities: {},
+    meta: {},
   };
-  const canonical = canonicalizeContract(coreContract);
+  const canonical = canonicalizeContract(storageContract);
   return computeHash(canonical);
 }
 
-export function computeProfileHash(contract: ContractInput): string {
-  const profileContract: ContractIR = {
+export function computeProfileHash(contract: CanonicalContractInput): string {
+  const profileContract = {
     schemaVersion: contract.schemaVersion,
     targetFamily: contract.targetFamily,
     target: contract.target,
@@ -50,8 +36,24 @@ export function computeProfileHash(contract: ContractInput): string {
     extensionPacks: {},
     capabilities: contract.capabilities,
     meta: {},
-    sources: {},
   };
   const canonical = canonicalizeContract(profileContract);
   return computeHash(canonical);
 }
+
+export function computeExecutionHash(contract: CanonicalContractInput): string {
+  const executionContract = {
+    schemaVersion: contract.schemaVersion,
+    targetFamily: contract.targetFamily,
+    target: contract.target,
+    models: {},
+    relations: {},
+    storage: {},
+    extensionPacks: {},
+    capabilities: {},
+    meta: {},
+    ...ifDefined('execution', contract.execution),
+  };
+  const canonical = canonicalizeContract(executionContract);
+  return computeHash(canonical);
+}

package/src/emission/types.ts

@@ -1,4 +1,4 @@
-import type { TypesImportSpec } from '@prisma-next/contract/types';
+import type { TypeRenderEntry, TypesImportSpec } from '@prisma-next/contract/types';
 import type { OperationRegistry } from '@prisma-next/operations';
 
 export interface EmitOptions {
@@ -7,11 +7,27 @@ export interface EmitOptions {
   readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
   readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
   readonly extensionIds?: ReadonlyArray<string>;
+  /**
+   * Normalized parameterized type renderers, keyed by codecId.
+   * These are extracted from descriptors and normalized during assembly.
+   */
+  readonly parameterizedRenderers?: Map<string, TypeRenderEntry>;
+  /**
+   * Type imports for parameterized codecs.
+   * These are added to contract.d.ts alongside codec and operation type imports.
+   */
+  readonly parameterizedTypeImports?: ReadonlyArray<TypesImportSpec>;
+  /**
+   * Query operation type imports for the query builder.
+   * Flat operation signatures keyed by operation name.
+   */
+  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
 }
 
 export interface EmitResult {
   readonly contractJson: string;
   readonly contractDts: string;
-  readonly coreHash: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
   readonly profileHash: string;
 }