@prisma-next/contract 0.11.0-dev.6 → 0.11.0-dev.61

package/src/canonicalization.ts

@@ -14,6 +14,25 @@ import type { Contract } from './contract-types';
  */
 export type SerializeContract = (contract: Contract) => JsonObject;
 
+/**
+ * Family-contributed predicate for the default-omission walk. Called when
+ * a value at `path` is a default (empty object/array or `false`); if this
+ * returns `true` the value is kept rather than stripped.
+ *
+ * The framework only calls the predicate inside the `isDefaultValue` branch,
+ * so there is no need to guard against non-default values.
+ */
+export type PreserveEmptyPredicate = (path: readonly string[]) => boolean;
+
+/**
+ * Family-contributed storage sort. Applied to the serialized `storage`
+ * subtree after the default-omission walk; the result replaces the
+ * `storage` field before the final key sort. Use to establish a
+ * deterministic order for storage arrays (indexes, uniques) that the
+ * family-agnostic `sortObjectKeys` pass cannot handle.
+ */
+export type StorageSort = (storage: unknown) => unknown;
+
 const TOP_LEVEL_ORDER = [
   'schemaVersion',
   'canonicalVersion',
@@ -42,13 +61,17 @@ function isDefaultValue(value: unknown): boolean {
   return false;
 }
 
-function omitDefaults(obj: unknown, path: readonly string[]): unknown {
+function omitDefaults(
+  obj: unknown,
+  path: readonly string[],
+  shouldPreserveEmpty: PreserveEmptyPredicate | undefined,
+): unknown {
   if (obj === null || typeof obj !== 'object') {
     return obj;
   }
 
   if (Array.isArray(obj)) {
-    return obj.map((item) => omitDefaults(item, path));
+    return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
   }
 
   const result: Record<string, unknown> = {};
@@ -74,20 +97,6 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       const isNamespaceSlot =
         currentPath.length === 3 &&
         isArrayEqual([currentPath[0], currentPath[1]], ['storage', 'namespaces']);
-      const isRequiredNamespaceTables =
-        currentPath.length === 4 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables';
-      // Preserve per-table payloads even when empty. SQL tables are never
-      // emitted empty; Mongo collections legitimately are (a declared
-      // collection with no schema is a valid representation), and the
-      // family-agnostic canonicalizer must not strip them.
-      const isNamespaceTableEntry =
-        currentPath.length === 5 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables';
       const isRequiredRoots = isArrayEqual(currentPath, ['roots']);
       const isRequiredExtensionPacks = isArrayEqual(currentPath, ['extensionPacks']);
       const isRequiredCapabilities = isArrayEqual(currentPath, ['capabilities']);
@@ -104,50 +113,21 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
       const isModelStorage =
         currentPath.length === 3 &&
         isArrayEqual([currentPath[0], currentPath[2]], ['models', 'storage']);
-      const isNamespaceTableUniques =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'uniques';
-      const isNamespaceTableIndexes =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'indexes';
-      const isNamespaceTableForeignKeys =
-        currentPath.length === 6 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'foreignKeys';
 
-      // `storage.types.<name>.typeParams` is part of the StorageTypeInstance
-      // shape (validators require it). Preserve it even when empty so the
-      // emitted contract.json remains structurally valid after a round-trip.
-      const isStorageTypeTypeParams =
-        currentPath.length === 4 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'types' &&
+      const isDomainUnboundTypeParams =
+        currentPath.length === 5 &&
+        currentPath[0] === 'domain' &&
+        currentPath[2] === 'types' &&
         key === 'typeParams';
 
-      const isFkBooleanField =
-        currentPath.length === 7 &&
-        currentPath[0] === 'storage' &&
-        currentPath[1] === 'namespaces' &&
-        currentPath[3] === 'tables' &&
-        currentPath[5] === 'foreignKeys' &&
-        (key === 'constraint' || key === 'index');
-
       const isNullableField = key === 'nullable';
 
+      const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
+
       if (
         !isRequiredModels &&
         !isRequiredNamespaces &&
         !isNamespaceSlot &&
-        !isRequiredNamespaceTables &&
-        !isNamespaceTableEntry &&
         !isRequiredRoots &&
         !isRequiredExtensionPacks &&
         !isRequiredCapabilities &&
@@ -156,18 +136,15 @@ function omitDefaults(obj: unknown, path: readonly string[]): unknown {
         !isExtensionNamespace &&
         !isModelRelations &&
         !isModelStorage &&
-        !isNamespaceTableUniques &&
-        !isNamespaceTableIndexes &&
-        !isNamespaceTableForeignKeys &&
-        !isFkBooleanField &&
         !isNullableField &&
-        !isStorageTypeTypeParams
+        !isDomainUnboundTypeParams &&
+        !isFamilyPreserved
       ) {
         continue;
       }
     }
 
-    result[key] = omitDefaults(value, currentPath);
+    result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
   }
 
   return result;
@@ -191,88 +168,6 @@ function sortObjectKeys(obj: unknown): unknown {
   return sorted;
 }
 
-type NamespaceObject = {
-  tables?: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
-type StorageObject = {
-  namespaces?: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
-type TableObject = {
-  indexes?: unknown[];
-  uniques?: unknown[];
-  [key: string]: unknown;
-};
-
-function sortTableArrays(tableObj: TableObject): TableObject {
-  const sortedTable: TableObject = { ...tableObj };
-
-  if (Array.isArray(tableObj.indexes)) {
-    sortedTable.indexes = [...tableObj.indexes].sort((a, b) => {
-      const nameA = (a as { name?: string })?.name || '';
-      const nameB = (b as { name?: string })?.name || '';
-      return nameA.localeCompare(nameB);
-    });
-  }
-
-  if (Array.isArray(tableObj.uniques)) {
-    sortedTable.uniques = [...tableObj.uniques].sort((a, b) => {
-      const nameA = (a as { name?: string })?.name || '';
-      const nameB = (b as { name?: string })?.name || '';
-      return nameA.localeCompare(nameB);
-    });
-  }
-
-  return sortedTable;
-}
-
-function sortIndexesAndUniques(storage: unknown): unknown {
-  if (!storage || typeof storage !== 'object') {
-    return storage;
-  }
-
-  const storageObj = storage as StorageObject;
-  if (!storageObj.namespaces || typeof storageObj.namespaces !== 'object') {
-    return storage;
-  }
-
-  const namespaces = storageObj.namespaces;
-  const result: StorageObject = { ...storageObj, namespaces: {} };
-  const resultNamespaces = result.namespaces as Record<string, unknown>;
-
-  for (const nsId of Object.keys(namespaces)) {
-    const ns = namespaces[nsId];
-    if (!ns || typeof ns !== 'object') {
-      resultNamespaces[nsId] = ns;
-      continue;
-    }
-
-    const nsObj = ns as NamespaceObject;
-    if (!nsObj.tables || typeof nsObj.tables !== 'object') {
-      resultNamespaces[nsId] = ns;
-      continue;
-    }
-
-    const sortedTables: Record<string, unknown> = {};
-    const sortedTableNames = Object.keys(nsObj.tables).sort();
-    for (const tableName of sortedTableNames) {
-      const table = nsObj.tables[tableName];
-      if (!table || typeof table !== 'object') {
-        sortedTables[tableName] = table;
-        continue;
-      }
-      sortedTables[tableName] = sortTableArrays(table as TableObject);
-    }
-
-    resultNamespaces[nsId] = { ...nsObj, tables: sortedTables };
-  }
-
-  return result;
-}
-
 export function orderTopLevel(obj: Record<string, unknown>): Record<string, unknown> {
   const ordered: Record<string, unknown> = {};
   const remaining = new Set(Object.keys(obj));
@@ -304,6 +199,21 @@ export interface CanonicalizeContractOptions {
    * the per-target serializer not putting them in the JSON shape.
    */
   readonly serializeContract: SerializeContract;
+  /**
+   * Family-contributed preserve-empty predicate. When the walk encounters a
+   * default value (empty object/array or `false`) at `path`, calling this
+   * with the full path allows the family to veto the omission. If absent,
+   * only the framework's family-agnostic required-slot rules apply.
+   */
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  /**
+   * Family-contributed storage sort. Applied to the serialized `storage`
+   * subtree after the default-omission walk, before the final key sort.
+   * SQL family uses this to impose a deterministic order on `indexes` and
+   * `uniques` arrays within each namespace table. Families that require no
+   * special storage ordering omit this hook.
+   */
+  readonly sortStorage?: StorageSort;
 }
 
 /**
@@ -324,15 +234,20 @@ export function canonicalizeContractToObject(
     roots: serialized['roots'],
     models: serialized['models'],
     ...ifDefined('valueObjects', serialized['valueObjects']),
+    ...ifDefined('domain', serialized['domain']),
     storage: serialized['storage'],
     ...ifDefined('execution', serialized['execution']),
     extensionPacks: serialized['extensionPacks'],
     capabilities: serialized['capabilities'],
     meta: serialized['meta'],
   };
-  const withDefaultsOmitted = omitDefaults(normalized, []) as Record<string, unknown>;
-  const withSortedIndexes = sortIndexesAndUniques(withDefaultsOmitted['storage']);
-  const withSortedStorage = { ...withDefaultsOmitted, storage: withSortedIndexes };
+  const withDefaultsOmitted = omitDefaults(normalized, [], options.shouldPreserveEmpty) as Record<
+    string,
+    unknown
+  >;
+  const withSortedStorage = options.sortStorage
+    ? { ...withDefaultsOmitted, storage: options.sortStorage(withDefaultsOmitted['storage']) }
+    : withDefaultsOmitted;
   const withSortedKeys = sortObjectKeys(withSortedStorage) as Record<string, unknown>;
   return orderTopLevel(withSortedKeys);
 }

package/src/contract-types.ts

@@ -1,3 +1,4 @@
+import type { CrossReference } from './cross-reference';
 import type { ContractModelBase, ContractValueObject } from './domain-types';
 import type {
   ExecutionHashBase,
@@ -43,7 +44,7 @@ export interface Contract<
 > {
   readonly target: string;
   readonly targetFamily: string;
-  readonly roots: Record<string, string>;
+  readonly roots: Record<string, CrossReference>;
   readonly models: TModels;
   readonly valueObjects?: Record<string, ContractValueObject>;
   /**

package/src/cross-reference.ts

@@ -0,0 +1,28 @@
+import { blindCast } from '@prisma-next/utils/casts';
+import { type Type, type } from 'arktype';
+import { asNamespaceId, type NamespaceId } from './namespace-id';
+
+export interface CrossReference {
+  readonly namespace: NamespaceId;
+  readonly model: string;
+}
+
+export const CrossReferenceSchema = blindCast<
+  Type<CrossReference>,
+  'namespace is validated as string at runtime and branded to NamespaceId by asNamespaceId in crossRef(); the schema accepts plain strings but the public type reflects the branded shape'
+>(
+  type({
+    '+': 'reject',
+    namespace: 'string',
+    model: 'string',
+  }),
+);
+
+const DEFAULT_CROSS_REF_NAMESPACE = '__unbound__';
+
+export function crossRef(
+  model: string,
+  namespace: string = DEFAULT_CROSS_REF_NAMESPACE,
+): CrossReference {
+  return { namespace: asNamespaceId(namespace), model };
+}

package/src/domain-types.ts

@@ -1,3 +1,5 @@
+import type { CrossReference } from './cross-reference';
+
 export type ScalarFieldType = {
   readonly kind: 'scalar';
   readonly codecId: string;
@@ -29,13 +31,13 @@ export type ContractRelationOn = {
 };
 
 export type ContractReferenceRelation = {
-  readonly to: string;
+  readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N' | 'N:1';
   readonly on: ContractRelationOn;
 };
 
 export type ContractEmbedRelation = {
-  readonly to: string;
+  readonly to: CrossReference;
   readonly cardinality: '1:1' | '1:N';
 };
 
@@ -61,7 +63,7 @@ export interface ContractModelBase<TModelStorage extends ModelStorageBase = Mode
   readonly storage: TModelStorage;
   readonly discriminator?: ContractDiscriminator;
   readonly variants?: Record<string, ContractVariantEntry>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
 

package/src/exports/hashing-utils.ts

@@ -0,0 +1,12 @@
+export {
+  createPreserveEmptyPredicate,
+  matchesPathPattern,
+  type PathPattern,
+  type PathSegment as PreserveEmptyPathSegment,
+} from '../canonicalization-path-match';
+export {
+  compareByNameProperty,
+  createStorageSort,
+  type NamedArraySortTarget,
+  type PathSegment as StorageSortPathSegment,
+} from '../canonicalization-storage-sort';

package/src/exports/hashing.ts

@@ -2,6 +2,8 @@ export {
   type CanonicalizeContractOptions,
   canonicalizeContract,
   canonicalizeContractToObject,
+  type PreserveEmptyPredicate,
   type SerializeContract,
+  type StorageSort,
 } from '../canonicalization';
 export { computeExecutionHash, computeProfileHash, computeStorageHash } from '../hashing';

package/src/exports/types.ts

@@ -1,4 +1,6 @@
 export type { Contract, ContractExecutionSection } from '../contract-types';
+export type { CrossReference } from '../cross-reference';
+export { CrossReferenceSchema, crossRef } from '../cross-reference';
 export type {
   ContractDiscriminator,
   ContractEmbedRelation,
@@ -18,6 +20,8 @@ export type {
   UnionFieldType,
   ValueObjectFieldType,
 } from '../domain-types';
+export type { NamespaceId } from '../namespace-id';
+export { asNamespaceId } from '../namespace-id';
 export type {
   $,
   Brand,
@@ -41,7 +45,9 @@ export type {
   ProfileHashBase,
   Source,
   StorageBase,
+  StorageEntitySlot,
   StorageHashBase,
+  StorageNamespace,
 } from '../types';
 export {
   coreHash,

package/src/hashing.ts

@@ -1,6 +1,11 @@
 import { createHash } from 'node:crypto';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { JsonObject } from '@prisma-next/utils/json';
-import { canonicalizeContract } from './canonicalization';
+import {
+  canonicalizeContract,
+  type PreserveEmptyPredicate,
+  type StorageSort,
+} from './canonicalization';
 import type { Contract } from './contract-types';
 import type { ExecutionHashBase, ProfileHashBase, StorageHashBase } from './types';
 
@@ -12,7 +17,13 @@ function sha256(content: string): string {
   return `sha256:${hash.digest('hex')}`;
 }
 
-function hashContract(section: Record<string, unknown>): string {
+type HashContractSection = Record<string, unknown> & {
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  readonly sortStorage?: StorageSort;
+};
+
+function hashContract(section: HashContractSection): string {
+  const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
   // Blind cast: the synthesised object is a hash-only stand-in
   // — never returned to callers, never executed as a Contract.
   // `canonicalizeContract` only walks the storage / execution /
@@ -20,29 +31,35 @@ function hashContract(section: Record<string, unknown>): string {
   // missing precise Contract typing on the other slots is
   // immaterial for the hash result.
   const contract = {
-    targetFamily: section['targetFamily'],
-    target: section['target'],
+    targetFamily: sectionData['targetFamily'],
+    target: sectionData['target'],
     roots: {},
     models: {},
-    storage: section['storage'] ?? {},
-    execution: section['execution'],
+    storage: sectionData['storage'] ?? {},
+    execution: sectionData['execution'],
     extensionPacks: {},
-    capabilities: section['capabilities'] ?? {},
+    capabilities: sectionData['capabilities'] ?? {},
     meta: {},
     profileHash: '',
-    ...section,
+    ...sectionData,
   } as unknown as Contract;
   return canonicalizeContract(contract, {
     schemaVersion: SCHEMA_VERSION,
     serializeContract: (c) => JSON.parse(JSON.stringify(c)) as JsonObject,
+    ...ifDefined('shouldPreserveEmpty', shouldPreserveEmpty),
+    ...ifDefined('sortStorage', sortStorage),
   });
 }
 
-export function computeStorageHash(args: {
+export type ComputeStorageHashArgs = {
   target: string;
   targetFamily: string;
   storage: Record<string, unknown>;
-}): StorageHashBase<string> {
+  readonly shouldPreserveEmpty?: PreserveEmptyPredicate;
+  readonly sortStorage?: StorageSort;
+};
+
+export function computeStorageHash(args: ComputeStorageHashArgs): StorageHashBase<string> {
   return sha256(hashContract(args)) as StorageHashBase<string>;
 }
 

package/src/namespace-id.ts

@@ -0,0 +1,10 @@
+import { blindCast } from '@prisma-next/utils/casts';
+
+export type NamespaceId = string & { readonly __brand: 'NamespaceId' };
+
+export function asNamespaceId(value: string): NamespaceId {
+  return blindCast<
+    NamespaceId,
+    'NamespaceId is a compile-time-only brand on string; this factory is the sole assertion site'
+  >(value);
+}

package/src/testing-factories.ts

@@ -1,5 +1,7 @@
 import { ifDefined } from '@prisma-next/utils/defined';
+import type { PreserveEmptyPredicate, StorageSort } from './canonicalization';
 import type { Contract } from './contract-types';
+import type { CrossReference } from './cross-reference';
 import type {
   ContractModel,
   ContractModelBase,
@@ -16,7 +18,7 @@ type ContractOverrides<
 > = {
   target?: string;
   targetFamily?: string;
-  roots?: Record<string, string>;
+  roots?: Record<string, CrossReference>;
   models?: TModels;
   storage?: Omit<TStorage, 'storageHash'>;
   valueObjects?: Record<string, ContractValueObject>;
@@ -25,6 +27,8 @@ type ContractOverrides<
   execution?: Omit<ExecutionSection, 'executionHash'>;
   profileHash?: ProfileHashBase<string>;
   meta?: Record<string, unknown>;
+  shouldPreserveEmpty?: PreserveEmptyPredicate;
+  sortStorage?: StorageSort;
 };
 
 const DUMMY_HASH = coreHash('sha256:test');
@@ -56,6 +60,8 @@ export function createContract<
     target,
     targetFamily,
     storage: rawStorage as Record<string, unknown>,
+    ...ifDefined('shouldPreserveEmpty', overrides.shouldPreserveEmpty),
+    ...ifDefined('sortStorage', overrides.sortStorage),
   });
 
   const storage = {

package/src/types.ts

@@ -48,13 +48,34 @@ export function profileHash<const T extends string>(value: T): ProfileHashBase<T
   return value as ProfileHashBase<T>;
 }
 
+/**
+ * One entity-kind slot in a namespace — a map of entity name to entry.
+ * Values are opaque at the foundation layer; family and target concretions
+ * refine them to typed IR classes.
+ */
+export type StorageEntitySlot = Readonly<Record<string, unknown>>;
+
+/**
+ * Plain-data namespace entry in a storage block. Every hydrated contract
+ * carries at least `id` plus zero or more entity-kind slot maps (`tables`,
+ * `collections`, …). Foundation declares only this shape — no IR machinery.
+ */
+export interface StorageNamespace {
+  readonly id: string;
+}
+
 /**
  * Base type for family-specific storage blocks.
  * Family storage types (SqlStorage, MongoStorage, etc.) extend this to carry the
  * storage hash alongside family-specific data (tables, collections, etc.).
+ *
+ * The `namespaces` map is carried by every hydrated storage block. Serialized
+ * envelope shape is target-owned; this types the in-memory contract after
+ * `deserializeContract`.
  */
 export interface StorageBase<THash extends string = string> {
   readonly storageHash: StorageHashBase<THash>;
+  readonly namespaces: Readonly<Record<string, StorageNamespace>>;
 }
 
 export interface FieldType {

package/src/validate-domain.ts

@@ -1,16 +1,17 @@
 import { ContractValidationError } from './contract-validation-error';
+import type { CrossReference } from './cross-reference';
 
 export interface DomainModelShape {
   readonly fields: Record<string, unknown>;
-  readonly relations?: Record<string, { readonly to: string }>;
+  readonly relations?: Record<string, { readonly to: CrossReference }>;
   readonly discriminator?: { readonly field: string };
   readonly variants?: Record<string, unknown>;
-  readonly base?: string;
+  readonly base?: CrossReference;
   readonly owner?: string;
 }
 
 export interface DomainContractShape {
-  readonly roots: Record<string, string>;
+  readonly roots: Record<string, CrossReference>;
   readonly models: Record<string, DomainModelShape>;
   readonly valueObjects?: Record<string, { readonly fields: Record<string, unknown> }>;
 }
@@ -41,11 +42,13 @@ function validateRoots(
   errors: string[],
 ): void {
   const seenValues = new Set<string>();
-  for (const [rootKey, modelName] of Object.entries(contract.roots)) {
-    if (seenValues.has(modelName)) {
+  for (const [rootKey, crossRef] of Object.entries(contract.roots)) {
+    const modelName = crossRef.model;
+    const dedupeKey = `${crossRef.namespace}:${modelName}`;
+    if (seenValues.has(dedupeKey)) {
       errors.push(`Duplicate root value: "${modelName}" is mapped by multiple root keys`);
     }
-    seenValues.add(modelName);
+    seenValues.add(dedupeKey);
 
     if (!modelNames.has(modelName)) {
       errors.push(
@@ -73,24 +76,27 @@ function validateVariantsAndBases(
         }
         const variantModel = models.get(variantName);
         if (!variantModel) continue;
-        if (variantModel.base !== modelName) {
+        if (variantModel.base?.model !== modelName) {
           errors.push(
-            `Variant "${variantName}" has base "${variantModel.base ?? '(none)'}" but expected "${modelName}"`,
+            `Variant "${variantName}" has base "${variantModel.base?.model ?? '(none)'}" but expected "${modelName}"`,
           );
         }
       }
     }
 
     if (model.base) {
-      if (!modelNames.has(model.base)) {
-        errors.push(`Model "${modelName}" has base "${model.base}" which does not exist in models`);
+      const baseModelName = model.base.model;
+      if (!modelNames.has(baseModelName)) {
+        errors.push(
+          `Model "${modelName}" has base "${baseModelName}" which does not exist in models`,
+        );
         continue;
       }
-      const baseModel = models.get(model.base);
+      const baseModel = models.get(baseModelName);
       if (!baseModel) continue;
       if (!baseModel.variants || !Object.hasOwn(baseModel.variants, modelName)) {
         errors.push(
-          `Model "${modelName}" has base "${model.base}" which does not list it as a variant`,
+          `Model "${modelName}" has base "${baseModelName}" which does not list it as a variant`,
         );
       }
     }
@@ -104,9 +110,10 @@ function validateRelationTargets(
 ): void {
   for (const [modelName, model] of Object.entries(contract.models)) {
     for (const [relName, relation] of Object.entries(model.relations ?? {})) {
-      if (!modelNames.has(relation.to)) {
+      const targetModelName = relation.to.model;
+      if (!modelNames.has(targetModelName)) {
         errors.push(
-          `Relation "${relName}" on model "${modelName}" targets "${relation.to}" which does not exist in models`,
+          `Relation "${relName}" on model "${modelName}" targets "${targetModelName}" which does not exist in models`,
         );
       }
     }
@@ -157,8 +164,8 @@ function validateOwnership(
       errors.push(`Model "${modelName}" has owner "${model.owner}" which does not exist in models`);
     }
 
-    for (const [rootKey, rootModel] of Object.entries(contract.roots)) {
-      if (rootModel === modelName) {
+    for (const [rootKey, rootRef] of Object.entries(contract.roots)) {
+      if (rootRef.model === modelName) {
         errors.push(
           `Owned model "${modelName}" must not appear in roots (found as root "${rootKey}")`,
         );

package/dist/contract-types-Bt2uyqs3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract-types-Bt2uyqs3.d.mts","names":[],"sources":["../src/domain-types.ts","../src/types.ts","../src/contract-types.ts"],"mappings":"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"}