@prisma-next/sql-contract 0.13.0-dev.4 → 0.13.0-dev.40

package/src/entity-kinds.ts

@@ -0,0 +1,45 @@
+import type {
+  AnyEntityKindDescriptor,
+  EntityKindDescriptor,
+} from '@prisma-next/framework-components/ir';
+import { StorageTableSchema, StorageValueSetSchema } from './ir/storage-entry-schemas';
+import { StorageTable, type StorageTableInput } from './ir/storage-table';
+import { StorageValueSet, type StorageValueSetInput } from './ir/storage-value-set';
+
+export const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable> = {
+  kind: 'table',
+  schema: StorageTableSchema,
+  construct: (input) => new StorageTable(input),
+};
+
+export const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet> = {
+  kind: 'valueSet',
+  schema: StorageValueSetSchema,
+  construct: (input) => new StorageValueSet(input),
+};
+
+/**
+ * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+ * `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+ * lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+ * later consumes this registry to turn a namespace's raw entries into IR
+ * instances, and `createSqlContractSchema` derives validation from the same
+ * registry. Throws on a duplicate kind.
+ */
+export function composeSqlEntityKinds(
+  packKinds: readonly AnyEntityKindDescriptor[] = [],
+): ReadonlyMap<string, AnyEntityKindDescriptor> {
+  const kinds = new Map<string, AnyEntityKindDescriptor>([
+    ['table', tableEntityKind],
+    ['valueSet', valueSetEntityKind],
+  ]);
+  for (const descriptor of packKinds) {
+    if (kinds.has(descriptor.kind)) {
+      throw new Error(
+        `composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`,
+      );
+    }
+    kinds.set(descriptor.kind, descriptor);
+  }
+  return kinds;
+}

package/src/exports/entity-kinds.ts

@@ -0,0 +1,5 @@
+export {
+  composeSqlEntityKinds,
+  tableEntityKind,
+  valueSetEntityKind,
+} from '../entity-kinds';

package/src/exports/types.ts

@@ -13,7 +13,6 @@ export type {
   ForeignKeyOptions,
   ForeignKeyReferenceInput,
   IndexInput,
-  PostgresEnumStorageEntry,
   PrimaryKeyInput,
   QueryOperationReturn,
   QueryOperationSelfSpec,
@@ -25,6 +24,8 @@ export type {
   SqlControlDriverInstance,
   SqlModelFieldStorage,
   SqlModelStorage,
+  SqlNamespace,
+  SqlNamespaceEntries,
   SqlNamespaceTablesInput,
   SqlQueryOperationTypes,
   SqlStorageInput,
@@ -49,9 +50,7 @@ export {
   ForeignKey,
   ForeignKeyReference,
   Index,
-  isPostgresEnumStorageEntry,
   isStorageTypeInstance,
-  POSTGRES_ENUM_KIND,
   PrimaryKey,
   SqlNode,
   SqlStorage,
@@ -59,7 +58,6 @@ export {
   StorageColumn,
   StorageTable,
   StorageValueSet,
-  storageTableAt,
   toStorageTypeInstance,
   UniqueConstraint,
 } from '../types';

package/src/index-type-validation.ts

@@ -2,15 +2,14 @@ import { ContractValidationError } from '@prisma-next/contract/contract-validati
 import type { Contract } from '@prisma-next/contract/types';
 import { type } from 'arktype';
 import type { IndexTypeRegistry } from './index-types';
-import type { SqlStorage, StorageTable } from './types';
+import type { SqlStorage } from './types';
 
 export function validateIndexTypes(
   contract: Contract<SqlStorage>,
   indexTypeRegistry: IndexTypeRegistry,
 ): void {
   for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {
-    for (const [tableName, rawTable] of Object.entries(ns.entries.table)) {
-      const table = rawTable as StorageTable;
+    for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) {
       for (const index of table.indexes) {
         if (index.type === undefined && index.options !== undefined) {
           throw new ContractValidationError(

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

@@ -1,14 +1,16 @@
 import {
   freezeNode,
+  hydrateNamespaceEntities,
   type Namespace,
   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 { composeSqlEntityKinds } from '../entity-kinds';
+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 type { StorageTable } from './storage-table';
+import type { StorageValueSet } from './storage-value-set';
 
 const SQL_NAMESPACE_KIND = 'sql-namespace' as const;
 
@@ -27,39 +29,39 @@ 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)]),
-      ),
+
+    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');
+
+    this.entries = Object.freeze(
+      blindCast<
+        SqlNamespaceEntries,
+        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'
+      >(dispatched),
     );
-    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 });
-    }
     Object.defineProperty(this, 'kind', {
       value: SQL_NAMESPACE_KIND,
       writable: false,
@@ -69,6 +71,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 +98,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-node.ts

@@ -41,8 +41,8 @@ export abstract class SqlNode extends IRNodeBase {
       value: 'sql',
       writable: false,
       enumerable: false,
-      // configurable so per-leaf subclasses (e.g. PostgresEnumType in
-      // target-postgres) can override `kind` with their narrower
+      // configurable so per-leaf subclasses (e.g. StorageValueSet)
+      // can override `kind` with their narrower
       // enumerable literal via a class-field initializer. SqlNode
       // itself never needs to mutate the property again, so
       // configurability has no surface impact at this layer.

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/ir/storage-entry-schemas.ts

@@ -0,0 +1,128 @@
+import { type Type, type } from 'arktype';
+import type { ForeignKeyInput, ReferentialAction } from './foreign-key';
+import type { ForeignKeyReferenceInput } from './foreign-key-reference';
+import type { PrimaryKeyInput } from './primary-key';
+import type { UniqueConstraintInput } from './unique-constraint';
+
+type ColumnDefaultLiteral = {
+  readonly kind: 'literal';
+  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;
+};
+type ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };
+
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+
+export const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({
+  kind: literalKindSchema,
+  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',
+});
+
+export const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({
+  kind: functionKindSchema,
+  expression: 'string',
+});
+
+export const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+
+const StorageValueSetRefSchema = type({
+  plane: "'storage'",
+  namespaceId: 'string',
+  entityKind: "'valueSet'",
+  entityName: 'string',
+  'spaceId?': 'string',
+});
+
+const StorageColumnSchema = type({
+  '+': 'reject',
+  nativeType: 'string',
+  codecId: 'string',
+  nullable: 'boolean',
+  'typeParams?': 'Record<string, unknown>',
+  'typeRef?': 'string',
+  'default?': ColumnDefaultSchema,
+  'control?': ControlPolicySchema,
+  'valueSet?': StorageValueSetRefSchema,
+}).narrow((col, ctx) => {
+  if (col.typeParams !== undefined && col.typeRef !== undefined) {
+    return ctx.mustBe('a column with either typeParams or typeRef, not both');
+  }
+  return true;
+});
+
+/**
+ * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+ * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+ * ordered `values` array of codec-encoded permitted values.
+ */
+export const StorageValueSetSchema = type({
+  kind: "'valueSet'",
+  values: type('string | number | boolean | null | unknown[] | Record<string, unknown>')
+    .array()
+    .readonly(),
+});
+
+const PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+export const IndexSchema = type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+  'type?': 'string',
+  'options?': 'Record<string, unknown>',
+});
+
+export const ForeignKeyReferenceSchema = type({
+  '+': 'reject',
+  namespaceId: 'string',
+  tableName: 'string',
+  columns: type.string.array().readonly(),
+  'spaceId?': 'string',
+}) satisfies Type<ForeignKeyReferenceInput>;
+
+export const ForeignKeySourceSchema = type({
+  '+': 'reject',
+  namespaceId: 'string',
+  tableName: 'string',
+  columns: type.string.array().readonly(),
+}) satisfies Type<ForeignKeyReferenceInput>;
+
+export const ReferentialActionSchema = type
+  .declare<ReferentialAction>()
+  .type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+
+export const ForeignKeySchema = type.declare<ForeignKeyInput>().type({
+  source: ForeignKeySourceSchema,
+  target: ForeignKeyReferenceSchema,
+  'name?': 'string',
+  'onDelete?': ReferentialActionSchema,
+  'onUpdate?': ReferentialActionSchema,
+  constraint: 'boolean',
+  index: 'boolean',
+});
+
+export const CheckConstraintSchema = type({
+  '+': 'reject',
+  name: 'string',
+  column: 'string',
+  valueSet: StorageValueSetRefSchema,
+});
+
+export const StorageTableSchema = type({
+  '+': 'reject',
+  columns: type({ '[string]': StorageColumnSchema }),
+  'primaryKey?': PrimaryKeySchema,
+  uniques: UniqueConstraintSchema.array().readonly(),
+  indexes: IndexSchema.array().readonly(),
+  foreignKeys: ForeignKeySchema.array().readonly(),
+  'control?': ControlPolicySchema,
+  'checks?': CheckConstraintSchema.array().readonly(),
+});

package/src/ir/storage-type-instance.ts

@@ -14,8 +14,8 @@ export const CODEC_INSTANCE_KIND = 'codec-instance' as const;
  * in `SqlStorage.types`. These are plain object literals — there is no
  * runtime IR class, the JSON envelope round-trips through the slot
  * unchanged. The `kind: 'codec-instance'` discriminator is the dispatch
- * key that distinguishes codec-typed entries from class-instance entries
- * (e.g. `PostgresEnumType`) sharing the polymorphic slot.
+ * key that distinguishes codec-typed entries from any class-instance
+ * kinds a target pack contributes to the polymorphic slot.
  */
 export interface StorageTypeInstance extends StorageType {
   readonly kind: typeof CODEC_INSTANCE_KIND;
@@ -54,7 +54,7 @@ export function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageT
 /**
  * Type-guard for codec-typed entries on the polymorphic
  * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
- * class-instance kinds (e.g. `PostgresEnumType`).
+ * any class-instance kinds a target pack contributes.
  */
 export function isStorageTypeInstance(value: unknown): value is StorageTypeInstance {
   if (typeof value !== 'object' || value === null) return false;

package/src/ir/storage-value-set.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
 
@@ -7,9 +8,9 @@ import { SqlNode } from './sql-node';
  * walker can hand a validated literal straight to `new`.
  */
 export interface StorageValueSetInput {
-  readonly kind: 'value-set';
+  readonly kind: 'valueSet';
   /** Ordered permitted values, codec-encoded. Declaration order is preserved. */
-  readonly values: readonly string[];
+  readonly values: readonly JsonValue[];
 }
 
 /**
@@ -21,7 +22,7 @@ export interface StorageValueSetInput {
  * column that references it already holds the codec; the value-set holds
  * only the permitted values.
  *
- * The node's `kind` is enumerable (`'value-set'`) so the JSON envelope
+ * The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope
  * carries the discriminator and the serializer hydration walker can
  * dispatch on it. This follows the per-leaf enumerable-kind convention
  * established in the SQL-node comment (future polymorphic dispatch on
@@ -31,8 +32,8 @@ export interface StorageValueSetInput {
  * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.
  */
 export class StorageValueSet extends SqlNode {
-  override readonly kind = 'value-set' as const;
-  readonly values: readonly string[];
+  override readonly kind = 'valueSet' as const;
+  readonly values: readonly JsonValue[];
 
   constructor(input: StorageValueSetInput) {
     super();

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

@@ -21,20 +21,16 @@ export {
   ForeignKeyReference,
   type ForeignKeyReferenceInput,
 } from './ir/foreign-key-reference';
-export {
-  isPostgresEnumStorageEntry,
-  POSTGRES_ENUM_KIND,
-  type PostgresEnumStorageEntry,
-} from './ir/postgres-enum-storage-entry';
 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';
@@ -83,11 +79,15 @@ export function applyFkDefaults(
   };
 }
 
+// Field-type maps nested by namespace coordinate: `[namespaceId][model][field]`.
+// Shared by the output and input field-type maps and their extractors.
+export type NamespacedFieldTypeMap = Record<string, Record<string, Record<string, unknown>>>;
+
 export type TypeMaps<
   TCodecTypes extends Record<string, { output: unknown }> = Record<string, never>,
   TQueryOperationTypes extends Record<string, unknown> = Record<string, never>,
-  TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
-  TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>,
+  TFieldOutputTypes extends NamespacedFieldTypeMap = Record<string, never>,
+  TFieldInputTypes extends NamespacedFieldTypeMap = Record<string, never>,
 > = {
   readonly codecTypes: TCodecTypes;
   readonly queryOperationTypes: TQueryOperationTypes;
@@ -159,7 +159,7 @@ export type ExtractTypeMapsFromContract<T> = TypeMapsPhantomKey extends keyof T
 export type FieldOutputTypesOf<T> = [T] extends [never]
   ? Record<string, never>
   : T extends { readonly fieldOutputTypes: infer F }
-    ? F extends Record<string, Record<string, unknown>>
+    ? F extends NamespacedFieldTypeMap
       ? F
       : Record<string, never>
     : Record<string, never>;
@@ -167,7 +167,7 @@ export type FieldOutputTypesOf<T> = [T] extends [never]
 export type FieldInputTypesOf<T> = [T] extends [never]
   ? Record<string, never>
   : T extends { readonly fieldInputTypes: infer F }
-    ? F extends Record<string, Record<string, unknown>>
+    ? F extends NamespacedFieldTypeMap
       ? F
       : Record<string, never>
     : Record<string, never>;