@prisma-next/sql-contract 0.13.0-dev.3 → 0.13.0-dev.31

package/dist/{types-DEnWD3xB.d.mts → types-CFpK1iC5.d.mts}

@@ -1,7 +1,6 @@
 import { r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
-import { m as StorageTable, n as SqlNamespaceTablesInput, t as SqlNamespace } from "./sql-storage-CXf9xjAL.mjs";
-import { Namespace, NamespaceBase, StorageType } from "@prisma-next/framework-components/ir";
-import { ControlPolicy } from "@prisma-next/contract/types";
+import { m as StorageTable, n as SqlNamespaceEntries, r as SqlNamespaceTablesInput, t as SqlNamespace } from "./sql-storage-BCLmt-nS.mjs";
+import { Namespace, NamespaceBase } from "@prisma-next/framework-components/ir";
 import { CodecTrait } from "@prisma-next/framework-components/codec";
 import { ControlDriverInstance } from "@prisma-next/framework-components/control";
 
@@ -9,57 +8,6 @@ import { ControlDriverInstance } from "@prisma-next/framework-components/control
 declare function buildSqlNamespace(input: SqlNamespaceTablesInput): SqlNamespace;
 declare function buildSqlNamespaceMap(namespaces: Readonly<Record<string, Namespace | SqlNamespaceTablesInput>>): Readonly<Record<string, SqlNamespace>>;
 //#endregion
-//#region src/ir/postgres-enum-storage-entry.d.ts
-/**
- * Discriminator literal for the Postgres-enum variant on the polymorphic
- * `SqlStorage.types` slot.
- *
- * Enums are a target-level concept: Postgres ships native
- * `CREATE TYPE … AS ENUM` while other SQL targets approximate enums via
- * constraints. The literal lives at the SQL family layer because every
- * SQL-family consumer (verifier, planner, lowering, …) needs to
- * discriminate enum-typed slot entries from codec-typed ones. The
- * concrete IR class (`PostgresEnumType`) lives in the target-postgres
- * package and implements this structural contract; cross-domain
- * layering rules forbid the SQL family from importing the concrete
- * target class directly, so the discriminator and structural interface
- * carry the dispatch.
- */
-declare const POSTGRES_ENUM_KIND: "postgres-enum";
-/**
- * Structural contract every Postgres-enum slot entry honours — both
- * the live `PostgresEnumType` IR-class instance and the raw JSON
- * envelope shape that survives `JSON.stringify` round-trips. SQL
- * family-layer dispatch narrows polymorphic `StorageType` slot
- * entries to this shape via `isPostgresEnumStorageEntry`.
- *
- * The `codecBinding` field is accessor-shaped (live class instance) on
- * the IR class and undefined on the raw JSON envelope; consumers that
- * need it must guard for its presence (the JSON path synthesises an
- * equivalent shape from `codecId` + `values`).
- */
-interface PostgresEnumStorageEntry extends StorageType {
-  readonly kind: typeof POSTGRES_ENUM_KIND;
-  readonly name: string;
-  readonly nativeType: string;
-  readonly values: readonly string[];
-  /**
-   * Enumerable own property on the persisted JSON envelope; the live
-   * IR-class instance carries it too. Family-shared dispatch sites
-   * read `codecId` directly rather than going through the IR-class
-   * `codecBinding` accessor (which lives on the prototype and isn't
-   * present on raw JSON envelopes).
-   */
-  readonly codecId: string;
-  readonly control?: ControlPolicy;
-}
-/**
- * Narrow a polymorphic `StorageType` entry to the Postgres-enum shape
- * via its enumerable `kind` discriminator. Type guard returns true for
- * both live `PostgresEnumType` instances and raw JSON envelopes.
- */
-declare function isPostgresEnumStorageEntry(value: unknown): value is PostgresEnumStorageEntry;
-//#endregion
 //#region src/ir/sql-unbound-namespace.d.ts
 /**
  * Family-layer placeholder for the SQL unbound-namespace singleton —
@@ -95,11 +43,10 @@ declare function isPostgresEnumStorageEntry(value: unknown): value is PostgresEn
 declare class SqlUnboundNamespace extends NamespaceBase {
   static readonly instance: SqlUnboundNamespace;
   readonly id: "__unbound__";
-  readonly entries: Readonly<{
-    readonly table: Readonly<Record<string, StorageTable>>;
-  }>;
+  readonly entries: SqlNamespaceEntries;
   readonly kind: string;
   private constructor();
+  get table(): Readonly<Record<string, StorageTable>>;
   qualifyTable(tableName: string): string;
 }
 //#endregion
@@ -204,5 +151,5 @@ type ExtractFieldOutputTypes<T> = FieldOutputTypesOf<ExtractTypeMapsFromContract
 type ExtractFieldInputTypes<T> = FieldInputTypesOf<ExtractTypeMapsFromContract<T>>;
 type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
 //#endregion
-export { buildSqlNamespace as A, TypeMaps as C, POSTGRES_ENUM_KIND as D, SqlUnboundNamespace as E, PostgresEnumStorageEntry 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, buildSqlNamespaceMap as j, isPostgresEnumStorageEntry as k, 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-DEnWD3xB.d.mts.map
+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-CFpK1iC5.d.mts.map

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

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

package/dist/types.d.mts

@@ -1,4 +1,4 @@
 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 { C as PrimaryKeyInput, S as PrimaryKey, T as CheckConstraintInput, _ as UniqueConstraintInput, a as SqlStorageTypeEntry, b as Index, c as StorageValueSetInput, d as StorageTypeInstanceInput, f as isStorageTypeInstance, g as UniqueConstraint, h as StorageTableInput, i as SqlStorageInput, l as CODEC_INSTANCE_KIND, m as StorageTable, n as SqlNamespaceTablesInput, o as storageTableAt, p as toStorageTypeInstance, r as SqlStorage, s as StorageValueSet, u as StorageTypeInstance, v as StorageColumn, w as CheckConstraint, x as IndexInput, y as StorageColumnInput } from "./sql-storage-CXf9xjAL.mjs";
-import { A as buildSqlNamespace, C as TypeMaps, D as POSTGRES_ENUM_KIND, E as SqlUnboundNamespace, O as PostgresEnumStorageEntry, 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, j as buildSqlNamespaceMap, k as isPostgresEnumStorageEntry, 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-DEnWD3xB.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, POSTGRES_ENUM_KIND, type PostgresEnumStorageEntry, PrimaryKey, type PrimaryKeyInput, type QueryOperationReturn, type QueryOperationSelfSpec, type QueryOperationTypeEntry, type QueryOperationTypesBase, type QueryOperationTypesOf, type ReferentialAction, type ResolveCodecTypes, type SqlControlDriverInstance, type SqlModelFieldStorage, type SqlModelStorage, 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, isPostgresEnumStorageEntry, isStorageTypeInstance, storageTableAt, toStorageTypeInstance };
+import { C as PrimaryKeyInput, S as PrimaryKey, T as CheckConstraintInput, _ as UniqueConstraintInput, a as SqlStorageInput, b as Index, c as StorageValueSetInput, d as StorageTypeInstanceInput, f as isStorageTypeInstance, g as UniqueConstraint, h as StorageTableInput, i as SqlStorage, l as CODEC_INSTANCE_KIND, m as StorageTable, n as SqlNamespaceEntries, o as SqlStorageTypeEntry, p as toStorageTypeInstance, r as SqlNamespaceTablesInput, s as StorageValueSet, t as SqlNamespace, u as StorageTypeInstance, v as StorageColumn, w as CheckConstraint, x as IndexInput, y as StorageColumnInput } from "./sql-storage-BCLmt-nS.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-CFpK1iC5.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 };

package/dist/types.mjs

@@ -1,2 +1,2 @@
-import { C as SqlUnboundNamespace, S as SqlNode, _ as Index, a as storageTableAt, b as ForeignKeyReference, c as toStorageTypeInstance, d as buildSqlNamespace, f as buildSqlNamespaceMap, g as StorageColumn, h as UniqueConstraint, i as SqlStorage, l as POSTGRES_ENUM_KIND, m as StorageTable, n as DEFAULT_FK_INDEX, o as CODEC_INSTANCE_KIND, p as StorageValueSet, r as applyFkDefaults, s as isStorageTypeInstance, t as DEFAULT_FK_CONSTRAINT, u as isPostgresEnumStorageEntry, v as PrimaryKey, x as CheckConstraint, y as ForeignKey } from "./types-DqhaAjCH.mjs";
-export { CODEC_INSTANCE_KIND, CheckConstraint, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, POSTGRES_ENUM_KIND, PrimaryKey, SqlNode, SqlStorage, SqlUnboundNamespace, StorageColumn, StorageTable, StorageValueSet, UniqueConstraint, applyFkDefaults, buildSqlNamespace, buildSqlNamespaceMap, isPostgresEnumStorageEntry, isStorageTypeInstance, storageTableAt, toStorageTypeInstance };
+import { _ as ForeignKeyReference, a as CODEC_INSTANCE_KIND, b as SqlUnboundNamespace, c as buildSqlNamespace, d as StorageTable, f as UniqueConstraint, g as ForeignKey, h as PrimaryKey, i as SqlStorage, l as buildSqlNamespaceMap, m as Index, n as DEFAULT_FK_INDEX, o as isStorageTypeInstance, p as StorageColumn, r as applyFkDefaults, s as toStorageTypeInstance, t as DEFAULT_FK_CONSTRAINT, u as StorageValueSet, v as CheckConstraint, y as SqlNode } from "./types-B7kJ6S7m.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 };

package/dist/validators.d.mts

@@ -1,5 +1,5 @@
 import { n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
-import { r as SqlStorage } from "./sql-storage-CXf9xjAL.mjs";
+import { i as SqlStorage } from "./sql-storage-BCLmt-nS.mjs";
 import { Contract } from "@prisma-next/contract/types";
 import { Type } from "arktype";
 
@@ -15,26 +15,14 @@ type ColumnDefaultFunction = {
 declare const ColumnDefaultLiteralSchema: import("arktype/internal/variants/object.ts").ObjectType<ColumnDefaultLiteral, {}>;
 declare const ColumnDefaultFunctionSchema: import("arktype/internal/variants/object.ts").ObjectType<ColumnDefaultFunction, {}>;
 declare const ColumnDefaultSchema: import("arktype/internal/variants/object.ts").ObjectType<ColumnDefaultLiteral | ColumnDefaultFunction, {}>;
-/**
- * Postgres native enum entry under `storage.namespaces[namespaceId].entries.type[name]`.
- * Document-scoped `storage.types` carries codec aliases only
- * (`DocumentScopedStorageTypeSchema`).
- */
-declare const PostgresEnumTypeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-  kind: "postgres-enum";
-  values: readonly string[];
-  name?: string;
-  nativeType?: string;
-  control?: "managed" | "tolerated" | "external" | "observed";
-}, {}>;
 /**
  * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
- * Carries a `kind: 'value-set'` discriminator (enumerable, survives JSON) and an
+ * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
  * ordered `values` array of codec-encoded permitted values.
  */
 declare const StorageValueSetSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-  kind: "value-set";
-  values: readonly string[];
+  kind: "valueSet";
+  values: readonly (string | number | boolean | Record<string, unknown> | unknown[] | null)[];
 }, {}>;
 /**
  * Domain enum entry under `domain.namespaces[id].enum[name]`.
@@ -44,7 +32,7 @@ declare const ContractEnumSchema: import("arktype/internal/variants/object.ts").
   codecId: string;
   members: readonly {
     name: string;
-    value: string;
+    value: string | number | boolean | Record<string, unknown> | unknown[] | null;
   }[];
 }, {}>;
 declare const IndexSchema: import("arktype/internal/variants/object.ts").ObjectType<{
@@ -70,33 +58,46 @@ declare const CheckConstraintSchema: import("arktype/internal/variants/object.ts
   name: string;
   column: string;
   valueSet: {
-    plane: "domain" | "storage";
+    plane: "storage";
     namespaceId: string;
-    entityKind: "value-set" | "enum";
-    name: string;
+    entityKind: "valueSet";
+    entityName: string;
     spaceId?: string;
   };
 }, {}>;
+/**
+ * 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 via `packSchemas`.
+ */
+declare function createSqlEntrySchemaRegistry(packSchemas?: ReadonlyMap<string, Type<unknown>>): ReadonlyMap<string, Type<unknown>>;
 /**
  * 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.
  */
-declare function createNamespaceEntrySchema(fragments?: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
+declare function createNamespaceEntrySchema(registry: ReadonlyMap<string, Type<unknown>>): 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.
  */
-declare function createSqlStorageSchema(fragments?: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
+declare function createSqlStorageSchema(registry: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
 /**
  * Builds the full SQL contract schema. The storage subtree threads
  * pack contributions through {@link createSqlStorageSchema}; the rest
  * of the contract envelope is family-shared.
  */
-declare function createSqlContractSchema(fragments?: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
+declare function createSqlContractSchema(registry: ReadonlyMap<string, Type<unknown>>): Type<unknown>;
 /**
  * Validates the structural shape of SqlStorage using Arktype.
  *
@@ -155,5 +156,5 @@ interface ValidateSqlContractFullyOptions {
  */
 declare function validateSqlContractFully<T extends Contract<SqlStorage>>(value: unknown, options?: ValidateSqlContractFullyOptions): T;
 //#endregion
-export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, PostgresEnumTypeSchema, ReferentialActionSchema, StorageValueSetSchema, ValidateSqlContractFullyOptions, createNamespaceEntrySchema, createSqlContractSchema, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
+export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, ReferentialActionSchema, StorageValueSetSchema, ValidateSqlContractFullyOptions, createNamespaceEntrySchema, createSqlContractSchema, createSqlEntrySchemaRegistry, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
 //# sourceMappingURL=validators.d.mts.map

package/dist/validators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"mappings":";;;;;;KA2BK,oBAAA;EAAA,SACM,IAAA;EAAA,SACA,KAAA,8BAAmC,MAAM;AAAA;AAAA,KAE/C,qBAAA;EAAA,SAAmC,IAAA;EAAA,SAA2B,UAAU;AAAA;AAAA,cAShE,0BAAA,gDAA0B,UAAA,CAAA,oBAAA;AAAA,cAK1B,2BAAA,gDAA2B,UAAA,CAAA,qBAAA;AAAA,cAK3B,mBAAA,gDAAmB,UAAA,CAAA,oBAAA,GAAA,qBAAA;;AArBoB;AAAA;;;cA+F9C,sBAAA,gDAAsB,UAAA;;;;;;;AA/E5B;;;;AAAwC;AAAxC,cA+Fa,qBAAA,gDAAqB,UAAA;;;;;;;;cASrB,kBAAA,gDAAkB,UAAA;;;;;;;cAqBlB,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;;;;;;;;;;;;AA7BlC;;;;;iBAqHgB,0BAAA,CACd,SAAA,GAAY,WAAA,SAAoB,IAAA,aAC/B,IAAA;;;;;;AA/GH;iBAqIgB,sBAAA,CACd,SAAA,GAAY,WAAA,SAAoB,IAAA,aAC/B,IAAA;;;;;;iBAiKa,uBAAA,CACd,SAAA,GAAY,WAAA,SAAoB,IAAA,aAC/B,IAAA;;;AAnSH;;;;AAAoC;iBA6UpB,eAAA,CAAgB,KAAA,YAAiB,UAAU;AAAA,iBA4B3C,aAAA,CAAc,KAAc;;;AArWf;AAU7B;;;;;;;;;;iBAyZgB,wBAAA,CAAyB,OAAmB,EAAV,UAAU;;;;;AAjU5D;;iBAsegB,8BAAA,CAA+B,QAAA,EAAU,QAAQ,CAAC,UAAA;;;;;;;iBA2DlD,6BAAA,CAA8B,QAAA,EAAU,QAAQ,CAAC,UAAA;AAAA,UAwGhD,+BAAA;EAvoBd;;AAAI;AAsBP;;;;;EAtBG,SAgpBQ,cAAA,GAAiB,IAAI;AAAA;;;;;;;AAxnBzB;AAiKP;iBAkegB,wBAAA,WAAmC,QAAA,CAAS,UAAA,GAC1D,KAAA,WACA,OAAA,GAAU,+BAAA,GACT,CAAA"}
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/validators.ts"],"mappings":";;;;;;KA2BK,oBAAA;EAAA,SACM,IAAA;EAAA,SACA,KAAA,8BAAmC,MAAM;AAAA;AAAA,KAE/C,qBAAA;EAAA,SAAmC,IAAA;EAAA,SAA2B,UAAU;AAAA;AAAA,cAShE,0BAAA,gDAA0B,UAAA,CAAA,oBAAA;AAAA,cAK1B,2BAAA,gDAA2B,UAAA,CAAA,qBAAA;AAAA,cAK3B,mBAAA,gDAAmB,UAAA,CAAA,oBAAA,GAAA,qBAAA;;AArBoB;AAAA;;;cAyGvC,qBAAA,gDAAqB,UAAA;;gDAKhC,MAAA;AAAA;;;AAnGqC;AAKvC;cAoGa,kBAAA,gDAAkB,UAAA;;;;uCAS7B,MAAA;EAAA;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;;;;;;;;;;;;;;;;;;iBAyBlB,4BAAA,CACd,WAAA,GAAc,WAAA,SAAoB,IAAA,aACjC,WAAA,SAAoB,IAAA;;;AAxDvB;;;;;;;;;iBAqFgB,0BAAA,CACd,QAAA,EAAU,WAAA,SAAoB,IAAA,aAC7B,IAAA;;AA/EH;;;;;iBAsHgB,sBAAA,CACd,QAAA,EAAU,WAAA,SAAoB,IAAA,aAC7B,IAAA;;;;;AAjHH;iBAgRgB,uBAAA,CACd,QAAA,EAAU,WAAA,SAAoB,IAAA,aAC7B,IAAA;;;AAlRiC;AAIpC;;;;iBAwTgB,eAAA,CAAgB,KAAA,YAAiB,UAAU;AAAA,iBA4B3C,aAAA,CAAc,KAAc;;;;;;;;;;;;;;iBA8D5B,wBAAA,CAAyB,OAAmB,EAAV,UAAU;AA/W5D;;;;;;AAAA,iBAohBgB,8BAAA,CAA+B,QAAA,EAAU,QAAQ,CAAC,UAAA;;;;;;;iBA4DlD,6BAAA,CAA8B,QAAA,EAAU,QAAQ,CAAC,UAAA;AAAA,UAwGhD,+BAAA;EAtrBU;AA6B3B;;;;;;;EA7B2B,SA+rBhB,cAAA,GAAiB,IAAI;AAAA;;;;;AAhqBzB;AAuCP;;;iBAooBgB,wBAAA,WAAmC,QAAA,CAAS,UAAA,GAC1D,KAAA,WACA,OAAA,GAAU,+BAAA,GACT,CAAA"}

package/dist/validators.mjs

@@ -1,10 +1,10 @@
-import { C as SqlUnboundNamespace, f as buildSqlNamespaceMap, i as SqlStorage } from "./types-DqhaAjCH.mjs";
+import { b as SqlUnboundNamespace, i as SqlStorage, l as buildSqlNamespaceMap } from "./types-B7kJ6S7m.mjs";
 import { 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 { CrossReferenceSchema } from "@prisma-next/contract/types";
 import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 import { validateContractDomain } from "@prisma-next/contract/validate-domain";
-import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";
 //#region src/validators.ts
 const literalKindSchema = type("'literal'");
@@ -46,11 +46,18 @@ const ExecutionSchema = type({
 		}).array().readonly()
 	}
 });
-const ValueSetRefSchema = type({
-	plane: "'domain' | 'storage'",
+const StorageValueSetRefSchema = type({
+	plane: "'storage'",
 	namespaceId: "string",
-	entityKind: "'enum' | 'value-set'",
-	name: "string",
+	entityKind: "'valueSet'",
+	entityName: "string",
+	"spaceId?": "string"
+});
+const DomainEnumRefSchema = type({
+	plane: "'domain'",
+	namespaceId: "string",
+	entityKind: "'enum'",
+	entityName: "string",
 	"spaceId?": "string"
 });
 const StorageColumnSchema = type({
@@ -62,45 +69,26 @@ const StorageColumnSchema = type({
 	"typeRef?": "string",
 	"default?": ColumnDefaultSchema,
 	"control?": ControlPolicySchema,
-	"valueSet?": ValueSetRefSchema
+	"valueSet?": StorageValueSetRefSchema
 }).narrow((col, ctx) => {
 	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
 	return true;
 });
-/**
-* Codec-triple entry persisted under `storage.types[name]`. Carries an
-* enumerable literal `kind: 'codec-instance'` discriminator so the
-* polymorphic slot dispatch can distinguish codec triples from
-* class-instance kinds (e.g. `'postgres-enum'`) sharing the slot.
-*/
-const StorageTypeInstanceSchema = type.declare().type({
+/** Document-scoped `storage.types`: codec triples only. */
+const DocumentScopedStorageTypeSchema = type.declare().type({
 	kind: "'codec-instance'",
 	codecId: "string",
 	nativeType: "string",
 	"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;
-/**
 * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
-* Carries a `kind: 'value-set'` discriminator (enumerable, survives JSON) and an
+* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
 * ordered `values` array of codec-encoded permitted values.
 */
 const StorageValueSetSchema = type({
-	kind: "'value-set'",
-	values: type.string.array().readonly()
+	kind: "'valueSet'",
+	values: type("string | number | boolean | null | unknown[] | Record<string, unknown>").array().readonly()
 });
 /**
 * Domain enum entry under `domain.namespaces[id].enum[name]`.
@@ -111,7 +99,7 @@ const ContractEnumSchema = type({
 	codecId: "string",
 	members: type({
 		name: "string",
-		value: "string"
+		value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
 	}).array().readonly()
 });
 const PrimaryKeySchema = type.declare().type({
@@ -155,7 +143,7 @@ const CheckConstraintSchema = type({
 	"+": "reject",
 	name: "string",
 	column: "string",
-	valueSet: ValueSetRefSchema
+	valueSet: StorageValueSetRefSchema
 });
 const StorageTableSchema = type({
 	"+": "reject",
@@ -168,73 +156,59 @@ const StorageTableSchema = type({
 	"checks?": CheckConstraintSchema.array().readonly()
 });
 /**
-* 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 via `packSchemas`.
 */
-function namespaceSlotEntrySchema(fallback, fallbackKind, fragments) {
-	if (fragments === void 0 || 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.kind;
-		if (typeof kind === "string") {
-			const fragment = fragments.get(kind);
-			if (fragment !== void 0) {
-				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;
-			}
-		}
-		const parsed = fallback(entry);
-		if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
-		return true;
-	});
+function createSqlEntrySchemaRegistry(packSchemas) {
+	const registry = new Map([["table", castAs(StorageTableSchema)], ["valueSet", castAs(StorageValueSetSchema)]]);
+	if (packSchemas !== void 0) 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);
+	}
+	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.
 */
-function createNamespaceEntrySchema(fragments) {
+function createNamespaceEntrySchema(registry) {
 	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 === void 0) 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;
 	});
 }
 /**
 * 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.
 */
-function createSqlStorageSchema(fragments) {
-	const namespaceEntry = createNamespaceEntrySchema(fragments);
+function createSqlStorageSchema(registry) {
+	const namespaceEntry = createNamespaceEntrySchema(registry);
 	return type({
 		"+": "reject",
 		storageHash: "string",
@@ -242,16 +216,18 @@ function createSqlStorageSchema(fragments) {
 		"namespaces?": type({ "[string]": namespaceEntry })
 	});
 }
-const StorageSchema = createSqlStorageSchema();
+const StorageSchema = createSqlStorageSchema(createSqlEntrySchemaRegistry());
 function eachStorageTable(storage) {
-	return Object.entries(storage.namespaces).flatMap(([namespaceId, ns]) => Object.entries(ns.entries.table).map(([tableName, table]) => ({
+	return Object.entries(storage.namespaces).flatMap(([namespaceId, ns]) => Object.entries(ns.entries["table"] ?? {}).map(([tableName, table]) => ({
 		namespaceId,
 		tableName,
 		table
 	})));
 }
 function isPlainRecord(value) {
-	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);
+	return proto === Object.prototype || proto === null;
 }
 function findDuplicateValue(values) {
 	const seen = /* @__PURE__ */ new Set();
@@ -283,7 +259,7 @@ const ModelFieldSchema = type({
 	type: type("unknown").narrow((value, ctx) => isContractFieldType(value) ? true : ctx.mustBe("scalar, valueObject, or union field type")),
 	"many?": "true",
 	"dict?": "true",
-	"valueSet?": ValueSetRefSchema
+	"valueSet?": DomainEnumRefSchema
 });
 const ModelStorageSchema = type({
 	table: "string",
@@ -342,8 +318,8 @@ const ContractMetaSchema = type({ "[string]": "unknown" });
 * pack contributions through {@link createSqlStorageSchema}; the rest
 * of the contract envelope is family-shared.
 */
-function createSqlContractSchema(fragments) {
-	const storage = createSqlStorageSchema(fragments);
+function createSqlContractSchema(registry) {
+	const storage = createSqlStorageSchema(registry);
 	return type({
 		"+": "reject",
 		target: "string",
@@ -364,7 +340,7 @@ function createSqlContractSchema(fragments) {
 		"execution?": ExecutionSchema
 	});
 }
-const SqlContractSchema = createSqlContractSchema();
+const SqlContractSchema = createSqlContractSchema(createSqlEntrySchemaRegistry());
 /**
 * Validates the structural shape of SqlStorage using Arktype.
 *
@@ -525,7 +501,7 @@ function validateModelStorageReferences(contract) {
 			const storageNamespaceId = model.storage.namespaceId;
 			if (storageNamespaceId !== namespaceId) throw new ContractValidationError(`Model "${qualifiedName}" storage.namespaceId "${storageNamespaceId}" does not match domain namespace "${namespaceId}"`, "storage");
 			const storageTable = model.storage.table;
-			const rawTable = contract.storage.namespaces[storageNamespaceId]?.entries.table[storageTable];
+			const rawTable = contract.storage.namespaces[storageNamespaceId]?.entries.table?.[storageTable];
 			if (rawTable === void 0) throw new ContractValidationError(`Model "${qualifiedName}" references non-existent table "${storageNamespaceId}.${storageTable}"`, "storage");
 			const table = rawTable;
 			const columnNames = new Set(Object.keys(table.columns));
@@ -563,7 +539,7 @@ function validateSqlStorageConsistency(contract) {
 			if (fk.source.namespaceId !== namespaceId || fk.source.tableName !== tableName) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" contains foreignKey with mismatched source coordinates (${fk.source.namespaceId}.${fk.source.tableName})`, "storage");
 			for (const colName of fk.source.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent column "${colName}"`, "storage");
 			if (fk.target.spaceId === void 0) {
-				const referencedRaw = contract.storage.namespaces[fk.target.namespaceId]?.entries.table[fk.target.tableName];
+				const referencedRaw = contract.storage.namespaces[fk.target.namespaceId]?.entries.table?.[fk.target.tableName];
 				if (referencedRaw === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent table "${fk.target.namespaceId}.${fk.target.tableName}"`, "storage");
 				const referencedColumnNames = new Set(Object.keys(referencedRaw.columns));
 				for (const colName of fk.target.columns) if (!referencedColumnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.target.tableName}"`, "storage");
@@ -596,6 +572,6 @@ function validateSqlContractFully(value, options) {
 	return validated;
 }
 //#endregion
-export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, PostgresEnumTypeSchema, ReferentialActionSchema, StorageValueSetSchema, createNamespaceEntrySchema, createSqlContractSchema, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
+export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, ReferentialActionSchema, StorageValueSetSchema, createNamespaceEntrySchema, createSqlContractSchema, createSqlEntrySchemaRegistry, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
 
 //# sourceMappingURL=validators.mjs.map