@prisma-next/sql-contract 0.12.0 → 0.13.0-dev.2

package/src/exports/types.ts

@@ -1,4 +1,5 @@
 export type {
+  CheckConstraintInput,
   CodecTypesOf,
   ContractWithTypeMaps,
   ExtractCodecTypes,
@@ -21,6 +22,7 @@ export type {
   QueryOperationTypesOf,
   ReferentialAction,
   ResolveCodecTypes,
+  SqlControlDriverInstance,
   SqlModelFieldStorage,
   SqlModelStorage,
   SqlNamespaceTablesInput,
@@ -31,6 +33,7 @@ export type {
   StorageTableInput,
   StorageTypeInstance,
   StorageTypeInstanceInput,
+  StorageValueSetInput,
   TypeMaps,
   TypeMapsPhantomKey,
   UniqueConstraintInput,
@@ -39,6 +42,7 @@ export {
   applyFkDefaults,
   buildSqlNamespace,
   buildSqlNamespaceMap,
+  CheckConstraint,
   CODEC_INSTANCE_KIND,
   DEFAULT_FK_CONSTRAINT,
   DEFAULT_FK_INDEX,
@@ -54,6 +58,8 @@ export {
   SqlUnboundNamespace,
   StorageColumn,
   StorageTable,
+  StorageValueSet,
+  storageTableAt,
   toStorageTypeInstance,
   UniqueConstraint,
 } from '../types';

package/src/factories.ts

@@ -72,12 +72,13 @@ export function model(
   tableName: string,
   fields: Record<string, SqlModelFieldStorage>,
   relations: Record<string, unknown> = {},
+  namespaceId: string = UNBOUND_NAMESPACE_ID,
 ): {
   storage: SqlModelStorage;
   fields: Record<string, { readonly nullable: boolean; readonly type: ScalarFieldType }>;
   relations: Record<string, unknown>;
 } {
-  const storage: SqlModelStorage = { table: tableName, fields };
+  const storage: SqlModelStorage = { table: tableName, namespaceId, fields };
   const domainFields = Object.fromEntries(
     Object.entries(fields).map(([name, field]) => [
       name,

package/src/index-type-validation.ts

@@ -9,7 +9,7 @@ export function validateIndexTypes(
   indexTypeRegistry: IndexTypeRegistry,
 ): void {
   for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {
-    for (const [tableName, rawTable] of Object.entries(ns.tables)) {
+    for (const [tableName, rawTable] of Object.entries(ns.entries.table)) {
       const table = rawTable as StorageTable;
       for (const index of table.indexes) {
         if (index.type === undefined && index.options !== undefined) {

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

@@ -5,10 +5,10 @@ import {
   UNBOUND_NAMESPACE_ID,
 } from '@prisma-next/framework-components/ir';
 import { blindCast, castAs } from '@prisma-next/utils/casts';
-import type { PostgresEnumStorageEntry } from './postgres-enum-storage-entry';
 import type { SqlNamespace, SqlNamespaceTablesInput } from './sql-storage';
 import { SqlUnboundNamespace } from './sql-unbound-namespace';
 import { StorageTable } from './storage-table';
+import { StorageValueSet } from './storage-value-set';
 
 const SQL_NAMESPACE_KIND = 'sql-namespace' as const;
 
@@ -25,15 +25,18 @@ function isMaterializedSqlNamespace(ns: Namespace | SqlNamespaceTablesInput): ns
 
 class SqlBoundNamespace extends NamespaceBase {
   declare readonly kind: string;
-  declare readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
 
   readonly id: string;
-  readonly tables: Readonly<Record<string, StorageTable>>;
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
+  }>;
 
   static fromTablesInput(input: SqlNamespaceTablesInput): SqlNamespace {
-    const tableCount = Object.keys(input.tables ?? {}).length;
-    const enumCount = Object.keys(input.enum ?? {}).length;
-    if (input.id === UNBOUND_NAMESPACE_ID && tableCount === 0 && enumCount === 0) {
+    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);
     }
     return castAs<SqlNamespace>(new SqlBoundNamespace(input));
@@ -42,21 +45,20 @@ class SqlBoundNamespace extends NamespaceBase {
   private constructor(input: SqlNamespaceTablesInput) {
     super();
     this.id = input.id;
-    this.tables = Object.freeze(
+    const table = Object.freeze(
       Object.fromEntries(
-        Object.entries(input.tables ?? {}).map(([name, t]) => [
-          name,
-          t instanceof StorageTable ? t : new StorageTable(t),
-        ]),
+        Object.entries(input.entries.table).map(([k, v]) => [k, new StorageTable(v)]),
       ),
     );
-    if (input.enum !== undefined && Object.keys(input.enum).length > 0) {
-      Object.defineProperty(this, 'enum', {
-        value: Object.freeze({ ...input.enum }),
-        writable: false,
-        enumerable: true,
-        configurable: false,
-      });
+    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,
@@ -66,6 +68,13 @@ class SqlBoundNamespace extends NamespaceBase {
     });
     freezeNode(this);
   }
+
+  qualifyTable(tableName: string): string {
+    if (this.id === UNBOUND_NAMESPACE_ID) {
+      return `"${tableName}"`;
+    }
+    return `"${this.id}"."${tableName}"`;
+  }
 }
 
 export function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace {
@@ -83,7 +92,12 @@ export function buildSqlNamespaceMap(
             SqlNamespace,
             'a materialised SQL-family namespace entry in a namespace map is a SqlNamespace'
           >(ns)
-        : SqlBoundNamespace.fromTablesInput(ns),
+        : SqlBoundNamespace.fromTablesInput(
+            blindCast<
+              SqlNamespaceTablesInput,
+              'non-materialized SQL namespace map entry is a SqlNamespaceTablesInput'
+            >(ns),
+          ),
     ]),
   );
 }

package/src/ir/check-constraint.ts

@@ -0,0 +1,42 @@
+import type { ValueSetRef } from '@prisma-next/contract/types';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+/**
+ * Hydration / construction input shape for {@link CheckConstraint}.
+ * Mirrors the on-disk storage JSON envelope so the serializer hydration
+ * walker can hand a validated literal straight to `new`.
+ */
+export interface CheckConstraintInput {
+  readonly name: string;
+  readonly column: string;
+  readonly valueSet: ValueSetRef;
+}
+
+/**
+ * SQL Contract IR node for a table-level check constraint that restricts
+ * a column to the permitted values of a value-set.
+ *
+ * The constraint is **structured** (names a column and a value-set
+ * reference), not a raw SQL expression. Each target renders its own DDL
+ * from the structured form, keeping the contract target-agnostic.
+ *
+ * Construction is idempotent: passing an existing `CheckConstraint`
+ * instance as input produces a new instance with identical fields.
+ * The constructor does not use `instanceof` for input discrimination —
+ * it reads plain named properties, which is sufficient since
+ * `CheckConstraintInput` is a structural type.
+ */
+export class CheckConstraint extends SqlNode {
+  readonly name: string;
+  readonly column: string;
+  readonly valueSet: ValueSetRef;
+
+  constructor(input: CheckConstraintInput) {
+    super();
+    this.name = input.name;
+    this.column = input.column;
+    this.valueSet = input.valueSet;
+    freezeNode(this);
+  }
+}

package/src/ir/foreign-key-reference.ts

@@ -2,16 +2,37 @@ import { asNamespaceId, type NamespaceId } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
 
+/**
+ * Input for a foreign-key reference (one side of a foreign-key declaration).
+ *
+ * When `spaceId` is absent the reference is local — the referenced table lives
+ * in the same contract-space. When `spaceId` is present the reference is
+ * cross-space — the referenced table lives in a different contract-space
+ * identified by `spaceId`.
+ *
+ * Presence-based discrimination keeps local FK JSON byte-identical to
+ * contracts authored before cross-space support was added.
+ */
 export interface ForeignKeyReferenceInput {
   readonly namespaceId: string;
   readonly tableName: string;
   readonly columns: readonly string[];
+  readonly spaceId?: string;
 }
 
 /**
  * SQL Contract IR node for one side (source or target) of a foreign-key
  * declaration. Carries the full coordinate: namespace, table, and columns.
  *
+ * Cross-space discrimination is based on `spaceId` presence: absent means
+ * local (same contract-space); present means cross-space (the referenced
+ * table lives in the contract-space identified by `spaceId`).
+ *
+ * For local references `spaceId` is absent from JSON, keeping the serialized
+ * shape byte-identical to contracts authored before cross-space support was
+ * added. For cross-space references `spaceId` appears in JSON so round-trips
+ * are lossless.
+ *
  * Use `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`
  * as the sentinel `namespaceId` for single-namespace (unbound) references.
  */
@@ -19,12 +40,14 @@ export class ForeignKeyReference extends SqlNode {
   readonly namespaceId: NamespaceId;
   readonly tableName: string;
   readonly columns: readonly string[];
+  declare readonly spaceId?: string;
 
   constructor(input: ForeignKeyReferenceInput) {
     super();
     this.namespaceId = asNamespaceId(input.namespaceId);
     this.tableName = input.tableName;
     this.columns = input.columns;
+    if (input.spaceId !== undefined) this.spaceId = input.spaceId;
     freezeNode(this);
   }
 }

package/src/ir/postgres-enum-storage-entry.ts

@@ -1,3 +1,4 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { StorageType } from '@prisma-next/framework-components/ir';
 
 /**
@@ -42,6 +43,7 @@ export interface PostgresEnumStorageEntry extends StorageType {
    * present on raw JSON envelopes).
    */
   readonly codecId: string;
+  readonly control?: ControlPolicy;
 }
 
 /**

package/src/ir/sql-storage.ts

@@ -1,32 +1,30 @@
 import type { StorageHashBase } from '@prisma-next/contract/types';
 import { freezeNode, type Namespace, type Storage } from '@prisma-next/framework-components/ir';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-} from './postgres-enum-storage-entry';
 import { SqlNode } from './sql-node';
 import type { StorageTable, StorageTableInput } from './storage-table';
 import {
   isStorageTypeInstance,
   type StorageTypeInstance,
   type StorageTypeInstanceInput,
+  toStorageTypeInstance,
 } from './storage-type-instance';
+import type { StorageValueSet, StorageValueSetInput } from './storage-value-set';
 
 /**
  * Polymorphic value type for document-scoped `SqlStorage.types` entries
- * (codec aliases / parameterised native type registrations). Postgres
- * native enum registrations live under
- * `storage.namespaces[namespaceId].enum` instead.
+ * (codec aliases / parameterised native type registrations).
+ *
+ * Postgres native enum registrations live under the postgres-specific
+ * `entries.type` slot on `PostgresSchema` (target layer), not here.
  */
-export type SqlStorageTypeEntry =
-  | StorageTypeInstance
-  | StorageTypeInstanceInput
-  | PostgresEnumStorageEntry;
+export type SqlStorageTypeEntry = StorageTypeInstance | StorageTypeInstanceInput;
 
 export interface SqlNamespaceTablesInput {
   readonly id: string;
-  readonly tables?: Record<string, StorageTable | StorageTableInput>;
-  readonly enum?: Record<string, PostgresEnumStorageEntry>;
+  readonly entries: {
+    readonly table: Record<string, StorageTable | StorageTableInput>;
+    readonly valueSet?: Record<string, StorageValueSet | StorageValueSetInput>;
+  };
 }
 
 export interface SqlStorageInput<THash extends string = string> {
@@ -51,30 +49,35 @@ export interface SqlStorageInput<THash extends string = string> {
  *
  * The constructor normalises optional `types` into class instances.
  * `types` is polymorphic per Decision 18 Option B: codec-triple inputs
- * are stamped with `kind: 'codec-instance'`; class-instance kinds
- * (e.g. Postgres-enum entries satisfying `PostgresEnumStorageEntry`)
- * pass through; hydration of raw JSON class-instance entries (carrying
- * their narrower `kind` literal) is the per-target serializer's
- * responsibility (so the family base does not import target-specific
- * subclasses).
+ * are stamped with `kind: 'codec-instance'`; hydration of raw JSON
+ * class-instance entries (carrying their narrower `kind` literal) is
+ * the per-target serializer's responsibility (so the family base does
+ * not import target-specific subclasses).
  */
-// SQL concretions always store `StorageTable`-shaped values in `tables`.
-// `tables` is a SQL-family idiom — the framework `Namespace` contract no
-// longer mandates this field; Mongo namespaces carry `collections`
-// instead. The `tables` slot uses the same narrowing as every other
-// SQL namespace; 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.
+// 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.
 export type SqlNamespace = Namespace & {
-  readonly tables: Readonly<Record<string, StorageTable>>;
-  readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+    readonly valueSet?: Readonly<Record<string, StorageValueSet>>;
+  }>;
+  /**
+   * Render a dialect-qualified table reference for runtime SQL emission.
+   * Present on materialised target concretions (`PostgresSchema`,
+   * `SqliteDatabase`, …) and family placeholders; omitted on emitted
+   * contract structural namespace literals (methods are not serialised).
+   */
+  qualifyTable?(tableName: string): string;
 };
 
 export class SqlStorage<THash extends string = string> extends SqlNode implements Storage {
   readonly storageHash: StorageHashBase<THash>;
   readonly namespaces: Readonly<Record<string, SqlNamespace>>;
-  declare readonly types?: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  declare readonly types?: Readonly<Record<string, StorageTypeInstance>>;
 
   constructor(input: SqlStorageInput<THash>) {
     super();
@@ -91,11 +94,18 @@ 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 recognised `kind` discriminator — either
- * `'codec-instance'` (codec triple, family-shared) or
- * `'postgres-enum'` (target-specific IR class). Untagged or
+ * Every entry must carry a `kind: 'codec-instance'` discriminator or
+ * be an already-constructed `StorageTypeInstance`. Untagged or
  * unrecognised inputs throw a diagnostic naming the entry and its
  * `kind`, so format drift surfaces loudly at the deserializer
  * boundary instead of slipping past the seam and corrupting
@@ -108,24 +118,17 @@ export class SqlStorage<THash extends string = string> extends SqlNode implement
  * arktype schema rejects untagged entries earlier, so this throw
  * only fires for in-memory authoring bugs.
  */
-function normaliseTypeEntry(
-  name: string,
-  entry: SqlStorageTypeEntry,
-): StorageTypeInstance | PostgresEnumStorageEntry {
-  if (isPostgresEnumStorageEntry(entry)) {
-    // Live class instances pass through unchanged; raw JSON envelopes
-    // (e.g. `kind: 'postgres-enum'` without the class identity) are
-    // rejected so the target serializer's hydration path is the only
-    // way IR class instances enter the slot.
-    if (entry instanceof SqlNode) {
+function normaliseTypeEntry(name: string, entry: SqlStorageTypeEntry): StorageTypeInstance {
+  if (isStorageTypeInstance(entry)) {
+    // Normalise on-disk objects that omit `typeParams` (the canonical on-disk
+    // form strips empty typeParams to keep JSON compact). The in-memory invariant
+    // is always `typeParams: {}` when empty — never `undefined`. Only create a
+    // new object when necessary to preserve identity-equality for callers that
+    // hold a reference to an already-correct in-memory entry.
+    if ('typeParams' in entry) {
       return entry;
     }
-    throw new Error(
-      `Encountered raw postgres-enum JSON in storage.types[${JSON.stringify(name)}] without serializer hydration; use a target ContractSerializer that registers the matching entity-type factory.`,
-    );
-  }
-  if (isStorageTypeInstance(entry)) {
-    return entry;
+    return toStorageTypeInstance(entry);
   }
   const rawKind = (entry as { kind?: unknown }).kind;
   const kindDescription =
@@ -133,6 +136,6 @@ function normaliseTypeEntry(
       ? 'missing `kind` discriminator'
       : `unrecognised \`kind\` discriminator ${JSON.stringify(rawKind)}`;
   throw new Error(
-    `storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify('codec-instance')} or ${JSON.stringify('postgres-enum')}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`,
+    `storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify('codec-instance')}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`,
   );
 }

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

@@ -19,9 +19,10 @@ import type { StorageTable } from './storage-table';
  * envelope and runtime walk are honest at every layer.
  *
  * The `kind` discriminator is installed as a non-enumerable own property
- * so the JSON envelope reads `{ "id": "__unbound__" }` — symmetric
- * with the family-level non-enumerable `kind` on `SqlNode` and bounded
- * to the minimum data the framework `Namespace` interface promises.
+ * so the JSON envelope reads `{ "id": "__unbound__", "entries": { … } }`
+ * — symmetric with the family-level non-enumerable `kind` on `SqlNode`
+ * and bounded to the minimum data the framework `Namespace` interface
+ * promises.
  *
  * **Freeze-trap warning.** The leaf constructor calls
  * `freezeNode(this)` after installing `kind`. The leaf-class shape
@@ -39,7 +40,9 @@ export class SqlUnboundNamespace extends NamespaceBase {
   static readonly instance: SqlUnboundNamespace = new SqlUnboundNamespace();
 
   readonly id = UNBOUND_NAMESPACE_ID;
-  readonly tables: Readonly<Record<string, StorageTable>> = Object.freeze({});
+  readonly entries: Readonly<{
+    readonly table: Readonly<Record<string, StorageTable>>;
+  }> = Object.freeze({ table: Object.freeze({}) });
   declare readonly kind: string;
 
   private constructor() {
@@ -52,4 +55,8 @@ export class SqlUnboundNamespace extends NamespaceBase {
     });
     freezeNode(this);
   }
+
+  qualifyTable(tableName: string): string {
+    return `"${tableName}"`;
+  }
 }

package/src/ir/storage-column.ts

@@ -1,4 +1,4 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
+import type { ColumnDefault, ControlPolicy, ValueSetRef } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from './sql-node';
 
@@ -19,6 +19,8 @@ export interface StorageColumnInput {
   readonly typeParams?: Record<string, unknown>;
   readonly typeRef?: string;
   readonly default?: ColumnDefault;
+  readonly control?: ControlPolicy;
+  readonly valueSet?: ValueSetRef;
 }
 
 /**
@@ -41,6 +43,8 @@ export class StorageColumn extends SqlNode {
   declare readonly typeParams?: Record<string, unknown>;
   declare readonly typeRef?: string;
   declare readonly default?: ColumnDefault;
+  declare readonly control?: ControlPolicy;
+  declare readonly valueSet?: ValueSetRef;
 
   constructor(input: StorageColumnInput) {
     super();
@@ -50,6 +54,8 @@ export class StorageColumn extends SqlNode {
     if (input.typeParams !== undefined) this.typeParams = input.typeParams;
     if (input.typeRef !== undefined) this.typeRef = input.typeRef;
     if (input.default !== undefined) this.default = input.default;
+    if (input.control !== undefined) this.control = input.control;
+    if (input.valueSet !== undefined) this.valueSet = input.valueSet;
     freezeNode(this);
   }
 }

package/src/ir/storage-table.ts

@@ -1,4 +1,6 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { CheckConstraint, type CheckConstraintInput } from './check-constraint';
 import { ForeignKey, type ForeignKeyInput } from './foreign-key';
 import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
 import { Index, type IndexInput } from './sql-index';
@@ -12,6 +14,8 @@ export interface StorageTableInput {
   readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;
   readonly indexes: ReadonlyArray<Index | IndexInput>;
   readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;
+  readonly control?: ControlPolicy;
+  readonly checks?: ReadonlyArray<CheckConstraint | CheckConstraintInput>;
 }
 
 /**
@@ -32,6 +36,8 @@ export class StorageTable extends SqlNode {
   readonly indexes: ReadonlyArray<Index>;
   readonly foreignKeys: ReadonlyArray<ForeignKey>;
   declare readonly primaryKey?: PrimaryKey;
+  declare readonly control?: ControlPolicy;
+  declare readonly checks?: ReadonlyArray<CheckConstraint>;
 
   constructor(input: StorageTableInput) {
     super();
@@ -56,6 +62,10 @@ export class StorageTable extends SqlNode {
     this.foreignKeys = Object.freeze(
       input.foreignKeys.map((fk) => (fk instanceof ForeignKey ? fk : new ForeignKey(fk))),
     );
+    if (input.control !== undefined) this.control = input.control;
+    if (input.checks !== undefined && input.checks.length > 0) {
+      this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));
+    }
     freezeNode(this);
   }
 }

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

@@ -28,24 +28,26 @@ export interface StorageTypeInstance extends StorageType {
  * Construction-time input for a codec-triple entry. Symmetric with the
  * structural runtime shape minus the `kind` discriminator — callers may
  * omit `kind`; the helper {@link toStorageTypeInstance} stamps it on.
+ * `typeParams` may be omitted on input; the constructor normalises a
+ * missing value to `{}` so the in-memory shape is always present.
  */
 export interface StorageTypeInstanceInput {
   readonly codecId: string;
   readonly nativeType: string;
-  readonly typeParams: Record<string, unknown>;
+  readonly typeParams?: Record<string, unknown>;
 }
 
 /**
  * Stamp the codec-instance `kind` discriminator on a caller-supplied
  * codec triple. Idempotent: input that already carries the discriminator
- * passes through unchanged.
+ * passes through unchanged. Missing `typeParams` is normalised to `{}`.
  */
 export function toStorageTypeInstance(input: StorageTypeInstanceInput): StorageTypeInstance {
   return {
     kind: CODEC_INSTANCE_KIND,
     codecId: input.codecId,
     nativeType: input.nativeType,
-    typeParams: input.typeParams,
+    typeParams: input.typeParams ?? {},
   };
 }
 

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

@@ -0,0 +1,42 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from './sql-node';
+
+/**
+ * Hydration / construction input shape for {@link StorageValueSet}.
+ * Mirrors the on-disk storage JSON envelope so the serializer hydration
+ * walker can hand a validated literal straight to `new`.
+ */
+export interface StorageValueSetInput {
+  readonly kind: 'value-set';
+  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */
+  readonly values: readonly string[];
+}
+
+/**
+ * SQL Contract IR node for a value-set entry in a namespace's `valueSet`
+ * map (`SqlNamespace.entries.valueSet`).
+ *
+ * A value-set records the ordered set of permitted codec-encoded values for
+ * an enum-like column restriction. It does not carry a `codecId` — the
+ * 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
+ * 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
+ * namespace entries needs the discriminator in JSON).
+ *
+ * The entry's name is not on the class — value-sets are keyed by name in
+ * 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[];
+
+  constructor(input: StorageValueSetInput) {
+    super();
+    this.values = Object.freeze([...input.values]);
+    freezeNode(this);
+  }
+}

package/src/referential-action-sql.ts

@@ -0,0 +1,14 @@
+import type { ReferentialAction } from './ir/foreign-key';
+
+/**
+ * Maps each `ReferentialAction` value to the SQL keyword used in ON DELETE /
+ * ON UPDATE clauses. Shared across the migration planner and adapter DDL
+ * renderers — single source of truth for the action → SQL mapping.
+ */
+export const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
+  noAction: 'NO ACTION',
+  restrict: 'RESTRICT',
+  cascade: 'CASCADE',
+  setNull: 'SET NULL',
+  setDefault: 'SET DEFAULT',
+};