@prisma-next/sql-contract 0.14.0-dev.8 → 0.14.0-dev.80

package/dist/canonicalization-hooks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;;cAwBa,gCAAA;EAAA,SACF,mBAAA,EAAqB,sBAAA;EAAA,SACrB,WAAA,EAAa,WAAW;AAAA"}
+{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;;cA6Ba,gCAAA;EAAA,SACF,mBAAA,EAAqB,sBAAA;EAAA,SACrB,WAAA,EAAa,WAAW;AAAA"}

package/dist/canonicalization-hooks.mjs

@@ -38,6 +38,18 @@ const sqlContractCanonicalizationHooks = {
 			"*",
 			"foreignKeys",
 			["constraint", "index"]
+		],
+		[
+			"storage",
+			"namespaces",
+			"*",
+			"entries",
+			"table",
+			"*",
+			"columns",
+			"*",
+			"default",
+			"value"
 		]
 	]),
 	sortStorage: createStorageSort([{

package/dist/canonicalization-hooks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.mjs","names":[],"sources":["../src/canonicalization-hooks.ts"],"sourcesContent":["import type { PreserveEmptyPredicate, StorageSort } from '@prisma-next/contract/hashing';\nimport {\n  createPreserveEmptyPredicate,\n  createStorageSort,\n  type NamedArraySortTarget,\n  type PathPattern,\n} from '@prisma-next/contract/hashing-utils';\n\nconst preserveEmptyPatterns = [\n  ['storage', 'namespaces', '*', 'entries', 'table'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'foreignKeys', ['constraint', 'index']],\n] as const satisfies readonly PathPattern[];\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate =\n  createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst sortStorage: StorageSort = createStorageSort(sortTargets);\n\nexport const sqlContractCanonicalizationHooks: {\n  readonly shouldPreserveEmpty: PreserveEmptyPredicate;\n  readonly sortStorage: StorageSort;\n} = {\n  shouldPreserveEmpty,\n  sortStorage,\n};\n"],"mappings":";AAwBA,MAAa,mCAGT;CACF,qBARA,6BAA6B;EAX7B;GAAC;GAAW;GAAc;GAAK;GAAW;EAAO;EACjD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;EAAG;EACtD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;IAAC;IAAW;IAAW;GAAa;EAAC;EAC7F;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;GAAe,CAAC,cAAc,OAAO;EAAC;CAQjE,CAQ7B;CACA,aAP+B,kBAAkB,CANjD;EAAE,MAAM;GAAC;GAAc;GAAK;GAAW;GAAS;EAAG;EAAG,WAAW,CAAC,WAAW,SAAS;CAAE,CAMvC,CAOjD;AACF"}
+{"version":3,"file":"canonicalization-hooks.mjs","names":[],"sources":["../src/canonicalization-hooks.ts"],"sourcesContent":["import type { PreserveEmptyPredicate, StorageSort } from '@prisma-next/contract/hashing';\nimport {\n  createPreserveEmptyPredicate,\n  createStorageSort,\n  type NamedArraySortTarget,\n  type PathPattern,\n} from '@prisma-next/contract/hashing-utils';\n\nconst preserveEmptyPatterns = [\n  ['storage', 'namespaces', '*', 'entries', 'table'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'foreignKeys', ['constraint', 'index']],\n  // A column default's literal payload is data, not shape — `{ kind:\n  // 'literal', value: false }` (or `value: []`) must survive the\n  // default-omission walk or the emitted contract fails its own\n  // validation on the next read (PN-CLI-4003 on `Boolean @default(false)`).\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'columns', '*', 'default', 'value'],\n] as const satisfies readonly PathPattern[];\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate =\n  createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst sortStorage: StorageSort = createStorageSort(sortTargets);\n\nexport const sqlContractCanonicalizationHooks: {\n  readonly shouldPreserveEmpty: PreserveEmptyPredicate;\n  readonly sortStorage: StorageSort;\n} = {\n  shouldPreserveEmpty,\n  sortStorage,\n};\n"],"mappings":";AA6BA,MAAa,mCAGT;CACF,qBARA,6BAA6B;EAhB7B;GAAC;GAAW;GAAc;GAAK;GAAW;EAAO;EACjD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;EAAG;EACtD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;IAAC;IAAW;IAAW;GAAa;EAAC;EAC7F;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;GAAe,CAAC,cAAc,OAAO;EAAC;EAK9F;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;GAAW;GAAK;GAAW;EAAO;CAQ7D,CAQ7B;CACA,aAP+B,kBAAkB,CANjD;EAAE,MAAM;GAAC;GAAc;GAAK;GAAW;GAAS;EAAG;EAAG,WAAW,CAAC,WAAW,SAAS;CAAE,CAMvC,CAOjD;AACF"}

package/dist/contract-view.d.mts

@@ -0,0 +1,61 @@
+import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
+import { DefaultNamespaceEntries, NamespacedEntities, SingleNamespaceView } from "@prisma-next/framework-components/ir";
+import { Contract } from "@prisma-next/contract/types";
+
+//#region src/contract-view.d.ts
+/**
+ * The SQL family's statically-named built-in entity kinds. `table` and
+ * `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+ * (e.g. `policy`) stay under `.entries`.
+ */
+declare const SQL_BUILTIN_KINDS: readonly ["table", "valueSet"];
+type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];
+type SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<TContract['storage']>;
+/**
+ * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds
+ * under `entries`. A target that never emits a built-in kind (SQLite has
+ * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty
+ * map.
+ */
+type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> = SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;
+/**
+ * Single-namespace SQL view: the deserialized contract intersected with the
+ * by-name accessors, so the value is substitutable for `Contract` while also
+ * exposing:
+ *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole
+ *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.
+ *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole
+ *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.
+ */
+type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract & SqlSingleNamespaceAccessors<TContract> & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+ * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+ * `namespace` map, and layers both over the deserialized contract. Targets with
+ * one default namespace (SQLite) call this directly; Postgres qualifies by
+ * schema.
+ */
+declare function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSingleNamespaceView<TContract>;
+/**
+ * Schema-qualified SQL view: the deserialized contract intersected with a single
+ * `view.namespace.<id>` member — every schema reached by raw id
+ * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`
+ * keying exactly (the default schema keeps its literal `__unbound__` id). There
+ * is NO root schema-name promotion, so there is no collision with contract
+ * envelope fields — `view.storage` is always the contract's `storage`. Postgres
+ * uses this; SQLite (single default namespace) uses
+ * {@link buildSqlSingleNamespaceView}.
+ */
+type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+ * map over the deserialized contract. Postgres uses this.
+ */
+declare function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSchemaQualifiedView<TContract>;
+//#endregion
+export { SQL_BUILTIN_KINDS, type SqlBuiltinKind, type SqlSchemaQualifiedView, type SqlSingleNamespaceAccessors, type SqlSingleNamespaceView, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+//# sourceMappingURL=contract-view.d.mts.map

package/dist/contract-view.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.d.mts","names":[],"sources":["../src/contract-view.ts"],"mappings":";;;;;;;AAeA;;;cAAa,iBAAA;AAAA,KACD,cAAA,WAAyB,iBAAiB;AAAA,KAEjD,UAAA,mBAA6B,QAAA,CAAS,UAAA,KAAe,uBAAA,CACxD,SAAA;;;;AAHoD;AAAU;;KAYpD,2BAAA,mBAA8C,QAAA,CAAS,UAAA,KACjE,mBAAA,CAAoB,UAAA,CAAW,SAAA,GAAY,cAAA;;;;;;;;;;KAWjC,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA,GAC3E,2BAAA,CAA4B,SAAA;EAAA,SACjB,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAvBtD;AASX;;;;;;AATW,iBAiCK,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA;;;;;;;;;;;KAyBd,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA;EAAA,SAClE,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAxC/D;;;;AAAA,iBA+CgB,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA"}

package/dist/contract-view.mjs

@@ -0,0 +1,39 @@
+import { buildNamespacedEntities, buildSingleNamespaceView } from "@prisma-next/framework-components/ir";
+//#region src/contract-view.ts
+/**
+* The SQL family's statically-named built-in entity kinds. `table` and
+* `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+* (e.g. `policy`) stay under `.entries`.
+*/
+const SQL_BUILTIN_KINDS = ["table", "valueSet"];
+/**
+* Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+* built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+* `namespace` map, and layers both over the deserialized contract. Targets with
+* one default namespace (SQLite) call this directly; Postgres qualifies by
+* schema.
+*/
+function buildSqlSingleNamespaceView(contract) {
+	const rootAccessors = buildSingleNamespaceView(contract.storage, SQL_BUILTIN_KINDS);
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		...rootAccessors,
+		namespace
+	};
+}
+/**
+* Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+* map over the deserialized contract. Postgres uses this.
+*/
+function buildSqlSchemaQualifiedView(contract) {
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		namespace
+	};
+}
+//#endregion
+export { SQL_BUILTIN_KINDS, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+
+//# sourceMappingURL=contract-view.mjs.map

package/dist/contract-view.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.mjs","names":[],"sources":["../src/contract-view.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildNamespacedEntities,\n  buildSingleNamespaceView,\n  type DefaultNamespaceEntries,\n  type NamespacedEntities,\n  type SingleNamespaceView,\n} from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from './ir/sql-storage';\n\n/**\n * The SQL family's statically-named built-in entity kinds. `table` and\n * `valueSet` are promoted to top-level view accessors; pack-contributed kinds\n * (e.g. `policy`) stay under `.entries`.\n */\nexport const SQL_BUILTIN_KINDS = ['table', 'valueSet'] as const;\nexport type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];\n\ntype SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<\n  TContract['storage']\n>;\n\n/**\n * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds\n * under `entries`. A target that never emits a built-in kind (SQLite has\n * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty\n * map.\n */\nexport type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> =\n  SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;\n\n/**\n * Single-namespace SQL view: the deserialized contract intersected with the\n * by-name accessors, so the value is substitutable for `Contract` while also\n * exposing:\n *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole\n *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.\n *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole\n *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.\n */\nexport type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract &\n  SqlSingleNamespaceAccessors<TContract> & {\n    readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n  };\n\n/**\n * Builds the single-namespace SQL view: unwraps the sole namespace's SQL\n * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed\n * `namespace` map, and layers both over the deserialized contract. Targets with\n * one default namespace (SQLite) call this directly; Postgres qualifies by\n * schema.\n */\nexport function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSingleNamespaceView<TContract> {\n  const rootAccessors = buildSingleNamespaceView<SqlSingleNamespaceAccessors<TContract>>(\n    contract.storage,\n    SQL_BUILTIN_KINDS,\n  );\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    ...rootAccessors,\n    namespace,\n  };\n}\n\n/**\n * Schema-qualified SQL view: the deserialized contract intersected with a single\n * `view.namespace.<id>` member — every schema reached by raw id\n * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`\n * keying exactly (the default schema keeps its literal `__unbound__` id). There\n * is NO root schema-name promotion, so there is no collision with contract\n * envelope fields — `view.storage` is always the contract's `storage`. Postgres\n * uses this; SQLite (single default namespace) uses\n * {@link buildSqlSingleNamespaceView}.\n */\nexport type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {\n  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n};\n\n/**\n * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`\n * map over the deserialized contract. Postgres uses this.\n */\nexport function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSchemaQualifiedView<TContract> {\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    namespace,\n  };\n}\n"],"mappings":";;;;;;;AAeA,MAAa,oBAAoB,CAAC,SAAS,UAAU;;;;;;;;AAqCrD,SAAgB,4BACd,UACmC;CACnC,MAAM,gBAAgB,yBACpB,SAAS,SACT,iBACF;CACA,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH,GAAG;EACH;CACF;AACF;;;;;AAoBA,SAAgB,4BACd,UACmC;CACnC,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH;CACF;AACF"}

package/dist/entity-kinds-BEPZdFBN.mjs

@@ -0,0 +1,132 @@
+import { t as StorageTable } from "./storage-table-y6R6pxyI.mjs";
+import { t as StorageValueSet } from "./storage-value-set-Tx3CFoS_.mjs";
+import { type } from "arktype";
+//#region src/ir/storage-entry-schemas.ts
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+const ColumnDefaultLiteralSchema = type.declare().type({
+	kind: literalKindSchema,
+	value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
+});
+const ColumnDefaultFunctionSchema = type.declare().type({
+	kind: functionKindSchema,
+	expression: "string"
+});
+const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+const StorageValueSetRefSchema = type({
+	plane: "'storage'",
+	namespaceId: "string",
+	entityKind: "'valueSet'",
+	entityName: "string",
+	"spaceId?": "string"
+});
+const StorageColumnSchema = type({
+	"+": "reject",
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"many?": "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema,
+	"control?": ControlPolicySchema,
+	"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;
+});
+/**
+* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+* ordered `values` array of codec-encoded permitted values.
+*/
+const StorageValueSetSchema = type({
+	kind: "'valueSet'",
+	values: type("string | number | boolean | null | unknown[] | Record<string, unknown>").array().readonly()
+});
+const PrimaryKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const UniqueConstraintSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const IndexSchema = type({
+	columns: type.string.array().readonly(),
+	"name?": "string",
+	"type?": "string",
+	"options?": "Record<string, unknown>"
+});
+const ForeignKeyReferenceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly(),
+	"spaceId?": "string"
+});
+const ForeignKeySourceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly()
+});
+const ReferentialActionSchema = type.declare().type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+const ForeignKeySchema = type.declare().type({
+	source: ForeignKeySourceSchema,
+	target: ForeignKeyReferenceSchema,
+	"name?": "string",
+	"onDelete?": ReferentialActionSchema,
+	"onUpdate?": ReferentialActionSchema,
+	constraint: "boolean",
+	index: "boolean"
+});
+const CheckConstraintSchema = type({
+	"+": "reject",
+	name: "string",
+	column: "string",
+	valueSet: StorageValueSetRefSchema
+});
+const StorageTableSchema = type({
+	"+": "reject",
+	columns: type({ "[string]": StorageColumnSchema }),
+	"primaryKey?": PrimaryKeySchema,
+	uniques: UniqueConstraintSchema.array().readonly(),
+	indexes: IndexSchema.array().readonly(),
+	foreignKeys: ForeignKeySchema.array().readonly(),
+	"control?": ControlPolicySchema,
+	"checks?": CheckConstraintSchema.array().readonly()
+});
+//#endregion
+//#region src/entity-kinds.ts
+const tableEntityKind = {
+	kind: "table",
+	schema: StorageTableSchema,
+	construct: (input) => new StorageTable(input)
+};
+const valueSetEntityKind = {
+	kind: "valueSet",
+	schema: StorageValueSetSchema,
+	construct: (input) => new StorageValueSet(input)
+};
+/**
+* Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+* `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+* lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+* later consumes this registry to turn a namespace's raw entries into IR
+* instances, and `createSqlContractSchema` derives validation from the same
+* registry. Throws on a duplicate kind.
+*/
+function composeSqlEntityKinds(packKinds = []) {
+	const kinds = /* @__PURE__ */ new Map([["table", tableEntityKind], ["valueSet", valueSetEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw new Error(`composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`);
+		kinds.set(descriptor.kind, descriptor);
+	}
+	return kinds;
+}
+//#endregion
+export { ColumnDefaultFunctionSchema as a, ForeignKeyReferenceSchema as c, IndexSchema as d, ReferentialActionSchema as f, CheckConstraintSchema as i, ForeignKeySchema as l, StorageValueSetSchema as m, tableEntityKind as n, ColumnDefaultLiteralSchema as o, StorageTableSchema as p, valueSetEntityKind as r, ColumnDefaultSchema as s, composeSqlEntityKinds as t, ForeignKeySourceSchema as u };
+
+//# sourceMappingURL=entity-kinds-BEPZdFBN.mjs.map

package/dist/entity-kinds-BEPZdFBN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-BEPZdFBN.mjs","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/entity-kinds.ts"],"sourcesContent":["import { type Type, type } from 'arktype';\nimport type { ForeignKeyInput, ReferentialAction } from './foreign-key';\nimport type { ForeignKeyReferenceInput } from './foreign-key-reference';\nimport type { PrimaryKeyInput } from './primary-key';\nimport type { UniqueConstraintInput } from './unique-constraint';\n\ntype ColumnDefaultLiteral = {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;\n};\ntype ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };\n\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst ControlPolicySchema = type(\"'managed' | 'tolerated' | 'external' | 'observed'\");\n\nexport const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({\n  kind: literalKindSchema,\n  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',\n});\n\nexport const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({\n  kind: functionKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\n\nconst StorageValueSetRefSchema = type({\n  plane: \"'storage'\",\n  namespaceId: 'string',\n  entityKind: \"'valueSet'\",\n  entityName: 'string',\n  'spaceId?': 'string',\n});\n\nconst StorageColumnSchema = type({\n  '+': 'reject',\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n  'many?': 'boolean',\n  'typeParams?': 'Record<string, unknown>',\n  'typeRef?': 'string',\n  'default?': ColumnDefaultSchema,\n  'control?': ControlPolicySchema,\n  'valueSet?': StorageValueSetRefSchema,\n}).narrow((col, ctx) => {\n  if (col.typeParams !== undefined && col.typeRef !== undefined) {\n    return ctx.mustBe('a column with either typeParams or typeRef, not both');\n  }\n  return true;\n});\n\n/**\n * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.\n * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an\n * ordered `values` array of codec-encoded permitted values.\n */\nexport const StorageValueSetSchema = type({\n  kind: \"'valueSet'\",\n  values: type('string | number | boolean | null | unknown[] | Record<string, unknown>')\n    .array()\n    .readonly(),\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nexport const IndexSchema = type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n  'type?': 'string',\n  'options?': 'Record<string, unknown>',\n});\n\nexport const ForeignKeyReferenceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n  'spaceId?': 'string',\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ForeignKeySourceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ReferentialActionSchema = type\n  .declare<ReferentialAction>()\n  .type(\"'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'\");\n\nexport const ForeignKeySchema = type.declare<ForeignKeyInput>().type({\n  source: ForeignKeySourceSchema,\n  target: ForeignKeyReferenceSchema,\n  'name?': 'string',\n  'onDelete?': ReferentialActionSchema,\n  'onUpdate?': ReferentialActionSchema,\n  constraint: 'boolean',\n  index: 'boolean',\n});\n\nexport const CheckConstraintSchema = type({\n  '+': 'reject',\n  name: 'string',\n  column: 'string',\n  valueSet: StorageValueSetRefSchema,\n});\n\nexport const StorageTableSchema = type({\n  '+': 'reject',\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n  'control?': ControlPolicySchema,\n  'checks?': CheckConstraintSchema.array().readonly(),\n});\n","import type {\n  AnyEntityKindDescriptor,\n  EntityKindDescriptor,\n} from '@prisma-next/framework-components/ir';\nimport { StorageTableSchema, StorageValueSetSchema } from './ir/storage-entry-schemas';\nimport { StorageTable, type StorageTableInput } from './ir/storage-table';\nimport { StorageValueSet, type StorageValueSetInput } from './ir/storage-value-set';\n\nexport const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable> = {\n  kind: 'table',\n  schema: StorageTableSchema,\n  construct: (input) => new StorageTable(input),\n};\n\nexport const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet> = {\n  kind: 'valueSet',\n  schema: StorageValueSetSchema,\n  construct: (input) => new StorageValueSet(input),\n};\n\n/**\n * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in\n * `table` and `valueSet` kinds plus any target `packKinds`. This builds the\n * lookup table — it does not touch contract data. `hydrateNamespaceEntities`\n * later consumes this registry to turn a namespace's raw entries into IR\n * instances, and `createSqlContractSchema` derives validation from the same\n * registry. Throws on a duplicate kind.\n */\nexport function composeSqlEntityKinds(\n  packKinds: readonly AnyEntityKindDescriptor[] = [],\n): ReadonlyMap<string, AnyEntityKindDescriptor> {\n  const kinds = new Map<string, AnyEntityKindDescriptor>([\n    ['table', tableEntityKind],\n    ['valueSet', valueSetEntityKind],\n  ]);\n  for (const descriptor of packKinds) {\n    if (kinds.has(descriptor.kind)) {\n      throw new Error(\n        `composeSqlEntityKinds: duplicate entity kind \"${descriptor.kind}\" — each kind may be registered only once`,\n      );\n    }\n    kinds.set(descriptor.kind, descriptor);\n  }\n  return kinds;\n}\n"],"mappings":"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"}

package/dist/entity-kinds.d.mts

@@ -1,4 +1,5 @@
-import { i as StorageTableInput, n as StorageValueSetInput, r as StorageTable, t as StorageValueSet } from "./storage-value-set-WnYsIFM8.mjs";
+import { n as StorageTableInput, t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
+import { n as StorageValueSetInput, t as StorageValueSet } from "./storage-value-set-D-jww77l.mjs";
 import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma-next/framework-components/ir";
 
 //#region src/entity-kinds.d.ts

package/dist/entity-kinds.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;cAQa,eAAA,EAAiB,oBAAA,CAAqB,iBAAA,EAAmB,YAAA;AAAA,cAMzD,kBAAA,EAAoB,oBAAA,CAAqB,oBAAA,EAAsB,eAAA;;;;;;;;;iBAc5D,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}
+{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;;cAQa,eAAA,EAAiB,oBAAA,CAAqB,iBAAA,EAAmB,YAAA;AAAA,cAMzD,kBAAA,EAAoB,oBAAA,CAAqB,oBAAA,EAAsB,eAAA;AAN5E;;;;;;;;AAAA,iBAoBgB,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}

package/dist/entity-kinds.mjs

@@ -1,2 +1,2 @@
-import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-Cl36zL5j.mjs";
+import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-BEPZdFBN.mjs";
 export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };

package/dist/factories.d.mts

@@ -1,10 +1,12 @@
-import { t as ForeignKey } from "./foreign-key-BATxB95l.mjs";
-import { a as UniqueConstraint, c as StorageColumnInput, d as PrimaryKey, l as Index, r as StorageTable, s as StorageColumn } from "./storage-value-set-WnYsIFM8.mjs";
-import { b as SqlModelFieldStorage, f as ForeignKeyOptions, x as SqlModelStorage } from "./types-B1N8w0I2.mjs";
+import { a as StorageColumn, l as PrimaryKey, o as StorageColumnInput, r as UniqueConstraint, s as Index, t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
+import { t as ForeignKey } from "./foreign-key-DM1UTydh.mjs";
+import { T as SqlModelStorage, m as ForeignKeyOptions, w as SqlModelFieldStorage } from "./types-zBvpNCmg.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
 
 //#region src/factories.d.ts
-declare function col(nativeType: string, codecId: string, nullable?: boolean): StorageColumn;
+declare function col(nativeType: string, codecId: string, nullable?: boolean, opts?: {
+  readonly many?: boolean;
+}): StorageColumn;
 declare function pk(...columns: readonly string[]): PrimaryKey;
 declare function unique(...columns: readonly string[]): UniqueConstraint;
 declare function index(...columns: readonly string[]): Index;

package/dist/factories.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"factories.d.mts","names":[],"sources":["../src/factories.ts"],"mappings":";;;;;;iBAgBgB,GAAA,CAAI,UAAA,UAAoB,OAAA,UAAiB,QAAA,aAAmB,aAAa;AAAA,iBAIzE,EAAA,IAAM,OAAA,sBAA6B,UAAU;AAAA,iBAI7C,MAAA,IAAU,OAAA,sBAA6B,gBAAgB;AAAA,iBAIvD,KAAA,IAAS,OAAA,sBAA6B,KAAK;AAAA,iBAI3C,EAAA,CACd,YAAA,UACA,UAAA,qBACA,eAAA,UACA,aAAA,qBACA,IAAA,GAAO,iBAAA;EAAsB,UAAA;EAAsB,KAAA;EAAiB,WAAA;AAAA,IACnE,UAAU;AAAA,iBAcG,KAAA,CACd,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA,GACxC,IAAA;EACE,EAAA,GAAK,UAAA;EACL,OAAA,YAAmB,gBAAA;EACnB,OAAA,YAAmB,KAAA;EACnB,GAAA,YAAe,UAAA;AAAA,IAEhB,YAAA;AAAA,iBAUa,KAAA,CACd,SAAA,UACA,MAAA,EAAQ,MAAA,SAAe,oBAAA,GACvB,SAAA,GAAW,MAAA,mBACX,WAAA;EAEA,OAAA,EAAS,eAAA;EACT,MAAA,EAAQ,MAAA;IAAA,SAA0B,QAAA;IAAA,SAA4B,IAAA,EAAM,eAAA;EAAA;EACpE,SAAA,EAAW,MAAA;AAAA"}
+{"version":3,"file":"factories.d.mts","names":[],"sources":["../src/factories.ts"],"mappings":";;;;;;iBAgBgB,GAAA,CACd,UAAA,UACA,OAAA,UACA,QAAA,YACA,IAAA;EAAA,SAAkB,IAAA;AAAA,IACjB,aAAa;AAAA,iBASA,EAAA,IAAM,OAAA,sBAA6B,UAAU;AAAA,iBAI7C,MAAA,IAAU,OAAA,sBAA6B,gBAAgB;AAAA,iBAIvD,KAAA,IAAS,OAAA,sBAA6B,KAAK;AAAA,iBAI3C,EAAA,CACd,YAAA,UACA,UAAA,qBACA,eAAA,UACA,aAAA,qBACA,IAAA,GAAO,iBAAA;EAAsB,UAAA;EAAsB,KAAA;EAAiB,WAAA;AAAA,IACnE,UAAU;AAAA,iBAcG,KAAA,CACd,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA,GACxC,IAAA;EACE,EAAA,GAAK,UAAA;EACL,OAAA,YAAmB,gBAAA;EACnB,OAAA,YAAmB,KAAA;EACnB,GAAA,YAAe,UAAA;AAAA,IAEhB,YAAA;AAAA,iBAUa,KAAA,CACd,SAAA,UACA,MAAA,EAAQ,MAAA,SAAe,oBAAA,GACvB,SAAA,GAAW,MAAA,mBACX,WAAA;EAEA,OAAA,EAAS,eAAA;EACT,MAAA,EAAQ,MAAA;IAAA,SAA0B,QAAA;IAAA,SAA4B,IAAA,EAAM,eAAA;EAAA;EACpE,SAAA,EAAW,MAAA;AAAA"}

package/dist/factories.mjs

@@ -1,13 +1,14 @@
-import { a as StorageTable, c as Index, l as PrimaryKey, o as UniqueConstraint, s as StorageColumn, u as ForeignKey } from "./entity-kinds-Cl36zL5j.mjs";
-import { r as applyFkDefaults } from "./types-B-eiQXff.mjs";
+import { a as PrimaryKey, i as Index, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, t as StorageTable } from "./storage-table-y6R6pxyI.mjs";
+import { r as applyFkDefaults } from "./types-Hkxybhdj.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
 //#region src/factories.ts
-function col(nativeType, codecId, nullable = false) {
+function col(nativeType, codecId, nullable = false, opts) {
 	return new StorageColumn({
 		nativeType,
 		codecId,
-		nullable
+		nullable,
+		...opts?.many !== void 0 && { many: opts.many }
 	});
 }
 function pk(...columns) {

package/dist/factories.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"factories.mjs","names":[],"sources":["../src/factories.ts"],"sourcesContent":["import { asNamespaceId, type ScalarFieldType } from '@prisma-next/contract/types';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  applyFkDefaults,\n  ForeignKey,\n  type ForeignKeyOptions,\n  Index,\n  PrimaryKey,\n  type SqlModelFieldStorage,\n  type SqlModelStorage,\n  StorageColumn,\n  type StorageColumnInput,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nexport function col(nativeType: string, codecId: string, nullable = false): StorageColumn {\n  return new StorageColumn({ nativeType, codecId, nullable });\n}\n\nexport function pk(...columns: readonly string[]): PrimaryKey {\n  return new PrimaryKey({ columns });\n}\n\nexport function unique(...columns: readonly string[]): UniqueConstraint {\n  return new UniqueConstraint({ columns });\n}\n\nexport function index(...columns: readonly string[]): Index {\n  return new Index({ columns });\n}\n\nexport function fk(\n  srcTableName: string,\n  srcColumns: readonly string[],\n  targetTableName: string,\n  targetColumns: readonly string[],\n  opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean; namespaceId?: string },\n): ForeignKey {\n  const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });\n  const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);\n  return new ForeignKey({\n    source: { namespaceId, tableName: srcTableName, columns: srcColumns },\n    target: { namespaceId, tableName: targetTableName, columns: targetColumns },\n    ...(opts?.name !== undefined && { name: opts.name }),\n    ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),\n    ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),\n    constraint: defaults.constraint,\n    index: defaults.index,\n  });\n}\n\nexport function table(\n  columns: Record<string, StorageColumn | StorageColumnInput>,\n  opts?: {\n    pk?: PrimaryKey;\n    uniques?: readonly UniqueConstraint[];\n    indexes?: readonly Index[];\n    fks?: readonly ForeignKey[];\n  },\n): StorageTable {\n  return new StorageTable({\n    columns,\n    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),\n    uniques: opts?.uniques ?? [],\n    indexes: opts?.indexes ?? [],\n    foreignKeys: opts?.fks ?? [],\n  });\n}\n\nexport function model(\n  tableName: string,\n  fields: Record<string, SqlModelFieldStorage>,\n  relations: Record<string, unknown> = {},\n  namespaceId: string = UNBOUND_NAMESPACE_ID,\n): {\n  storage: SqlModelStorage;\n  fields: Record<string, { readonly nullable: boolean; readonly type: ScalarFieldType }>;\n  relations: Record<string, unknown>;\n} {\n  const storage: SqlModelStorage = { table: tableName, namespaceId, fields };\n  const domainFields = Object.fromEntries(\n    Object.entries(fields).map(([name, field]) => [\n      name,\n      {\n        nullable: field.nullable ?? false,\n        type: { kind: 'scalar' as const, codecId: field.codecId ?? 'core/unknown@1' },\n      },\n    ]),\n  ) as Record<string, { nullable: boolean; type: ScalarFieldType }>;\n  return {\n    storage,\n    fields: domainFields,\n    relations,\n  };\n}\n"],"mappings":";;;;;AAgBA,SAAgB,IAAI,YAAoB,SAAiB,WAAW,OAAsB;CACxF,OAAO,IAAI,cAAc;EAAE;EAAY;EAAS;CAAS,CAAC;AAC5D;AAEA,SAAgB,GAAG,GAAG,SAAwC;CAC5D,OAAO,IAAI,WAAW,EAAE,QAAQ,CAAC;AACnC;AAEA,SAAgB,OAAO,GAAG,SAA8C;CACtE,OAAO,IAAI,iBAAiB,EAAE,QAAQ,CAAC;AACzC;AAEA,SAAgB,MAAM,GAAG,SAAmC;CAC1D,OAAO,IAAI,MAAM,EAAE,QAAQ,CAAC;AAC9B;AAEA,SAAgB,GACd,cACA,YACA,iBACA,eACA,MACY;CACZ,MAAM,WAAW,gBAAgB;EAAE,YAAY,MAAM;EAAY,OAAO,MAAM;CAAM,CAAC;CACrF,MAAM,cAAc,cAAc,MAAM,eAAe,oBAAoB;CAC3E,OAAO,IAAI,WAAW;EACpB,QAAQ;GAAE;GAAa,WAAW;GAAc,SAAS;EAAW;EACpE,QAAQ;GAAE;GAAa,WAAW;GAAiB,SAAS;EAAc;EAC1E,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,KAAK,KAAK;EAClD,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,YAAY,SAAS;EACrB,OAAO,SAAS;CAClB,CAAC;AACH;AAEA,SAAgB,MACd,SACA,MAMc;CACd,OAAO,IAAI,aAAa;EACtB;EACA,GAAI,MAAM,OAAO,KAAA,KAAa,EAAE,YAAY,KAAK,GAAG;EACpD,SAAS,MAAM,WAAW,CAAC;EAC3B,SAAS,MAAM,WAAW,CAAC;EAC3B,aAAa,MAAM,OAAO,CAAC;CAC7B,CAAC;AACH;AAEA,SAAgB,MACd,WACA,QACA,YAAqC,CAAC,GACtC,cAAsB,sBAKtB;CAWA,OAAO;EACL,SAAA;GAXiC,OAAO;GAAW;GAAa;EAW1D;EACN,QAXmB,OAAO,YAC1B,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAC5C,MACA;GACE,UAAU,MAAM,YAAY;GAC5B,MAAM;IAAE,MAAM;IAAmB,SAAS,MAAM,WAAW;GAAiB;EAC9E,CACF,CAAC,CAIkB;EACnB;CACF;AACF"}
+{"version":3,"file":"factories.mjs","names":[],"sources":["../src/factories.ts"],"sourcesContent":["import { asNamespaceId, type ScalarFieldType } from '@prisma-next/contract/types';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport {\n  applyFkDefaults,\n  ForeignKey,\n  type ForeignKeyOptions,\n  Index,\n  PrimaryKey,\n  type SqlModelFieldStorage,\n  type SqlModelStorage,\n  StorageColumn,\n  type StorageColumnInput,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nexport function col(\n  nativeType: string,\n  codecId: string,\n  nullable = false,\n  opts?: { readonly many?: boolean },\n): StorageColumn {\n  return new StorageColumn({\n    nativeType,\n    codecId,\n    nullable,\n    ...(opts?.many !== undefined && { many: opts.many }),\n  });\n}\n\nexport function pk(...columns: readonly string[]): PrimaryKey {\n  return new PrimaryKey({ columns });\n}\n\nexport function unique(...columns: readonly string[]): UniqueConstraint {\n  return new UniqueConstraint({ columns });\n}\n\nexport function index(...columns: readonly string[]): Index {\n  return new Index({ columns });\n}\n\nexport function fk(\n  srcTableName: string,\n  srcColumns: readonly string[],\n  targetTableName: string,\n  targetColumns: readonly string[],\n  opts?: ForeignKeyOptions & { constraint?: boolean; index?: boolean; namespaceId?: string },\n): ForeignKey {\n  const defaults = applyFkDefaults({ constraint: opts?.constraint, index: opts?.index });\n  const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);\n  return new ForeignKey({\n    source: { namespaceId, tableName: srcTableName, columns: srcColumns },\n    target: { namespaceId, tableName: targetTableName, columns: targetColumns },\n    ...(opts?.name !== undefined && { name: opts.name }),\n    ...(opts?.onDelete !== undefined && { onDelete: opts.onDelete }),\n    ...(opts?.onUpdate !== undefined && { onUpdate: opts.onUpdate }),\n    constraint: defaults.constraint,\n    index: defaults.index,\n  });\n}\n\nexport function table(\n  columns: Record<string, StorageColumn | StorageColumnInput>,\n  opts?: {\n    pk?: PrimaryKey;\n    uniques?: readonly UniqueConstraint[];\n    indexes?: readonly Index[];\n    fks?: readonly ForeignKey[];\n  },\n): StorageTable {\n  return new StorageTable({\n    columns,\n    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),\n    uniques: opts?.uniques ?? [],\n    indexes: opts?.indexes ?? [],\n    foreignKeys: opts?.fks ?? [],\n  });\n}\n\nexport function model(\n  tableName: string,\n  fields: Record<string, SqlModelFieldStorage>,\n  relations: Record<string, unknown> = {},\n  namespaceId: string = UNBOUND_NAMESPACE_ID,\n): {\n  storage: SqlModelStorage;\n  fields: Record<string, { readonly nullable: boolean; readonly type: ScalarFieldType }>;\n  relations: Record<string, unknown>;\n} {\n  const storage: SqlModelStorage = { table: tableName, namespaceId, fields };\n  const domainFields = Object.fromEntries(\n    Object.entries(fields).map(([name, field]) => [\n      name,\n      {\n        nullable: field.nullable ?? false,\n        type: { kind: 'scalar' as const, codecId: field.codecId ?? 'core/unknown@1' },\n      },\n    ]),\n  ) as Record<string, { nullable: boolean; type: ScalarFieldType }>;\n  return {\n    storage,\n    fields: domainFields,\n    relations,\n  };\n}\n"],"mappings":";;;;;AAgBA,SAAgB,IACd,YACA,SACA,WAAW,OACX,MACe;CACf,OAAO,IAAI,cAAc;EACvB;EACA;EACA;EACA,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,KAAK,KAAK;CACpD,CAAC;AACH;AAEA,SAAgB,GAAG,GAAG,SAAwC;CAC5D,OAAO,IAAI,WAAW,EAAE,QAAQ,CAAC;AACnC;AAEA,SAAgB,OAAO,GAAG,SAA8C;CACtE,OAAO,IAAI,iBAAiB,EAAE,QAAQ,CAAC;AACzC;AAEA,SAAgB,MAAM,GAAG,SAAmC;CAC1D,OAAO,IAAI,MAAM,EAAE,QAAQ,CAAC;AAC9B;AAEA,SAAgB,GACd,cACA,YACA,iBACA,eACA,MACY;CACZ,MAAM,WAAW,gBAAgB;EAAE,YAAY,MAAM;EAAY,OAAO,MAAM;CAAM,CAAC;CACrF,MAAM,cAAc,cAAc,MAAM,eAAe,oBAAoB;CAC3E,OAAO,IAAI,WAAW;EACpB,QAAQ;GAAE;GAAa,WAAW;GAAc,SAAS;EAAW;EACpE,QAAQ;GAAE;GAAa,WAAW;GAAiB,SAAS;EAAc;EAC1E,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,KAAK,KAAK;EAClD,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,GAAI,MAAM,aAAa,KAAA,KAAa,EAAE,UAAU,KAAK,SAAS;EAC9D,YAAY,SAAS;EACrB,OAAO,SAAS;CAClB,CAAC;AACH;AAEA,SAAgB,MACd,SACA,MAMc;CACd,OAAO,IAAI,aAAa;EACtB;EACA,GAAI,MAAM,OAAO,KAAA,KAAa,EAAE,YAAY,KAAK,GAAG;EACpD,SAAS,MAAM,WAAW,CAAC;EAC3B,SAAS,MAAM,WAAW,CAAC;EAC3B,aAAa,MAAM,OAAO,CAAC;CAC7B,CAAC;AACH;AAEA,SAAgB,MACd,WACA,QACA,YAAqC,CAAC,GACtC,cAAsB,sBAKtB;CAWA,OAAO;EACL,SAAA;GAXiC,OAAO;GAAW;GAAa;EAW1D;EACN,QAXmB,OAAO,YAC1B,OAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAC5C,MACA;GACE,UAAU,MAAM,YAAY;GAC5B,MAAM;IAAE,MAAM;IAAmB,SAAS,MAAM,WAAW;GAAiB;EAC9E,CACF,CAAC,CAIkB;EACnB;CACF;AACF"}

package/dist/{foreign-key-BATxB95l.d.mts → foreign-key-DM1UTydh.d.mts}

@@ -1,44 +1,6 @@
-import { IRNodeBase } from "@prisma-next/framework-components/ir";
+import { t as SqlNode } from "./sql-node-V214WXQD.mjs";
 import { NamespaceId } from "@prisma-next/contract/types";
 
-//#region src/ir/sql-node.d.ts
-/**
- * SQL family IR node base. Carries the family-level `kind` discriminator
- * `'sql'` and inherits the framework's `freezeNode` affordance.
- *
- * Single family-level discriminator (not per-leaf) reflects the fact that
- * SQL IR has no polymorphic dispatch today — verifiers and serializers
- * walk by structural position (`storage.tables[name].columns[name]`),
- * not by inspecting `kind`. The abstract bar for per-leaf discriminators
- * isn't earned until a future polymorphic consumer arrives.
- *
- * `kind` is installed as a non-enumerable own property on every instance,
- * which keeps three things clean simultaneously:
- *
- * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
- *   shape (no `kind` field), so emitted contract.json files and the
- *   `validateSqlContractFully` arktype schemas stay unchanged.
- * - Test assertions that use `toEqual({...})` against the pre-lift flat
- *   shape continue to pass — only enumerable own properties are
- *   compared.
- * - Direct access (`node.kind`) and runtime narrowing
- *   (`if (node.kind === 'sql')`) still work, so future polymorphic
- *   dispatch can begin reading `kind` without a runtime change.
- *
- * Future per-leaf overrides land cleanly: a class that gains a
- * polymorphic-dispatch consumer (e.g. an enum type instance walked
- * alongside other types) overrides `kind` with its narrower literal
- * at that leaf level. Per-leaf overrides will use enumerable kind
- * (matching the Mongo per-class-discriminator precedent) because they
- * encode dispatch-relevant information that callers need to see in
- * JSON envelopes; the family-level `'sql'` is uniform across all SQL
- * IR and carries no dispatch-relevant information.
- */
-declare abstract class SqlNode extends IRNodeBase {
-  readonly kind?: string;
-  constructor();
-}
-//#endregion
 //#region src/ir/foreign-key-reference.d.ts
 /**
  * Input for a foreign-key reference (one side of a foreign-key declaration).
@@ -117,5 +79,5 @@ declare class ForeignKey extends SqlNode {
   constructor(input: ForeignKeyInput);
 }
 //#endregion
-export { ForeignKeyReferenceInput as a, ForeignKeyReference as i, ForeignKeyInput as n, SqlNode as o, ReferentialAction as r, ForeignKey as t };
-//# sourceMappingURL=foreign-key-BATxB95l.d.mts.map
+export { ForeignKeyReferenceInput as a, ForeignKeyReference as i, ForeignKeyInput as n, ReferentialAction as r, ForeignKey as t };
+//# sourceMappingURL=foreign-key-DM1UTydh.d.mts.map

package/dist/foreign-key-DM1UTydh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-DM1UTydh.d.mts","names":[],"sources":["../src/ir/foreign-key-reference.ts","../src/ir/foreign-key.ts"],"mappings":";;;;;;AAeA;;;;;;;;;UAAiB,wBAAA;EAAA,SACN,WAAA;EAAA,SACA,SAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;AAAA;;;;;;;;;;;;;;AAyBkC;;;cANhC,mBAAA,SAA4B,OAAA;EAAA,SAC9B,WAAA,EAAa,WAAA;EAAA,SACb,SAAA;EAAA,SACA,OAAA;EAAA,SACQ,OAAA;cAEL,KAAA,EAAO,wBAAA;AAAA;;;KCxCT,iBAAA;AAAA,UAEK,eAAA;EAAA,SACN,MAAA,EAAQ,mBAAA,GAAsB,wBAAA;EAAA,SAC9B,MAAA,EAAQ,mBAAA,GAAsB,wBAAA;EAAA,SAC9B,IAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAA;EDMX;EAAA,SCJA,UAAA;EDMA;EAAA,SCJA,KAAA;AAAA;ADuBX;;;;;;;;;;;;AAAA,cCRa,UAAA,SAAmB,OAAA;EAAA,SACrB,MAAA,EAAQ,mBAAA;EAAA,SACR,MAAA,EAAQ,mBAAA;EAAA,SACR,UAAA;EAAA,SACA,KAAA;EAAA,SACQ,IAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAA;cAEhB,KAAA,EAAO,eAAA;AAAA"}

package/dist/index-type-validation.d.mts

@@ -1,4 +1,4 @@
-import { i as SqlStorage } from "./sql-storage-Dga0jwP2.mjs";
+import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
 import { a as IndexTypeRegistry } from "./index-types-Czsyu7Iw.mjs";
 import { Contract } from "@prisma-next/contract/types";
 

package/dist/referential-action-sql.d.mts

@@ -1,4 +1,4 @@
-import { r as ReferentialAction } from "./foreign-key-BATxB95l.mjs";
+import { r as ReferentialAction } from "./foreign-key-DM1UTydh.mjs";
 
 //#region src/referential-action-sql.d.ts
 /**

package/dist/resolve-storage-table.d.mts

@@ -1,5 +1,5 @@
-import { r as StorageTable } from "./storage-value-set-WnYsIFM8.mjs";
-import { i as SqlStorage } from "./sql-storage-Dga0jwP2.mjs";
+import { t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
+import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
 
 //#region src/resolve-storage-table.d.ts
 interface ResolvedStorageTable {

package/dist/sql-node-V214WXQD.d.mts

@@ -0,0 +1,42 @@
+import { IRNodeBase } from "@prisma-next/framework-components/ir";
+
+//#region src/ir/sql-node.d.ts
+/**
+ * SQL family IR node base. Carries the family-level `kind` discriminator
+ * `'sql'` and inherits the framework's `freezeNode` affordance.
+ *
+ * Single family-level discriminator (not per-leaf) reflects the fact that
+ * SQL IR has no polymorphic dispatch today — verifiers and serializers
+ * walk by structural position (`storage.tables[name].columns[name]`),
+ * not by inspecting `kind`. The abstract bar for per-leaf discriminators
+ * isn't earned until a future polymorphic consumer arrives.
+ *
+ * `kind` is installed as a non-enumerable own property on every instance,
+ * which keeps three things clean simultaneously:
+ *
+ * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope
+ *   shape (no `kind` field), so emitted contract.json files and the
+ *   `validateSqlContractFully` arktype schemas stay unchanged.
+ * - Test assertions that use `toEqual({...})` against the pre-lift flat
+ *   shape continue to pass — only enumerable own properties are
+ *   compared.
+ * - Direct access (`node.kind`) and runtime narrowing
+ *   (`if (node.kind === 'sql')`) still work, so future polymorphic
+ *   dispatch can begin reading `kind` without a runtime change.
+ *
+ * Future per-leaf overrides land cleanly: a class that gains a
+ * polymorphic-dispatch consumer (e.g. an enum type instance walked
+ * alongside other types) overrides `kind` with its narrower literal
+ * at that leaf level. Per-leaf overrides will use enumerable kind
+ * (matching the Mongo per-class-discriminator precedent) because they
+ * encode dispatch-relevant information that callers need to see in
+ * JSON envelopes; the family-level `'sql'` is uniform across all SQL
+ * IR and carries no dispatch-relevant information.
+ */
+declare abstract class SqlNode extends IRNodeBase {
+  readonly kind?: string;
+  constructor();
+}
+//#endregion
+export { SqlNode as t };
+//# sourceMappingURL=sql-node-V214WXQD.d.mts.map

package/dist/sql-node-V214WXQD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-node-V214WXQD.d.mts","names":[],"sources":["../src/ir/sql-node.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAsB,OAAA,SAAgB,UAAU;EAAA,SACrC,IAAA"}