@prisma-next/sql-contract 0.14.0-dev.5 → 0.14.0-dev.50

package/dist/{types-B1N8w0I2.d.mts → types-zBvpNCmg.d.mts}

@@ -1,56 +1,7 @@
-import { r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
-import { r as StorageTable } from "./storage-value-set-WnYsIFM8.mjs";
-import { n as SqlNamespaceEntries, r as SqlNamespaceTablesInput, t as SqlNamespace } from "./sql-storage-Dga0jwP2.mjs";
-import { Namespace, NamespaceBase } from "@prisma-next/framework-components/ir";
+import { r as ReferentialAction } from "./foreign-key-DM1UTydh.mjs";
 import { CodecTrait } from "@prisma-next/framework-components/codec";
 import { ControlDriverInstance } from "@prisma-next/framework-components/control";
 
-//#region src/ir/build-sql-namespace.d.ts
-declare function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace;
-declare function buildSqlNamespaceMap(namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>): Readonly<Record<string, SqlNamespace>>;
-//#endregion
-//#region src/ir/sql-unbound-namespace.d.ts
-/**
- * Family-layer placeholder for the SQL unbound-namespace singleton —
- * the late-bound slot whose binding the target resolves at connection
- * time rather than at authoring time.
- *
- * SQL contracts honour the framework `Storage.namespaces` invariant from
- * the moment they appear in the IR. Today `SqlStorage` is family-shared
- * (Postgres + SQLite consume the same class); a per-target namespace
- * concretion (`PostgresSchema.unbound`, `SqliteUnboundDatabase.instance`)
- * earns its existence when each target's namespace shape lands. Until
- * then the family ships a single placeholder singleton so the JSON
- * 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__", "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
- * works today only because `NamespaceBase` does NOT freeze in its
- * constructor — the `Object.defineProperty(this, 'kind', …)` call after
- * `super()` succeeds because the instance is still mutable at that
- * point. Subclasses that add instance fields will still hit the freeze
- * trap once leaf-class `freezeNode(this)` runs; and if a future
- * framework change lifts the freeze to `NamespaceBase`, even the
- * `defineProperty` here would silently fail. To add subclass instance
- * fields safely, lift `freezeNode` to a leaf-class `seal()` hook each
- * leaf calls explicitly at the end of its own constructor.
- */
-declare class SqlUnboundNamespace extends NamespaceBase {
-  static readonly instance: SqlUnboundNamespace;
-  readonly id: "__unbound__";
-  readonly entries: SqlNamespaceEntries;
-  readonly kind: string;
-  private constructor();
-  get table(): Readonly<Record<string, StorageTable>>;
-  qualifyTable(tableName: string): string;
-}
-//#endregion
 //#region src/types.d.ts
 interface SqlControlDriverInstance<T extends string = string> extends ControlDriverInstance<'sql', T> {
   query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<{
@@ -85,13 +36,16 @@ declare function applyFkDefaults(fk: {
   index: boolean;
 };
 type NamespacedFieldTypeMap = Record<string, Record<string, Record<string, unknown>>>;
+type NamespacedStorageColumnTypeMap = Record<string, Record<string, Record<string, unknown>>>;
 type TypeMaps<TCodecTypes extends Record<string, {
   output: unknown;
-}> = Record<string, never>, TQueryOperationTypes extends Record<string, unknown> = Record<string, never>, TFieldOutputTypes extends NamespacedFieldTypeMap = Record<string, never>, TFieldInputTypes extends NamespacedFieldTypeMap = Record<string, never>> = {
+}> = Record<string, never>, TQueryOperationTypes extends Record<string, unknown> = Record<string, never>, TFieldOutputTypes extends NamespacedFieldTypeMap = Record<string, never>, TFieldInputTypes extends NamespacedFieldTypeMap = Record<string, never>, TStorageColumnTypes extends NamespacedStorageColumnTypeMap = Record<string, never>, TStorageColumnInputTypes extends NamespacedStorageColumnTypeMap = Record<string, never>> = {
   readonly codecTypes: TCodecTypes;
   readonly queryOperationTypes: TQueryOperationTypes;
   readonly fieldOutputTypes: TFieldOutputTypes;
   readonly fieldInputTypes: TFieldInputTypes;
+  readonly storageColumnTypes: TStorageColumnTypes;
+  readonly storageColumnInputTypes: TStorageColumnInputTypes;
 };
 type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
   readonly codecTypes: infer C;
@@ -102,15 +56,23 @@ type CodecTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
  * Dispatch hint identifying the first-argument target of an operation.
  *
  * Used by ORM column helpers to decide whether an operation is reachable on a
- * field. Either names a concrete codec identity or a set of capability traits
- * that the field's codec must carry.
+ * field. Names a concrete codec identity, a set of capability traits the
+ * field's codec must carry, or targets list-typed (`many`) fields. Element
+ * capability gating for list ops travels in `elementTraits`.
  */
 type QueryOperationSelfSpec = {
   readonly codecId: string;
   readonly traits?: never;
+  readonly many?: never;
 } | {
   readonly traits: readonly CodecTrait[];
   readonly codecId?: never;
+  readonly many?: never;
+} | {
+  readonly many: true;
+  readonly elementTraits?: readonly CodecTrait[];
+  readonly codecId?: never;
+  readonly traits?: never;
 };
 /**
  * Structural shape an operation's impl must return: any value carrying a
@@ -147,11 +109,19 @@ type FieldOutputTypesOf<T> = [T] extends [never] ? Record<string, never> : T ext
 type FieldInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
   readonly fieldInputTypes: infer F;
 } ? F extends NamespacedFieldTypeMap ? F : Record<string, never> : Record<string, never>;
+type StorageColumnTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly storageColumnTypes: infer F;
+} ? F extends NamespacedStorageColumnTypeMap ? F : Record<string, never> : Record<string, never>;
+type StorageColumnInputTypesOf<T> = [T] extends [never] ? Record<string, never> : T extends {
+  readonly storageColumnInputTypes: infer F;
+} ? F extends NamespacedStorageColumnTypeMap ? F : Record<string, never> : Record<string, never>;
 type ExtractCodecTypes<T> = CodecTypesOf<ExtractTypeMapsFromContract<T>>;
 type ExtractQueryOperationTypes<T> = QueryOperationTypesOf<ExtractTypeMapsFromContract<T>>;
 type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract<T>>;
 type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractStorageColumnTypes<T> = StorageColumnTypesOf<ExtractTypeMapsFromContract<T>>;
+type ExtractStorageColumnInputTypes<T> = StorageColumnInputTypesOf<ExtractTypeMapsFromContract<T>>;
 type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
 //#endregion
-export { TypeMaps as C, buildSqlNamespace as D, SqlUnboundNamespace as E, buildSqlNamespaceMap as O, SqlQueryOperationTypes as S, applyFkDefaults as T, QueryOperationTypesOf as _, ExtractCodecTypes as a, SqlModelFieldStorage as b, ExtractQueryOperationTypes as c, FieldOutputTypesOf as d, ForeignKeyOptions as f, QueryOperationTypesBase as g, QueryOperationTypeEntry as h, DEFAULT_FK_INDEX as i, ExtractTypeMapsFromContract as l, QueryOperationSelfSpec as m, ContractWithTypeMaps as n, ExtractFieldInputTypes as o, QueryOperationReturn as p, DEFAULT_FK_CONSTRAINT as r, ExtractFieldOutputTypes as s, CodecTypesOf as t, FieldInputTypesOf as u, ResolveCodecTypes as v, TypeMapsPhantomKey as w, SqlModelStorage as x, SqlControlDriverInstance as y };
-//# sourceMappingURL=types-B1N8w0I2.d.mts.map
+export { TypeMapsPhantomKey as A, SqlControlDriverInstance as C, StorageColumnInputTypesOf as D, SqlQueryOperationTypes as E, StorageColumnTypesOf as O, ResolveCodecTypes as S, SqlModelStorage as T, QueryOperationReturn as _, ExtractCodecTypes as a, QueryOperationTypesBase as b, ExtractQueryOperationTypes as c, ExtractTypeMapsFromContract as d, FieldInputTypesOf as f, NamespacedStorageColumnTypeMap as g, NamespacedFieldTypeMap as h, DEFAULT_FK_INDEX as i, applyFkDefaults as j, TypeMaps as k, ExtractStorageColumnInputTypes as l, ForeignKeyOptions as m, ContractWithTypeMaps as n, ExtractFieldInputTypes as o, FieldOutputTypesOf as p, DEFAULT_FK_CONSTRAINT as r, ExtractFieldOutputTypes as s, CodecTypesOf as t, ExtractStorageColumnTypes as u, QueryOperationSelfSpec as v, SqlModelFieldStorage as w, QueryOperationTypesOf as x, QueryOperationTypeEntry as y };
+//# sourceMappingURL=types-zBvpNCmg.d.mts.map

package/dist/types-zBvpNCmg.d.mts.map

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

package/dist/types.d.mts

@@ -1,5 +1,13 @@
-import { a as ForeignKeyReferenceInput, i as ForeignKeyReference, n as ForeignKeyInput, o as SqlNode, r as ReferentialAction, t as ForeignKey } from "./foreign-key-BATxB95l.mjs";
-import { a as UniqueConstraint, c as StorageColumnInput, d as PrimaryKey, f as PrimaryKeyInput, i as StorageTableInput, l as Index, m as CheckConstraintInput, n as StorageValueSetInput, o as UniqueConstraintInput, p as CheckConstraint, r as StorageTable, s as StorageColumn, t as StorageValueSet, u as IndexInput } from "./storage-value-set-WnYsIFM8.mjs";
-import { a as SqlStorageInput, c as StorageTypeInstance, d as toStorageTypeInstance, i as SqlStorage, l as StorageTypeInstanceInput, n as SqlNamespaceEntries, o as SqlStorageTypeEntry, r as SqlNamespaceTablesInput, s as CODEC_INSTANCE_KIND, t as SqlNamespace, u as isStorageTypeInstance } from "./sql-storage-Dga0jwP2.mjs";
-import { C as TypeMaps, D as buildSqlNamespace, E as SqlUnboundNamespace, O as buildSqlNamespaceMap, S as SqlQueryOperationTypes, T as applyFkDefaults, _ as QueryOperationTypesOf, a as ExtractCodecTypes, b as SqlModelFieldStorage, c as ExtractQueryOperationTypes, d as FieldOutputTypesOf, f as ForeignKeyOptions, g as QueryOperationTypesBase, h as QueryOperationTypeEntry, i as DEFAULT_FK_INDEX, l as ExtractTypeMapsFromContract, m as QueryOperationSelfSpec, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as QueryOperationReturn, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, u as FieldInputTypesOf, v as ResolveCodecTypes, w as TypeMapsPhantomKey, x as SqlModelStorage, y as SqlControlDriverInstance } from "./types-B1N8w0I2.mjs";
-export { CODEC_INSTANCE_KIND, CheckConstraint, type CheckConstraintInput, type CodecTypesOf, type ContractWithTypeMaps, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, type ExtractCodecTypes, type ExtractFieldInputTypes, type ExtractFieldOutputTypes, type ExtractQueryOperationTypes, type ExtractTypeMapsFromContract, type FieldInputTypesOf, type FieldOutputTypesOf, ForeignKey, type ForeignKeyInput, type ForeignKeyOptions, ForeignKeyReference, type ForeignKeyReferenceInput, Index, type IndexInput, PrimaryKey, type PrimaryKeyInput, type QueryOperationReturn, type QueryOperationSelfSpec, type QueryOperationTypeEntry, type QueryOperationTypesBase, type QueryOperationTypesOf, type ReferentialAction, type ResolveCodecTypes, type SqlControlDriverInstance, type SqlModelFieldStorage, type SqlModelStorage, type SqlNamespace, type SqlNamespaceEntries, type SqlNamespaceTablesInput, SqlNode, type SqlQueryOperationTypes, SqlStorage, type SqlStorageInput, type SqlStorageTypeEntry, SqlUnboundNamespace, StorageColumn, type StorageColumnInput, StorageTable, type StorageTableInput, type StorageTypeInstance, type StorageTypeInstanceInput, StorageValueSet, type StorageValueSetInput, type TypeMaps, type TypeMapsPhantomKey, UniqueConstraint, type UniqueConstraintInput, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isStorageTypeInstance, toStorageTypeInstance };
+import { t as SqlNode } from "./sql-node-V214WXQD.mjs";
+import { a as StorageColumn, c as IndexInput, d as CheckConstraint, f as CheckConstraintInput, i as UniqueConstraintInput, l as PrimaryKey, n as StorageTableInput, o as StorageColumnInput, r as UniqueConstraint, s as Index, t as StorageTable, u as PrimaryKeyInput } from "./storage-table-Bj1ZN1P7.mjs";
+import { a as ForeignKeyReferenceInput, i as ForeignKeyReference, n as ForeignKeyInput, r as ReferentialAction, t as ForeignKey } from "./foreign-key-DM1UTydh.mjs";
+import { a as SqlNamespaceFactory, c as SqlStorageInput, d as isSqlAuthoringContributions, f as CODEC_INSTANCE_KIND, g as toStorageTypeInstance, h as isStorageTypeInstance, i as SqlNamespaceEntries, l as SqlStorageTypeEntry, m as StorageTypeInstanceInput, n as SqlNamespace, o as SqlNamespaceInput, p as StorageTypeInstance, r as SqlNamespaceBase, s as SqlStorage, t as SqlAuthoringContributions, u as isMaterializedSqlNamespace } from "./sql-storage-BRB55sCP.mjs";
+import { n as StorageValueSetInput, r as isStorageValueSet, t as StorageValueSet } from "./storage-value-set-D-jww77l.mjs";
+import { A as TypeMapsPhantomKey, C as SqlControlDriverInstance, D as StorageColumnInputTypesOf, E as SqlQueryOperationTypes, O as StorageColumnTypesOf, S as ResolveCodecTypes, T as SqlModelStorage, _ as QueryOperationReturn, a as ExtractCodecTypes, b as QueryOperationTypesBase, c as ExtractQueryOperationTypes, d as ExtractTypeMapsFromContract, f as FieldInputTypesOf, g as NamespacedStorageColumnTypeMap, h as NamespacedFieldTypeMap, i as DEFAULT_FK_INDEX, j as applyFkDefaults, k as TypeMaps, l as ExtractStorageColumnInputTypes, m as ForeignKeyOptions, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as FieldOutputTypesOf, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, u as ExtractStorageColumnTypes, v as QueryOperationSelfSpec, w as SqlModelFieldStorage, x as QueryOperationTypesOf, y as QueryOperationTypeEntry } from "./types-zBvpNCmg.mjs";
+
+//#region src/column-type-resolution.d.ts
+type StorageColumnMapAt<SCT, NsId extends string, TableName extends string> = string extends keyof SCT ? never : NsId extends keyof SCT ? string extends keyof SCT[NsId] ? never : TableName extends keyof SCT[NsId] ? SCT[NsId][TableName] : never : never;
+type StorageColumnTypeAcrossNamespaces<SCT, TableName extends string, ColumnName extends string> = { [Ns in keyof SCT]: TableName extends keyof SCT[Ns] ? ColumnName extends keyof SCT[Ns][TableName] ? SCT[Ns][TableName][ColumnName] : never : never }[keyof SCT];
+//#endregion
+export { CODEC_INSTANCE_KIND, CheckConstraint, type CheckConstraintInput, type CodecTypesOf, type ContractWithTypeMaps, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, type ExtractCodecTypes, type ExtractFieldInputTypes, type ExtractFieldOutputTypes, type ExtractQueryOperationTypes, type ExtractStorageColumnInputTypes, type ExtractStorageColumnTypes, type ExtractTypeMapsFromContract, type FieldInputTypesOf, type FieldOutputTypesOf, ForeignKey, type ForeignKeyInput, type ForeignKeyOptions, ForeignKeyReference, type ForeignKeyReferenceInput, Index, type IndexInput, type NamespacedFieldTypeMap, type NamespacedStorageColumnTypeMap, PrimaryKey, type PrimaryKeyInput, type QueryOperationReturn, type QueryOperationSelfSpec, type QueryOperationTypeEntry, type QueryOperationTypesBase, type QueryOperationTypesOf, type ReferentialAction, type ResolveCodecTypes, type SqlAuthoringContributions, type SqlControlDriverInstance, type SqlModelFieldStorage, type SqlModelStorage, type SqlNamespace, SqlNamespaceBase, type SqlNamespaceEntries, type SqlNamespaceFactory, type SqlNamespaceInput, SqlNode, type SqlQueryOperationTypes, SqlStorage, type SqlStorageInput, type SqlStorageTypeEntry, StorageColumn, type StorageColumnInput, type StorageColumnInputTypesOf, type StorageColumnMapAt, type StorageColumnTypeAcrossNamespaces, type StorageColumnTypesOf, StorageTable, type StorageTableInput, type StorageTypeInstance, type StorageTypeInstanceInput, StorageValueSet, type StorageValueSetInput, type TypeMaps, type TypeMapsPhantomKey, UniqueConstraint, type UniqueConstraintInput, applyFkDefaults, isMaterializedSqlNamespace, isSqlAuthoringContributions, isStorageTypeInstance, isStorageValueSet, toStorageTypeInstance };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/column-type-resolution.ts"],"mappings":";;;;;;;;KACY,kBAAA,4EAIa,GAAA,WAErB,IAAA,eAAmB,GAAA,wBACI,GAAA,CAAI,IAAA,YAEvB,SAAA,eAAwB,GAAA,CAAI,IAAA,IAC1B,GAAA,CAAI,IAAA,EAAM,SAAA;AAAA,KAIR,iCAAA,4EAKG,GAAA,GAAM,SAAA,eAAwB,GAAA,CAAI,EAAA,IAC3C,UAAA,eAAyB,GAAA,CAAI,EAAA,EAAI,SAAA,IAC/B,GAAA,CAAI,EAAA,EAAI,SAAA,EAAW,UAAA,0BAGnB,GAAA"}

package/dist/types.mjs

@@ -1,3 +1,3 @@
-import { a as StorageTable, c as Index, d as ForeignKeyReference, f as CheckConstraint, i as StorageValueSet, l as PrimaryKey, o as UniqueConstraint, p as SqlNode, s as StorageColumn, u as ForeignKey } from "./entity-kinds-Cl36zL5j.mjs";
-import { a as CODEC_INSTANCE_KIND, c as buildSqlNamespace, i as SqlStorage, l as buildSqlNamespaceMap, n as DEFAULT_FK_INDEX, o as isStorageTypeInstance, r as applyFkDefaults, s as toStorageTypeInstance, t as DEFAULT_FK_CONSTRAINT, u as SqlUnboundNamespace } from "./types-B-eiQXff.mjs";
-export { CODEC_INSTANCE_KIND, CheckConstraint, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, PrimaryKey, SqlNode, SqlStorage, SqlUnboundNamespace, StorageColumn, StorageTable, StorageValueSet, UniqueConstraint, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isStorageTypeInstance, toStorageTypeInstance };
+import { a as StorageColumn, c as ForeignKey, d as SqlNode, i as UniqueConstraint, l as ForeignKeyReference, n as isStorageValueSet, o as Index, r as StorageTable, s as PrimaryKey, t as StorageValueSet, u as CheckConstraint } from "./storage-value-set-C4XInPlX.mjs";
+import { a as SqlStorage, c as CODEC_INSTANCE_KIND, i as SqlNamespaceBase, l as isStorageTypeInstance, n as DEFAULT_FK_INDEX, o as isMaterializedSqlNamespace, r as applyFkDefaults, s as isSqlAuthoringContributions, t as DEFAULT_FK_CONSTRAINT, u as toStorageTypeInstance } from "./types-KiOT4SAV.mjs";
+export { CODEC_INSTANCE_KIND, CheckConstraint, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, PrimaryKey, SqlNamespaceBase, SqlNode, SqlStorage, StorageColumn, StorageTable, StorageValueSet, UniqueConstraint, applyFkDefaults, isMaterializedSqlNamespace, isSqlAuthoringContributions, isStorageTypeInstance, isStorageValueSet, toStorageTypeInstance };

package/dist/validators.d.mts

@@ -1,8 +1,8 @@
-import { n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
-import { f as PrimaryKeyInput, o as UniqueConstraintInput } from "./storage-value-set-WnYsIFM8.mjs";
-import { i as SqlStorage } from "./sql-storage-Dga0jwP2.mjs";
-import { Type } from "arktype";
+import { i as UniqueConstraintInput, u as PrimaryKeyInput } from "./storage-table-Bj1ZN1P7.mjs";
+import { n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-DM1UTydh.mjs";
+import { s as SqlStorage } from "./sql-storage-BRB55sCP.mjs";
 import { AnyEntityKindDescriptor } from "@prisma-next/framework-components/ir";
+import { Type } from "arktype";
 import { Contract } from "@prisma-next/contract/types";
 
 //#region src/ir/storage-entry-schemas.d.ts
@@ -62,6 +62,7 @@ declare const StorageTableSchema: import("arktype/internal/variants/object.ts").
       nativeType: string;
       codecId: string;
       nullable: boolean;
+      many?: boolean;
       typeParams?: Record<string, unknown>;
       typeRef?: string;
       default?: ColumnDefaultLiteral | ColumnDefaultFunction;
@@ -133,13 +134,15 @@ declare function createSqlStorageSchema(kinds: ReadonlyMap<string, AnyEntityKind
  */
 declare function createSqlContractSchema(kinds: ReadonlyMap<string, AnyEntityKindDescriptor>): Type<unknown>;
 /**
- * Validates the structural shape of SqlStorage using Arktype.
+ * Validates the structural shape of SqlStorage using Arktype. Pure
+ * structural check: namespace IR is never materialized here (that needs
+ * a target concretion via the serializer hydration path), so this throws
+ * on invalid input and constructs nothing.
  *
  * @param value - The storage value to validate
- * @returns The validated storage if structure is valid
  * @throws Error if the storage structure is invalid
  */
-declare function validateStorage(value: unknown): SqlStorage;
+declare function validateStorage(value: unknown): void;
 declare function validateModel(value: unknown): unknown;
 /**
  * Validates semantic constraints on SqlStorage that cannot be expressed in Arktype schemas.

package/dist/validators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/validators.ts"],"mappings":";;;;;;;;KAMK,oBAAA;EAAA,SACM,IAAA;EAAA,SACA,KAAA,8BAAmC,MAAM;AAAA;AAAA,KAE/C,qBAAA;EAAA,SAAmC,IAAA;EAAA,SAA2B,UAAU;AAAA;AAAA,cAMhE,0BAAA,gDAA0B,UAAA,CAAA,oBAAA;AAAA,cAK1B,2BAAA,gDAA2B,UAAA,CAAA,qBAAA;AAAA,cAK3B,mBAAA,gDAAmB,UAAA,CAAA,oBAAA,GAAA,qBAAA;;;;AAlBoB;AAAA;cAkDvC,qBAAA,gDAAqB,UAAA;;gDAKhC,MAAA;AAAA;AAAA,cAYW,WAAA,gDAAW,UAAA;;;;YAKtB,MAAA;AAAA;AAAA,cAEW,yBAAA,gDAAyB,UAAA;;;;;;cAQzB,sBAAA,gDAAsB,UAAA;;;;;cAOtB,uBAAA,gDAAuB,UAAA,CAAA,iBAAA;AAAA,cAIvB,gBAAA,gDAAgB,UAAA,CAAA,eAAA;AAAA,cAUhB,qBAAA,gDAAqB,UAAA;;;;;;;;;;;cAOrB,kBAAA,gDAAkB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCXlB,kBAAA,gDAAkB,UAAA;;;;mDAS7B,MAAA;EAAA;AAAA;;AD5GkD;AAAA;;;;AAEyB;AAM7E;iBC0HgB,0BAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;;;AD5HoC;AAKvC;;;iBCmKgB,sBAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;ADrKqC;AAKxC;;;;AALwC,iBC8TxB,uBAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;;;;AD3T6B;AAgChC;;;iBCqUgB,eAAA,CAAgB,KAAA,YAAiB,UAAU;AAAA,iBA4B3C,aAAA,CAAc,KAAc;;;;;;ADhV5C;;;;;;;;iBC8YgB,wBAAA,CAAyB,OAAmB,EAAV,UAAU;;;;ADvY5D;;;iBC4iBgB,8BAAA,CAA+B,QAAA,EAAU,QAAQ,CAAC,UAAA;;;;;;;iBA4DlD,6BAAA,CAA8B,QAAA,EAAU,QAAQ,CAAC,UAAA;AAAA,UAwGhD,+BAAA;EDnsB0B;;;;;;;;EAAA,SC4sBhC,cAAA,GAAiB,IAAI;AAAA;;;;AD1sBI;AAIpC;;;;iBCitBgB,wBAAA,WAAmC,QAAA,CAAS,UAAA,GAC1D,KAAA,WACA,OAAA,GAAU,+BAAA,GACT,CAAA"}
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/validators.ts"],"mappings":";;;;;;;;KAMK,oBAAA;EAAA,SACM,IAAA;EAAA,SACA,KAAA,8BAAmC,MAAM;AAAA;AAAA,KAE/C,qBAAA;EAAA,SAAmC,IAAA;EAAA,SAA2B,UAAU;AAAA;AAAA,cAMhE,0BAAA,gDAA0B,UAAA,CAAA,oBAAA;AAAA,cAK1B,2BAAA,gDAA2B,UAAA,CAAA,qBAAA;AAAA,cAK3B,mBAAA,gDAAmB,UAAA,CAAA,oBAAA,GAAA,qBAAA;;;;AAlBoB;AAAA;cAmDvC,qBAAA,gDAAqB,UAAA;;gDAKhC,MAAA;AAAA;AAAA,cAYW,WAAA,gDAAW,UAAA;;;;YAKtB,MAAA;AAAA;AAAA,cAEW,yBAAA,gDAAyB,UAAA;;;;;;cAQzB,sBAAA,gDAAsB,UAAA;;;;;cAOtB,uBAAA,gDAAuB,UAAA,CAAA,iBAAA;AAAA,cAIvB,gBAAA,gDAAgB,UAAA,CAAA,eAAA;AAAA,cAUhB,qBAAA,gDAAqB,UAAA;;;;;;;;;;;cAOrB,kBAAA,gDAAkB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCflB,kBAAA,gDAAkB,UAAA;;;;mDAS7B,MAAA;EAAA;AAAA;;ADzGkD;AAAA;;;;AAEyB;AAM7E;iBCuHgB,0BAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;;;ADzHoC;AAKvC;;;iBCgKgB,sBAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;ADlKqC;AAKxC;;;;AALwC,iBC0TxB,uBAAA,CACd,KAAA,EAAO,WAAA,SAAoB,uBAAA,IAC1B,IAAA;;;;ADvT6B;AAiChC;;;;;iBC4TgB,eAAA,CAAgB,KAAc;AAAA,iBAQ9B,aAAA,CAAc,KAAc;;;;ADnT5C;;;;;;;;;;iBCiXgB,wBAAA,CAAyB,OAAmB,EAAV,UAAU;;AD1W5D;;;;;iBC+gBgB,8BAAA,CAA+B,QAAA,EAAU,QAAQ,CAAC,UAAA;;;;;;ADvgBlE;iBCmkBgB,6BAAA,CAA8B,QAAA,EAAU,QAAQ,CAAC,UAAA;AAAA,UAwGhD,+BAAA;EDtqB0B;;;;;;;AAE3C;EAF2C,SC+qBhC,cAAA,GAAiB,IAAI;AAAA;;AD7qBI;AAIpC;;;;AAA6B;AAU7B;iBC0qBgB,wBAAA,WAAmC,QAAA,CAAS,UAAA,GAC1D,KAAA,WACA,OAAA,GAAU,+BAAA,GACT,CAAA"}

package/dist/validators.mjs

@@ -1,11 +1,10 @@
-import { C as StorageTableSchema, S as ReferentialActionSchema, _ as ColumnDefaultSchema, b as ForeignKeySourceSchema, g as ColumnDefaultLiteralSchema, h as ColumnDefaultFunctionSchema, m as CheckConstraintSchema, t as composeSqlEntityKinds, v as ForeignKeyReferenceSchema, w as StorageValueSetSchema, x as IndexSchema, y as ForeignKeySchema } from "./entity-kinds-Cl36zL5j.mjs";
-import { i as SqlStorage, l as buildSqlNamespaceMap, u as SqlUnboundNamespace } from "./types-B-eiQXff.mjs";
+import { a as ColumnDefaultFunctionSchema, c as ForeignKeyReferenceSchema, d as IndexSchema, f as ReferentialActionSchema, i as CheckConstraintSchema, l as ForeignKeySchema, m as StorageValueSetSchema, o as ColumnDefaultLiteralSchema, p as StorageTableSchema, s as ColumnDefaultSchema, t as composeSqlEntityKinds, u as ForeignKeySourceSchema } from "./entity-kinds-CHiydmat.mjs";
+import { isPlainRecord } from "@prisma-next/framework-components/ir";
 import { type } from "arktype";
-import { UNBOUND_NAMESPACE_ID, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { CrossReferenceSchema } from "@prisma-next/contract/types";
-import { blindCast } from "@prisma-next/utils/casts";
 import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 import { validateContractDomain } from "@prisma-next/contract/validate-domain";
+import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 //#region src/validators.ts
 const generatorKindSchema = type("'generator'");
@@ -236,10 +235,12 @@ function createSqlContractSchema(kinds) {
 }
 const SqlContractSchema = createSqlContractSchema(DEFAULT_SQL_KINDS);
 /**
-* Validates the structural shape of SqlStorage using Arktype.
+* Validates the structural shape of SqlStorage using Arktype. Pure
+* structural check: namespace IR is never materialized here (that needs
+* a target concretion via the serializer hydration path), so this throws
+* on invalid input and constructs nothing.
 *
 * @param value - The storage value to validate
-* @returns The validated storage if structure is valid
 * @throws Error if the storage structure is invalid
 */
 function validateStorage(value) {
@@ -248,17 +249,6 @@ function validateStorage(value) {
 		const messages = result.map((p) => p.message).join("; ");
 		throw new Error(`Storage validation failed: ${messages}`);
 	}
-	const validated = blindCast(result);
-	const namespaces = buildSqlNamespaceMap(validated.namespaces ?? {});
-	const unbound = namespaces[UNBOUND_NAMESPACE_ID] ?? SqlUnboundNamespace.instance;
-	return new SqlStorage({
-		storageHash: validated.storageHash,
-		...ifDefined("types", validated.types),
-		namespaces: {
-			...namespaces,
-			[UNBOUND_NAMESPACE_ID]: unbound
-		}
-	});
 }
 function validateModel(value) {
 	const result = ModelSchema(value);
@@ -463,8 +453,110 @@ function validateSqlContractFully(value, options) {
 	const semanticErrors = validateStorageSemantics(validated.storage);
 	if (semanticErrors.length > 0) throw new ContractValidationError(`Contract semantic validation failed: ${semanticErrors.join("; ")}`, "storage");
 	validateModelStorageReferences(validated);
+	validateRelationThroughConsistency(validated);
 	return validated;
 }
+/** Storage column lookup for through-consistency validation. */
+function lookupStorageColumn(contract, namespaceId, tableName, columnName) {
+	const rawTable = contract.storage.namespaces[namespaceId]?.entries.table?.[tableName];
+	if (rawTable === void 0) return;
+	return blindCast(rawTable).columns[columnName];
+}
+/**
+* Two storage columns share a type when their `nativeType` and `typeParams`
+* match. The contract is canonicalized, so `typeParams` key order is stable and
+* a JSON comparison is exact. `codecId` and `nullable` are intentionally not
+* compared: they do not change the database-level type that governs a join.
+*/
+function sameStorageType(a, b) {
+	return a.nativeType === b.nativeType && JSON.stringify(a.typeParams ?? null) === JSON.stringify(b.typeParams ?? null);
+}
+function describeColumnType(column) {
+	return column.typeParams === void 0 ? column.nativeType : `${column.nativeType} ${JSON.stringify(column.typeParams)}`;
+}
+/**
+* Validates one side of an N:M join: the junction columns and the model
+* columns they pair against positionally must be equal in number, exist in
+* their tables, and share the same storage type (`nativeType` + `typeParams`).
+* The junction's storage foreign keys already guarantee this for user-declared
+* FK constraints, but `through` is a logical descriptor never tied to them by
+* the rest of validation — and the TS builder accepts explicit join columns
+* without requiring a junction FK at all — so this checks the columns directly
+* against storage, one path regardless of how the junction was authored.
+*
+* Joined columns must be the *same* storage type, not merely compatible:
+* relying on implicit conversion (e.g. `text`↔`character`) is unsafe on writes
+* — `character(n)` space-padding makes such coercions non-associative — and no
+* ADR sanctions heterogeneous junction columns. Equality is the conservative
+* default; it can be relaxed deliberately if a real use case ever appears.
+*/
+function validateThroughJoinSide(input) {
+	const fail = (detail) => new ContractValidationError(`Many-to-many relation "${input.qualifiedName}" ${detail}`, "storage");
+	if (input.junctionColumns.length !== input.modelColumns.length) throw fail(`pairs ${input.junctionColumnsLabel} (${input.junctionColumns.length}) with ${input.modelColumnsLabel} (${input.modelColumns.length}) of differing length; they join positionally and must match.`);
+	for (const [index, junctionColumnName] of input.junctionColumns.entries()) {
+		const modelColumnRef = input.modelColumns[index];
+		if (modelColumnRef === void 0) continue;
+		const junctionColumn = lookupStorageColumn(input.contract, input.junctionNamespaceId, input.junctionTable, junctionColumnName);
+		if (junctionColumn === void 0) throw fail(`${input.junctionColumnsLabel} references column "${junctionColumnName}" absent from junction table "${input.junctionNamespaceId}.${input.junctionTable}".`);
+		const model = input.model;
+		if (model === void 0) continue;
+		let modelColumnName = modelColumnRef;
+		if (model.fieldToColumn !== void 0) {
+			const mapped = model.fieldToColumn[modelColumnRef];
+			if (mapped === void 0) throw fail(`${input.modelColumnsLabel} references field "${modelColumnRef}" absent from model on table "${model.namespaceId}.${model.table}".`);
+			modelColumnName = mapped.column;
+		}
+		const modelColumn = lookupStorageColumn(input.contract, model.namespaceId, model.table, modelColumnName);
+		if (modelColumn === void 0) throw fail(`${input.modelColumnsLabel} references column "${modelColumnName}" absent from table "${model.namespaceId}.${model.table}".`);
+		if (!sameStorageType(junctionColumn, modelColumn)) throw fail(`joins "${input.junctionTable}.${junctionColumnName}" (${describeColumnType(junctionColumn)}) with "${model.table}.${modelColumnName}" (${describeColumnType(modelColumn)}) of differing storage type; junction columns must match the type of the column they reference.`);
+	}
+}
+/**
+* Validates that every N:M relation's `through` descriptor is consistent with
+* the storage columns it joins: both join sides match in column count,
+* reference columns that exist in their tables, and pair columns of the same
+* storage type. Without this, a `through` that disagrees with storage surfaces
+* as a silently wrong JOIN at query time rather than a validation error here.
+*/
+function validateRelationThroughConsistency(contract) {
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespace.models)) for (const [relationName, relation] of Object.entries(model.relations)) {
+		if (relation.cardinality !== "N:M") continue;
+		const qualifiedName = `${namespaceId}.${modelName}.${relationName}`;
+		const { on, through } = relation;
+		const modelStorage = blindCast(model.storage);
+		validateThroughJoinSide({
+			contract,
+			qualifiedName,
+			modelColumns: on.localFields,
+			modelColumnsLabel: "on.localFields",
+			model: {
+				namespaceId,
+				table: modelStorage.table,
+				fieldToColumn: modelStorage.fields
+			},
+			junctionColumns: through.parentColumns,
+			junctionColumnsLabel: "through.parentColumns",
+			junctionNamespaceId: through.namespaceId,
+			junctionTable: through.table
+		});
+		const targetModel = relation.to.space === void 0 ? contract.domain.namespaces[relation.to.namespace]?.models[relation.to.model] : void 0;
+		const targetModelSide = targetModel === void 0 ? void 0 : {
+			namespaceId: relation.to.namespace,
+			table: blindCast(targetModel.storage).table
+		};
+		validateThroughJoinSide({
+			contract,
+			qualifiedName,
+			modelColumns: through.targetColumns,
+			modelColumnsLabel: "through.targetColumns",
+			...ifDefined("model", targetModelSide),
+			junctionColumns: through.childColumns,
+			junctionColumnsLabel: "through.childColumns",
+			junctionNamespaceId: through.namespaceId,
+			junctionTable: through.table
+		});
+	}
+}
 //#endregion
 export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, ReferentialActionSchema, StorageTableSchema, StorageValueSetSchema, createNamespaceEntrySchema, createSqlContractSchema, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };