@prisma-next/sql-contract 0.13.0-dev.26 → 0.13.0-dev.28

package/src/ir/build-sql-namespace.ts

@@ -4,11 +4,12 @@ import {
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
-import type { SqlNamespace, SqlNamespaceTablesInput } from './sql-storage';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { SqlNamespace, SqlNamespaceEntries, SqlNamespaceTablesInput } from './sql-storage';
 import { SqlUnboundNamespace } from './sql-unbound-namespace';
-import { StorageTable } from './storage-table';
-import { StorageValueSet } from './storage-value-set';
+import { StorageTable, type StorageTableInput } from './storage-table';
+import { StorageValueSet, type StorageValueSetInput } from './storage-value-set';
 
 const SQL_NAMESPACE_KIND = 'sql-namespace' as const;
 
@@ -27,39 +28,63 @@ class SqlBoundNamespace extends NamespaceBase {
   declare readonly kind: string;
 
   readonly id: string;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
-  }>;
+  readonly entries: SqlNamespaceEntries;
 
   static fromTablesInput(input: SqlNamespaceTablesInput): SqlNamespace {
-    const tableCount = Object.keys(input.entries.table).length;
-    const hasValueSets =
-      input.entries.valueSet !== undefined && Object.keys(input.entries.valueSet).length > 0;
-    if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && !hasValueSets) {
-      return castAs<SqlNamespace>(SqlUnboundNamespace.instance);
+    const tableKind = input.entries['table'];
+    const tableCount = tableKind !== undefined ? Object.keys(tableKind).length : 0;
+    const valueSetKind = input.entries['valueSet'];
+    const hasValueSets = valueSetKind !== undefined && Object.keys(valueSetKind).length > 0;
+    const hasUnknownKinds = Object.keys(input.entries).some(
+      (kind) => kind !== 'table' && kind !== 'valueSet',
+    );
+    if (
+      input.id === UNBOUND_NAMESPACE_ID &&
+      tableCount === 0 &&
+      !hasValueSets &&
+      !hasUnknownKinds
+    ) {
+      return SqlUnboundNamespace.instance;
     }
-    return castAs<SqlNamespace>(new SqlBoundNamespace(input));
+    return new SqlBoundNamespace(input);
   }
 
   private constructor(input: SqlNamespaceTablesInput) {
     super();
     this.id = input.id;
-    const table = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.entries.table).map(([k, v]) => [k, new StorageTable(v)]),
-      ),
-    );
-    if (input.entries.valueSet !== undefined) {
-      const valueSet = Object.freeze(
-        Object.fromEntries(
-          Object.entries(input.entries.valueSet).map(([k, v]) => [k, new StorageValueSet(v)]),
-        ),
-      );
-      this.entries = Object.freeze({ table, valueSet });
-    } else {
-      this.entries = Object.freeze({ table });
+
+    const carried: Record<string, Readonly<Record<string, unknown>>> = {};
+    let table: Readonly<Record<string, StorageTable>> = Object.freeze({});
+    let valueSet: Readonly<Record<string, StorageValueSet>> | undefined;
+    for (const [kind, rawMap] of Object.entries(input.entries)) {
+      if (kind === 'table') {
+        const tableMap: Record<string, StorageTable> = {};
+        for (const [name, v] of Object.entries(
+          blindCast<
+            Record<string, StorageTableInput>,
+            'entries[table] holds StorageTableInput by construction'
+          >(rawMap),
+        )) {
+          tableMap[name] = new StorageTable(v);
+        }
+        table = Object.freeze(tableMap);
+      } else if (kind === 'valueSet') {
+        const vsMap: Record<string, StorageValueSet> = {};
+        for (const [name, v] of Object.entries(
+          blindCast<
+            Record<string, StorageValueSetInput>,
+            'entries[valueSet] holds StorageValueSetInput by construction'
+          >(rawMap),
+        )) {
+          vsMap[name] = new StorageValueSet(v);
+        }
+        valueSet = Object.freeze(vsMap);
+      } else {
+        carried[kind] = Object.freeze(rawMap);
+      }
     }
+
+    this.entries = Object.freeze({ ...carried, table, ...ifDefined('valueSet', valueSet) });
     Object.defineProperty(this, 'kind', {
       value: SQL_NAMESPACE_KIND,
       writable: false,
@@ -69,6 +94,14 @@ class SqlBoundNamespace extends NamespaceBase {
     freezeNode(this);
   }
 
+  get table(): Readonly<Record<string, StorageTable>> {
+    return this.entries.table ?? Object.freeze({});
+  }
+
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {
+    return this.entries.valueSet;
+  }
+
   qualifyTable(tableName: string): string {
     if (this.id === UNBOUND_NAMESPACE_ID) {
       return `"${tableName}"`;
@@ -88,10 +121,7 @@ export function buildSqlNamespaceMap(
     Object.entries(namespaces).map(([nsKey, ns]) => [
       nsKey,
       isMaterializedSqlNamespace(ns)
-        ? blindCast<
-            SqlNamespace,
-            'a materialised SQL-family namespace entry in a namespace map is a SqlNamespace'
-          >(ns)
+        ? ns
         : SqlBoundNamespace.fromTablesInput(
             blindCast<
               SqlNamespaceTablesInput,

package/src/ir/sql-storage.ts

@@ -1,14 +1,14 @@
 import type { StorageHashBase } from '@prisma-next/contract/types';
 import { freezeNode, type Namespace, type Storage } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
-import type { StorageTable, StorageTableInput } from './storage-table';
+import type { StorageTable } from './storage-table';
 import {
   isStorageTypeInstance,
   type StorageTypeInstance,
   type StorageTypeInstanceInput,
   toStorageTypeInstance,
 } from './storage-type-instance';
-import type { StorageValueSet, StorageValueSetInput } from './storage-value-set';
+import type { StorageValueSet } from './storage-value-set';
 
 /**
  * Polymorphic value type for document-scoped `SqlStorage.types` entries
@@ -21,10 +21,7 @@ export type SqlStorageTypeEntry = StorageTypeInstance | StorageTypeInstanceInput
 
 export interface SqlNamespaceTablesInput {
   readonly id: string;
-  readonly entries: {
-    readonly table: Record<string, StorageTable | StorageTableInput>;
-    readonly valueSet?: Record<string, StorageValueSet | StorageValueSetInput>;
-  };
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 
 export interface SqlStorageInput<THash extends string = string> {
@@ -54,17 +51,26 @@ export interface SqlStorageInput<THash extends string = string> {
  * the per-target serializer's responsibility (so the family base does
  * not import target-specific subclasses).
  */
-// SQL concretions store `StorageTable` values under `entries.table`.
-// Mongo namespaces carry `entries.collection` instead. The wider
-// `Record<string, object>` on `StorageTable` is only there so emitted
-// `contract.d.ts` table literals (which lack the runtime `kind`
-// discriminator on `StorageTable`) structurally satisfy the slot without
-// a class-instance check.
+/**
+ * The typed `entries` shape for SQL family namespaces. The open dictionary
+ * is intersected with optional known-kind maps so that `ns.entries.table`
+ * and `ns.entries.valueSet` resolve without a cast, while unknown pack-
+ * contributed kinds remain valid (the `Record` part allows any string key).
+ */
+export type SqlNamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+  readonly table?: Readonly<Record<string, StorageTable>>;
+  readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
+};
+
+/**
+ * SQL family namespace. `entries` is the open ADR 224 dictionary —
+ * `entries[entityKind][entityName]` addresses any entity. Emitted
+ * contract literals satisfy this structurally (no prototype getters
+ * needed). For typed access to specific kinds, use the class getters
+ * on the concretion or `ns.entries.table` / `ns.entries.valueSet` directly.
+ */
 export type SqlNamespace = Namespace & {
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
-  }>;
+  readonly entries: SqlNamespaceEntries;
   /**
    * Render a dialect-qualified table reference for runtime SQL emission.
    * Present on materialised target concretions (`PostgresSchema`,
@@ -94,14 +100,6 @@ export class SqlStorage<THash extends string = string> extends SqlNode implement
   }
 }
 
-export function storageTableAt(
-  storage: SqlStorage,
-  namespaceId: string,
-  tableName: string,
-): StorageTable | undefined {
-  return storage.namespaces[namespaceId]?.entries.table[tableName];
-}
-
 /**
  * Strict polymorphic-slot dispatch for `SqlStorage.types` entries.
  * Every entry must carry a `kind: 'codec-instance'` discriminator or

package/src/ir/sql-unbound-namespace.ts

@@ -3,6 +3,8 @@ import {
   NamespaceBase,
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { SqlNamespaceEntries } from './sql-storage';
 import type { StorageTable } from './storage-table';
 
 /**
@@ -40,9 +42,12 @@ export class SqlUnboundNamespace extends NamespaceBase {
   static readonly instance: SqlUnboundNamespace = new SqlUnboundNamespace();
 
   readonly id = UNBOUND_NAMESPACE_ID;
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-  }> = Object.freeze({ table: Object.freeze({}) });
+  readonly entries: SqlNamespaceEntries = Object.freeze({
+    table: blindCast<
+      Readonly<Record<string, StorageTable>>,
+      'empty frozen map is a valid Readonly<Record<string, StorageTable>>'
+    >(Object.freeze({})),
+  });
   declare readonly kind: string;
 
   private constructor() {
@@ -56,6 +61,13 @@ export class SqlUnboundNamespace extends NamespaceBase {
     freezeNode(this);
   }
 
+  get table(): Readonly<Record<string, StorageTable>> {
+    return blindCast<
+      Readonly<Record<string, StorageTable>>,
+      'entries[table] holds only StorageTable by construction'
+    >(this.entries['table']);
+  }
+
   qualifyTable(tableName: string): string {
     return `"${tableName}"`;
   }

package/src/resolve-storage-table.ts

@@ -1,4 +1,5 @@
-import type { SqlNamespace, SqlStorage } from './ir/sql-storage';
+import { entityAt } from '@prisma-next/framework-components/ir';
+import type { SqlStorage } from './ir/sql-storage';
 import type { StorageTable } from './ir/storage-table';
 
 export interface ResolvedStorageTable {
@@ -6,20 +7,6 @@ export interface ResolvedStorageTable {
   readonly table: StorageTable;
 }
 
-function tableInNamespace(
-  namespace: SqlNamespace | undefined,
-  tableName: string,
-): StorageTable | undefined {
-  if (namespace === undefined) {
-    return undefined;
-  }
-  const tables = namespace.entries.table;
-  if (!Object.hasOwn(tables, tableName)) {
-    return undefined;
-  }
-  return tables[tableName];
-}
-
 /**
  * Resolve a bare storage table name to its namespace coordinate and table IR.
  *
@@ -35,13 +22,21 @@ export function resolveStorageTable(
   namespaceId?: string,
 ): ResolvedStorageTable | undefined {
   if (namespaceId !== undefined) {
-    const table = tableInNamespace(storage.namespaces[namespaceId], tableName);
+    const table = entityAt<StorageTable>(storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     return table === undefined ? undefined : { namespaceId, table };
   }
 
   const matches: ResolvedStorageTable[] = [];
   for (const candidateNamespaceId of Object.keys(storage.namespaces)) {
-    const table = tableInNamespace(storage.namespaces[candidateNamespaceId], tableName);
+    const table = entityAt<StorageTable>(storage, {
+      namespaceId: candidateNamespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     if (table !== undefined) {
       matches.push({ namespaceId: candidateNamespaceId, table });
     }

package/src/types.ts

@@ -30,11 +30,12 @@ export { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';
 export { Index, type IndexInput } from './ir/sql-index';
 export { SqlNode } from './ir/sql-node';
 export {
+  type SqlNamespace,
+  type SqlNamespaceEntries,
   type SqlNamespaceTablesInput,
   SqlStorage,
   type SqlStorageInput,
   type SqlStorageTypeEntry,
-  storageTableAt,
 } from './ir/sql-storage';
 export { SqlUnboundNamespace } from './ir/sql-unbound-namespace';
 export { StorageColumn, type StorageColumnInput } from './ir/storage-column';

package/src/validators.ts

@@ -7,7 +7,7 @@ import {
 } from '@prisma-next/contract/types';
 import { validateContractDomain } from '@prisma-next/contract/validate-domain';
 import { type Namespace, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import { blindCast } from '@prisma-next/utils/casts';
+import { blindCast, castAs } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { type Type, type } from 'arktype';
 import { buildSqlNamespaceMap } from './ir/build-sql-namespace';
@@ -125,19 +125,6 @@ const StorageTypeInstanceSchema = type
     'typeParams?': 'Record<string, unknown>',
   });
 
-/**
- * Postgres native enum entry under `storage.namespaces[namespaceId].entries.type[name]`.
- * Document-scoped `storage.types` carries codec aliases only
- * (`DocumentScopedStorageTypeSchema`).
- */
-const PostgresEnumTypeSchema = type({
-  kind: "'postgres-enum'",
-  'name?': 'string',
-  'nativeType?': 'string',
-  values: type.string.array().readonly(),
-  'control?': ControlPolicySchema,
-});
-
 /** Document-scoped `storage.types`: codec triples only. */
 const DocumentScopedStorageTypeSchema = StorageTypeInstanceSchema;
 
@@ -233,103 +220,88 @@ const StorageTableSchema = type({
 });
 
 /**
- * Re-exported so target packs can register their `validatorSchema`
- * fragment without re-declaring the schema for the kinds the family
- * core already validates. Full extraction of enum-specific schemas
- * into the Postgres pack is a follow-up; today the symbol lives here.
- */
-export { PostgresEnumTypeSchema };
-
-/**
- * Composes a hardcoded family `fallback` schema with optional
- * pack-contributed `fragments` keyed by the entry's `kind`
- * discriminator. The composition is **additive**, not substitutive:
- *
- * - No fragments registered → entries are validated by `fallback`
- *   alone (the unchanged baseline).
- * - An entry's `kind` matches `fallbackKind` AND a fragment for that
- *   kind is registered → the entry must pass **both** `fallback` and
- *   the fragment. This preserves family-owned invariants (e.g. the
- *   built-in `PostgresEnumType` shape) even when a pack contributes
- *   its own schema for the same kind.
- * - An entry's `kind` matches a registered fragment for some
- *   non-fallback kind → the fragment alone validates the entry.
- *   `fallback` is family-specific (validates a single hardcoded kind)
- *   and would reject any other kind, so it does not apply here.
- * - An entry's `kind` matches no fragment → fall through to
- *   `fallback`.
+ * Composes the single entry-validator registry consulted during
+ * structural validation. SQL core registers its own kinds (`'table'`,
+ * `'valueSet'`) into the same registry targets extend — there is no
+ * separate built-in fallback tier. Target packs pass their contributed
+ * kinds (e.g. postgres passes `'type'` → the postgres enum schema).
  */
-function namespaceSlotEntrySchema(
-  fallback: Type<unknown>,
-  fallbackKind: string,
-  fragments?: ReadonlyMap<string, Type<unknown>>,
-): Type<unknown> {
-  if (fragments === undefined || fragments.size === 0) {
-    return fallback;
-  }
-  return type('unknown').narrow((entry, ctx) => {
-    if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
-      return ctx.mustBe('an object');
-    }
-    const kind = (entry as { kind?: unknown }).kind;
-    if (typeof kind === 'string') {
-      const fragment = fragments.get(kind);
-      if (fragment !== undefined) {
-        if (kind === fallbackKind) {
-          const baseParsed = fallback(entry);
-          if (baseParsed instanceof type.errors) {
-            return ctx.reject({ expected: baseParsed.summary });
-          }
-        }
-        const parsed = fragment(entry);
-        if (parsed instanceof type.errors) {
-          return ctx.reject({ expected: parsed.summary });
-        }
-        return true;
+export function createSqlEntrySchemaRegistry(
+  packSchemas?: ReadonlyMap<string, Type<unknown>>,
+): ReadonlyMap<string, Type<unknown>> {
+  const registry = new Map<string, Type<unknown>>([
+    ['table', castAs<Type<unknown>>(StorageTableSchema)],
+    ['valueSet', castAs<Type<unknown>>(StorageValueSetSchema)],
+  ]);
+  if (packSchemas !== undefined) {
+    for (const [kind, schema] of packSchemas) {
+      if (registry.has(kind)) {
+        throw new Error(
+          `createSqlEntrySchemaRegistry: pack schema "${kind}" collides with a core kind — pack schemas cannot override "table" or "valueSet"`,
+        );
       }
+      registry.set(kind, schema);
     }
-    const parsed = fallback(entry);
-    if (parsed instanceof type.errors) {
-      return ctx.reject({ expected: parsed.summary });
-    }
-    return true;
-  });
+  }
+  return registry;
 }
 
 /**
  * Builds the per-namespace entry schema for `storage.namespaces[id]`.
- * Pack-contributed `validatorSchema` fragments — keyed by the
- * descriptor's `discriminator` — validate each entry by matching the
- * entry's `kind` field on the `'entries.type'` slot.
+ *
+ * Validation is registry-driven: the `registry` parameter maps each
+ * entries key to an arktype schema that validates a single inner-map
+ * value for that kind. Compose the registry with
+ * {@link createSqlEntrySchemaRegistry} — SQL core's kinds and pack
+ * contributions live in the same map. An unregistered key fails
+ * validation naming the kind and the namespace id, so validation fails
+ * closed.
  */
 export function createNamespaceEntrySchema(
-  fragments?: ReadonlyMap<string, Type<unknown>>,
+  registry: ReadonlyMap<string, Type<unknown>>,
 ): Type<unknown> {
   return type({
     '+': 'reject',
     id: 'string',
     'kind?': 'string',
-    entries: type({
-      '+': 'reject',
-      'table?': type({ '[string]': StorageTableSchema }),
-      'type?': type({
-        '[string]': namespaceSlotEntrySchema(PostgresEnumTypeSchema, 'postgres-enum', fragments),
-      }),
-      'valueSet?': type({ '[string]': StorageValueSetSchema }),
-    }),
+    entries: 'object',
+  }).narrow((ns, ctx) => {
+    if (!isPlainRecord(ns.entries)) {
+      return ctx.mustBe('an entries object');
+    }
+    for (const [key, innerMap] of Object.entries(ns.entries)) {
+      const entrySchema = registry.get(key);
+      if (entrySchema === undefined) {
+        return ctx.reject({
+          expected: `entries key "${key}" in namespace "${ns.id}" is not a registered entity kind`,
+        });
+      }
+      if (!isPlainRecord(innerMap)) {
+        return ctx.reject({
+          expected: `entries["${key}"] in namespace "${ns.id}" must be an object`,
+        });
+      }
+      for (const [, value] of Object.entries(innerMap)) {
+        const parsed = entrySchema(value);
+        if (parsed instanceof type.errors) {
+          return ctx.reject({ expected: parsed.summary });
+        }
+      }
+    }
+    return true;
   }) as Type<unknown>;
 }
 
 /**
  * Builds the storage schema. Pack contributions reach the per-namespace
  * entry shape through {@link createNamespaceEntrySchema}; the
- * document-scoped `storage.types` slot (codec triples only) and the
+ * document-scoped `storage.types` field (codec triples only) and the
  * storage hash stay family-shared.
  */
 export function createSqlStorageSchema(
-  fragments?: ReadonlyMap<string, Type<unknown>>,
+  registry: ReadonlyMap<string, Type<unknown>>,
 ): Type<unknown> {
-  const namespaceEntry = createNamespaceEntrySchema(fragments);
+  const namespaceEntry = createNamespaceEntrySchema(registry);
   return type({
     '+': 'reject',
     storageHash: 'string',
@@ -343,24 +315,20 @@ export function createSqlStorageSchema(
   }) as Type<unknown>;
 }
 
-const StorageSchema = createSqlStorageSchema();
+const StorageSchema = createSqlStorageSchema(createSqlEntrySchemaRegistry());
 
-// SQL-specific namespace walk shape (`entries.table` is the SQL family's
-// idiom). The wider `object` table value keeps this helper structurally
-// compatible with `SqlNamespace` and JSON envelope variants that lose class
-// identity.
 type NamespacedStorageWalk = {
   readonly namespaces: Readonly<
     Record<
       string,
-      Namespace & { readonly entries: { readonly table: Readonly<Record<string, object>> } }
+      Namespace & { readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>> }
     >
   >;
 };
 
 function eachStorageTable(storage: NamespacedStorageWalk) {
   return Object.entries(storage.namespaces).flatMap(([namespaceId, ns]) =>
-    Object.entries(ns.entries.table).map(([tableName, table]) => ({
+    Object.entries(ns.entries['table'] ?? {}).map(([tableName, table]) => ({
       namespaceId,
       tableName,
       table,
@@ -369,7 +337,9 @@ function eachStorageTable(storage: NamespacedStorageWalk) {
 }
 
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value) as unknown;
+  return proto === Object.prototype || proto === null;
 }
 
 function findDuplicateValue(values: readonly string[]): string | undefined {
@@ -490,9 +460,9 @@ const ContractMetaSchema = type({
  * of the contract envelope is family-shared.
  */
 export function createSqlContractSchema(
-  fragments?: ReadonlyMap<string, Type<unknown>>,
+  registry: ReadonlyMap<string, Type<unknown>>,
 ): Type<unknown> {
-  const storage = createSqlStorageSchema(fragments);
+  const storage = createSqlStorageSchema(registry);
   return type({
     '+': 'reject',
     target: 'string',
@@ -518,7 +488,7 @@ export function createSqlContractSchema(
   }) as Type<unknown>;
 }
 
-const SqlContractSchema = createSqlContractSchema();
+const SqlContractSchema = createSqlContractSchema(createSqlEntrySchemaRegistry());
 
 // NOTE: StorageColumnSchema, StorageTableSchema, and StorageSchema use bare type()
 // instead of type.declare<T>().type() because the ColumnDefault union's value field
@@ -802,7 +772,8 @@ export function validateModelStorageReferences(contract: Contract<SqlStorage>):
       }
 
       const storageTable = model.storage.table;
-      const rawTable = contract.storage.namespaces[storageNamespaceId]?.entries.table[storageTable];
+      const storageNs = contract.storage.namespaces[storageNamespaceId];
+      const rawTable = storageNs?.entries.table?.[storageTable];
       if (rawTable === undefined) {
         throw new ContractValidationError(
           `Model "${qualifiedName}" references non-existent table "${storageNamespaceId}.${storageTable}"`,
@@ -922,7 +893,7 @@ export function validateSqlStorageConsistency(contract: Contract<SqlStorage>): v
 
       if (fk.target.spaceId === undefined) {
         const targetNamespace = contract.storage.namespaces[fk.target.namespaceId];
-        const referencedRaw = targetNamespace?.entries.table[fk.target.tableName];
+        const referencedRaw = targetNamespace?.entries.table?.[fk.target.tableName];
         if (referencedRaw === undefined) {
           throw new ContractValidationError(
             `Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent table "${fk.target.namespaceId}.${fk.target.tableName}"`,