@prisma-next/sql-contract 0.15.0 → 0.16.0-dev.10

package/dist/canonicalization-hooks.d.mts

@@ -1,5 +1,4 @@
 import { PreserveEmptyPredicate, StorageSort } from "@prisma-next/contract/hashing";
-
 //#region src/canonicalization-hooks.d.ts
 declare const sqlContractCanonicalizationHooks: {
   readonly shouldPreserveEmpty: PreserveEmptyPredicate;

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

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;;cAqDa,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":";;cAoDa;WACF,qBAAqB;WACrB,aAAa"}

package/dist/canonicalization-hooks.mjs

@@ -29,16 +29,6 @@ const preserveEmptyPatterns = [
 			"foreignKeys"
 		]
 	],
-	[
-		"storage",
-		"namespaces",
-		"*",
-		"entries",
-		"table",
-		"*",
-		"foreignKeys",
-		["constraint", "index"]
-	],
 	[
 		"storage",
 		"namespaces",

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  matchesPathPattern,\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\n// A literal column default's value is user data, not omittable structure:\n// `@default(false)` (and empty objects/arrays at any depth inside the value)\n// must survive canonicalization, or the emitted contract fails the runtime's\n// structural validation with `default.value … (was missing)`.\nconst columnDefaultValuePrefix = [\n  'storage',\n  'namespaces',\n  '*',\n  'entries',\n  'table',\n  '*',\n  'columns',\n  '*',\n  'default',\n  'value',\n] as const satisfies PathPattern;\n\nconst isColumnDefaultValuePath = (path: readonly string[]): boolean =>\n  path.length >= columnDefaultValuePrefix.length &&\n  matchesPathPattern(path.slice(0, columnDefaultValuePrefix.length), columnDefaultValuePrefix);\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst matchesPreserveEmptyPattern = createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate = (path) =>\n  isColumnDefaultValuePath(path) || matchesPreserveEmptyPattern(path);\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":";;AASA,MAAM,wBAAwB;CAC5B;EAAC;EAAW;EAAc;EAAK;EAAW;CAAO;CACjD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;CAAG;CACtD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;GAAC;GAAW;GAAW;EAAa;CAAC;CAC7F;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;EAAe,CAAC,cAAc,OAAO;CAAC;CAK9F;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;EAAW;EAAK;EAAW;CAAO;AAC5F;AAMA,MAAM,2BAA2B;CAC/B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,4BAA4B,SAChC,KAAK,UAAU,yBAAyB,UACxC,mBAAmB,KAAK,MAAM,GAAG,yBAAyB,MAAM,GAAG,wBAAwB;AAE7F,MAAM,cAAc,CAClB;CAAE,MAAM;EAAC;EAAc;EAAK;EAAW;EAAS;CAAG;CAAG,WAAW,CAAC,WAAW,SAAS;AAAE,CAC1F;AAEA,MAAM,8BAA8B,6BAA6B,qBAAqB;AAEtF,MAAM,uBAA+C,SACnD,yBAAyB,IAAI,KAAK,4BAA4B,IAAI;AAIpE,MAAa,mCAGT;CACF;CACA,aAP+B,kBAAkB,WAOjD;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  matchesPathPattern,\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  // 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 (CONTRACT.VALIDATION_FAILED on `Boolean @default(false)`).\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'columns', '*', 'default', 'value'],\n] as const satisfies readonly PathPattern[];\n\n// A literal column default's value is user data, not omittable structure:\n// `@default(false)` (and empty objects/arrays at any depth inside the value)\n// must survive canonicalization, or the emitted contract fails the runtime's\n// structural validation with `default.value … (was missing)`.\nconst columnDefaultValuePrefix = [\n  'storage',\n  'namespaces',\n  '*',\n  'entries',\n  'table',\n  '*',\n  'columns',\n  '*',\n  'default',\n  'value',\n] as const satisfies PathPattern;\n\nconst isColumnDefaultValuePath = (path: readonly string[]): boolean =>\n  path.length >= columnDefaultValuePrefix.length &&\n  matchesPathPattern(path.slice(0, columnDefaultValuePrefix.length), columnDefaultValuePrefix);\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst matchesPreserveEmptyPattern = createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate = (path) =>\n  isColumnDefaultValuePath(path) || matchesPreserveEmptyPattern(path);\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":";;AASA,MAAM,wBAAwB;CAC5B;EAAC;EAAW;EAAc;EAAK;EAAW;CAAO;CACjD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;CAAG;CACtD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;GAAC;GAAW;GAAW;EAAa;CAAC;CAK7F;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;EAAW;EAAK;EAAW;CAAO;AAC5F;AAMA,MAAM,2BAA2B;CAC/B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,4BAA4B,SAChC,KAAK,UAAU,yBAAyB,UACxC,mBAAmB,KAAK,MAAM,GAAG,yBAAyB,MAAM,GAAG,wBAAwB;AAE7F,MAAM,cAAc,CAClB;CAAE,MAAM;EAAC;EAAc;EAAK;EAAW;EAAS;CAAG;CAAG,WAAW,CAAC,WAAW,SAAS;AAAE,CAC1F;AAEA,MAAM,8BAA8B,6BAA6B,qBAAqB;AAEtF,MAAM,uBAA+C,SACnD,yBAAyB,IAAI,KAAK,4BAA4B,IAAI;AAIpE,MAAa,mCAGT;CACF;CACA,aAP+B,kBAAkB,WAOjD;AACF"}

package/dist/contract-errors-CPZcBw8G.mjs

@@ -0,0 +1,9 @@
+import { structuredError } from "@prisma-next/utils/structured-error";
+//#region src/contract-errors.ts
+function contractError(code, message, options) {
+	return structuredError(code, message, options);
+}
+//#endregion
+export { contractError as t };
+
+//# sourceMappingURL=contract-errors-CPZcBw8G.mjs.map

package/dist/contract-errors-CPZcBw8G.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-errors-CPZcBw8G.mjs","names":[],"sources":["../src/contract-errors.ts"],"sourcesContent":["import type { StructuredError, StructuredErrorOptions } from '@prisma-next/utils/structured-error';\nimport { structuredError } from '@prisma-next/utils/structured-error';\n\ntype ContractCode = `CONTRACT.${ContractSubcode}`;\n\ntype ContractSubcode = 'PACK_CONTRIBUTION_INVALID' | 'TABLE_AMBIGUOUS' | 'VALIDATION_FAILED';\n\nexport function contractError(\n  code: ContractCode,\n  message: string,\n  options?: StructuredErrorOptions,\n): StructuredError {\n  return structuredError(code, message, options);\n}\n"],"mappings":";;AAOA,SAAgB,cACd,MACA,SACA,SACiB;CACjB,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC/C"}

package/dist/contract-view.d.mts

@@ -1,7 +1,6 @@
-import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
+import { s as SqlStorage } from "./sql-storage-BIErcfFA.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

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

@@ -1 +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"}
+{"version":3,"file":"contract-view.d.mts","names":[],"sources":["../src/contract-view.ts"],"mappings":";;;;;;;;;cAea;KACD,yBAAyB;KAEhC,WAAW,kBAAkB,SAAS,eAAe,wBACxD;;;;;;;KASU,4BAA4B,kBAAkB,SAAS,eACjE,oBAAoB,WAAW,YAAY;;;;;;;;;;KAWjC,uBAAuB,kBAAkB,SAAS,eAAe,YAC3E,4BAA4B;WACjB,WAAW,mBAAmB,sBAAsB;;;;;;;;;iBAUjD,4BAA4B,kBAAkB,SAAS,aACrE,UAAU,YACT,uBAAuB;;;;;;;;;;;KAyBd,uBAAuB,kBAAkB,SAAS,eAAe;WAClE,WAAW,mBAAmB,sBAAsB;;;;;;iBAO/C,4BAA4B,kBAAkB,SAAS,aACrE,UAAU,YACT,uBAAuB"}

package/dist/entity-handle-lowering-hook.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-handle-lowering-hook.d.mts","names":[],"sources":["../src/entity-handle-lowering-hook.ts"],"mappings":";;AAwBA;;;;;;;;;AAEiC;AAUjC;;;;;;;;;;;;UAZiB,gBAAA;EAAA,SACN,UAAA;EAAA,SACA,IAAA,GAAO,QAAQ,CAAC,MAAA;AAAA;AA0BH;AAIxB;;;;;;AAJwB,KAhBZ,uBAAA;EAAA,SAEG,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,SAAA;AAAA;;UAIE,wBAAA;EAAA,SACN,MAAA,EAAQ,gBAAA;EAAA,SACR,IAAA,EAAM,QAAA,CAAS,MAAA,SAAe,uBAAA;AAAA;AAAA,UAGxB,yBAAA;EAOiB;EAAA,SALvB,OAAA,WAAkB,wBAAwB;EAAA,SAC1C,kBAAA;AAAA;;UAIM,iBAAA;EAAA,SACN,WAAA;EAAA,SACA,UAAA;EAAA,SACA,GAAA;EAAA,SACA,MAAA;AAAA;AAAA,UAGM,mCAAA;EAMiE;;;;;EAAhF,kBAAA,CAAmB,KAAA,EAAO,yBAAA,YAAqC,iBAAiB;AAAA;AAIlF;AAAA,iBAAgB,4BAAA,CACd,SAAA,YACC,SAAA,IAAa,mCAAmC;;;;;;;AAAA;AAgBnD;KAAY,oBAAA,GAAuB,QAAQ,CAAC,MAAA;EAAA,SAA0B,SAAA;AAAA"}
+{"version":3,"file":"entity-handle-lowering-hook.d.mts","names":[],"sources":["../src/entity-handle-lowering-hook.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;UAwBiB;WACN;WACA,OAAO,SAAS;;;;;;;;;KAUf;WAEG;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;;;UAIE;WACN,QAAQ;WACR,MAAM,SAAS,eAAe;;UAGxB;;WAEN,kBAAkB;WAClB;;;UAIM;WACN;WACA;WACA;WACA;;UAGM;;;;;;EAMf,mBAAmB,OAAO,qCAAqC;;;iBAIjD,6BACd,qBACC,aAAa;;;;;;;;;KAgBJ,uBAAuB,SAAS;WAA0B"}

package/dist/{entity-kinds-BEPZdFBN.mjs → entity-kinds-La8Jg-jW.mjs}

@@ -1,5 +1,6 @@
-import { t as StorageTable } from "./storage-table-y6R6pxyI.mjs";
-import { t as StorageValueSet } from "./storage-value-set-Tx3CFoS_.mjs";
+import { t as contractError } from "./contract-errors-CPZcBw8G.mjs";
+import { t as StorageTable } from "./storage-table-9O0ZNiMs.mjs";
+import { t as StorageValueSet } from "./storage-value-set-DiGJT-LT.mjs";
 import { type } from "arktype";
 //#region src/ir/storage-entry-schemas.ts
 const literalKindSchema = type("'literal'");
@@ -78,9 +79,7 @@ const ForeignKeySchema = type.declare().type({
 	target: ForeignKeyReferenceSchema,
 	"name?": "string",
 	"onDelete?": ReferentialActionSchema,
-	"onUpdate?": ReferentialActionSchema,
-	constraint: "boolean",
-	index: "boolean"
+	"onUpdate?": ReferentialActionSchema
 });
 const CheckConstraintSchema = type({
 	"+": "reject",
@@ -121,7 +120,7 @@ const valueSetEntityKind = {
 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`);
+		if (kinds.has(descriptor.kind)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`, { meta: { entityKind: descriptor.kind } });
 		kinds.set(descriptor.kind, descriptor);
 	}
 	return kinds;
@@ -129,4 +128,4 @@ function composeSqlEntityKinds(packKinds = []) {
 //#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
+//# sourceMappingURL=entity-kinds-La8Jg-jW.mjs.map

package/dist/entity-kinds-La8Jg-jW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-La8Jg-jW.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});\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 { contractError } from './contract-errors';\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 contractError(\n        'CONTRACT.PACK_CONTRIBUTION_INVALID',\n        `composeSqlEntityKinds: duplicate entity kind \"${descriptor.kind}\" — each kind may be registered only once`,\n        { meta: { entityKind: descriptor.kind } },\n      );\n    }\n    kinds.set(descriptor.kind, descriptor);\n  }\n  return kinds;\n}\n"],"mappings":";;;;;AAYA,MAAM,oBAAoB,KAAK,WAAW;AAC1C,MAAM,qBAAqB,KAAK,YAAY;AAC5C,MAAM,sBAAsB,KAAK,mDAAmD;AAEpF,MAAa,6BAA6B,KAAK,QAA8B,CAAC,CAAC,KAAK;CAClF,MAAM;CACN,OAAO;AACT,CAAC;AAED,MAAa,8BAA8B,KAAK,QAA+B,CAAC,CAAC,KAAK;CACpF,MAAM;CACN,YAAY;AACd,CAAC;AAED,MAAa,sBAAsB,2BAA2B,GAAG,2BAA2B;AAE5F,MAAM,2BAA2B,KAAK;CACpC,OAAO;CACP,aAAa;CACb,YAAY;CACZ,YAAY;CACZ,YAAY;AACd,CAAC;AAED,MAAM,sBAAsB,KAAK;CAC/B,KAAK;CACL,YAAY;CACZ,SAAS;CACT,UAAU;CACV,SAAS;CACT,eAAe;CACf,YAAY;CACZ,YAAY;CACZ,YAAY;CACZ,aAAa;AACf,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ;CACtB,IAAI,IAAI,eAAe,KAAA,KAAa,IAAI,YAAY,KAAA,GAClD,OAAO,IAAI,OAAO,sDAAsD;CAE1E,OAAO;AACT,CAAC;;;;;;AAOD,MAAa,wBAAwB,KAAK;CACxC,MAAM;CACN,QAAQ,KAAK,wEAAwE,CAAC,CACnF,MAAM,CAAC,CACP,SAAS;AACd,CAAC;AAED,MAAM,mBAAmB,KAAK,QAAyB,CAAC,CAAC,KAAK;CAC5D,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACtC,SAAS;AACX,CAAC;AAED,MAAM,yBAAyB,KAAK,QAA+B,CAAC,CAAC,KAAK;CACxE,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACtC,SAAS;AACX,CAAC;AAED,MAAa,cAAc,KAAK;CAC9B,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACtC,SAAS;CACT,SAAS;CACT,YAAY;AACd,CAAC;AAED,MAAa,4BAA4B,KAAK;CAC5C,KAAK;CACL,aAAa;CACb,WAAW;CACX,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACtC,YAAY;AACd,CAAC;AAED,MAAa,yBAAyB,KAAK;CACzC,KAAK;CACL,aAAa;CACb,WAAW;CACX,SAAS,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;AACxC,CAAC;AAED,MAAa,0BAA0B,KACpC,QAA2B,CAAC,CAC5B,KAAK,gEAAgE;AAExE,MAAa,mBAAmB,KAAK,QAAyB,CAAC,CAAC,KAAK;CACnE,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,aAAa;CACb,aAAa;AACf,CAAC;AAED,MAAa,wBAAwB,KAAK;CACxC,KAAK;CACL,MAAM;CACN,QAAQ;CACR,UAAU;AACZ,CAAC;AAED,MAAa,qBAAqB,KAAK;CACrC,KAAK;CACL,SAAS,KAAK,EAAE,YAAY,oBAAoB,CAAC;CACjD,eAAe;CACf,SAAS,uBAAuB,MAAM,CAAC,CAAC,SAAS;CACjD,SAAS,YAAY,MAAM,CAAC,CAAC,SAAS;CACtC,aAAa,iBAAiB,MAAM,CAAC,CAAC,SAAS;CAC/C,YAAY;CACZ,WAAW,sBAAsB,MAAM,CAAC,CAAC,SAAS;AACpD,CAAC;;;ACrHD,MAAa,kBAAyE;CACpF,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,aAAa,KAAK;AAC9C;AAEA,MAAa,qBAAkF;CAC7F,MAAM;CACN,QAAQ;CACR,YAAY,UAAU,IAAI,gBAAgB,KAAK;AACjD;;;;;;;;;AAUA,SAAgB,sBACd,YAAgD,CAAC,GACH;CAC9C,MAAM,wBAAQ,IAAI,IAAqC,CACrD,CAAC,SAAS,eAAe,GACzB,CAAC,YAAY,kBAAkB,CACjC,CAAC;CACD,KAAK,MAAM,cAAc,WAAW;EAClC,IAAI,MAAM,IAAI,WAAW,IAAI,GAC3B,MAAM,cACJ,sCACA,iDAAiD,WAAW,KAAK,4CACjE,EAAE,MAAM,EAAE,YAAY,WAAW,KAAK,EAAE,CAC1C;EAEF,MAAM,IAAI,WAAW,MAAM,UAAU;CACvC;CACA,OAAO;AACT"}

package/dist/entity-kinds.d.mts

@@ -1,7 +1,6 @@
-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 { n as StorageTableInput, t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { n as StorageValueSetInput, t as StorageValueSet } from "./storage-value-set-DPHvvSdB.mjs";
 import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma-next/framework-components/ir";
-
 //#region src/entity-kinds.d.ts
 declare const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable>;
 declare const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet>;

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;AAN5E;;;;;;;;AAAA,iBAoBgB,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}
+{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;cASa,iBAAiB,qBAAqB,mBAAmB;cAMzD,oBAAoB,qBAAqB,sBAAsB;;;;;;;;;iBAc5D,sBACd,qBAAoB,4BACnB,oBAAoB"}

package/dist/entity-kinds.mjs

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

package/dist/factories.d.mts

@@ -1,8 +1,8 @@
-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 { i as StorageColumnInput, r as StorageColumn, t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { t as ForeignKey } from "./foreign-key-CWCEM2IT.mjs";
+import { a as PrimaryKey, r as Index, t as UniqueConstraint } from "./unique-constraint-WHfanEUq.mjs";
+import { T as SqlModelStorage, m as ForeignKeyOptions, w as SqlModelFieldStorage } from "./types-lpzJtKpv.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
-
 //#region src/factories.d.ts
 declare function col(nativeType: string, codecId: string, nullable?: boolean, opts?: {
   readonly many?: boolean;
@@ -11,8 +11,6 @@ declare function pk(...columns: readonly string[]): PrimaryKey;
 declare function unique(...columns: readonly string[]): UniqueConstraint;
 declare function index(...columns: readonly string[]): Index;
 declare function fk(srcTableName: string, srcColumns: readonly string[], targetTableName: string, targetColumns: readonly string[], opts?: ForeignKeyOptions & {
-  constraint?: boolean;
-  index?: boolean;
   namespaceId?: string;
 }): ForeignKey;
 declare function table(columns: Record<string, StorageColumn | StorageColumnInput>, opts?: {

package/dist/factories.d.mts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"factories.d.mts","names":[],"sources":["../src/factories.ts"],"mappings":";;;;;;iBAegB,IACd,oBACA,iBACA,oBACA;WAAkB;IACjB;iBASa,MAAM,6BAA6B;iBAInC,UAAU,6BAA6B;iBAIvC,SAAS,6BAA6B;iBAItC,GACd,sBACA,+BACA,yBACA,kCACA,OAAO;EAAsB;IAC5B;iBAWa,MACd,SAAS,eAAe,gBAAgB,qBACxC;EACE,KAAK;EACL,mBAAmB;EACnB,mBAAmB;EACnB,eAAe;IAEhB;iBAUa,MACd,mBACA,QAAQ,eAAe,uBACvB,YAAW,yBACX;EAEA,SAAS;EACT,QAAQ;aAA0B;aAA4B,MAAM;;EACpE,WAAW"}

package/dist/factories.mjs

@@ -1,5 +1,4 @@
-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 { a as PrimaryKey, i as Index, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, t as StorageTable } from "./storage-table-9O0ZNiMs.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
 //#region src/factories.ts
@@ -21,10 +20,6 @@ function index(...columns) {
 	return new Index({ columns });
 }
 function fk(srcTableName, srcColumns, targetTableName, targetColumns, opts) {
-	const defaults = applyFkDefaults({
-		constraint: opts?.constraint,
-		index: opts?.index
-	});
 	const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);
 	return new ForeignKey({
 		source: {
@@ -39,9 +34,7 @@ function fk(srcTableName, srcColumns, targetTableName, targetColumns, opts) {
 		},
 		...opts?.name !== void 0 && { name: opts.name },
 		...opts?.onDelete !== void 0 && { onDelete: opts.onDelete },
-		...opts?.onUpdate !== void 0 && { onUpdate: opts.onUpdate },
-		constraint: defaults.constraint,
-		index: defaults.index
+		...opts?.onUpdate !== void 0 && { onUpdate: opts.onUpdate }
 	});
 }
 function table(columns, opts) {

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(\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"}
+{"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  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 & { namespaceId?: string },\n): ForeignKey {\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  });\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":";;;;AAeA,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,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;CAChE,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-DM1UTydh.d.mts → foreign-key-CWCEM2IT.d.mts}

@@ -1,6 +1,5 @@
-import { t as SqlNode } from "./sql-node-V214WXQD.mjs";
+import { t as SqlNode } from "./sql-node-QXu33IeX.mjs";
 import { NamespaceId } from "@prisma-next/contract/types";
-
 //#region src/ir/foreign-key-reference.d.ts
 /**
  * Input for a foreign-key reference (one side of a foreign-key declaration).
@@ -51,13 +50,17 @@ interface ForeignKeyInput {
   readonly name?: string;
   readonly onDelete?: ReferentialAction;
   readonly onUpdate?: ReferentialAction;
-  /** Whether to emit FK constraint DDL (ALTER TABLE … ADD CONSTRAINT … FOREIGN KEY). */
-  readonly constraint: boolean;
-  /** Whether to emit a backing index for the FK columns. */
-  readonly index: boolean;
 }
 /**
- * SQL Contract IR node for a table-level foreign-key declaration.
+ * SQL Contract IR node for a table-level foreign-key declaration — the
+ * referential constraint only (source, target, `onDelete`/`onUpdate`).
+ *
+ * A persisted `foreignKeys[]` entry always denotes a real constraint: whether
+ * to emit the constraint at all, and whether to back it with an index, are
+ * authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,
+ * index })`) resolved once at `contract emit` — a `constraint: false` FK
+ * simply has no entry here, and a backing index (if any) is its own discrete,
+ * named entry in the table's `indexes[]`.
  *
  * Each FK carries explicit `source` and `target` {@link ForeignKeyReference}
  * coordinates (namespace, table, columns). For single-namespace contracts the
@@ -71,8 +74,6 @@ interface ForeignKeyInput {
 declare class ForeignKey extends SqlNode {
   readonly source: ForeignKeyReference;
   readonly target: ForeignKeyReference;
-  readonly constraint: boolean;
-  readonly index: boolean;
   readonly name?: string;
   readonly onDelete?: ReferentialAction;
   readonly onUpdate?: ReferentialAction;
@@ -80,4 +81,4 @@ declare class ForeignKey extends SqlNode {
 }
 //#endregion
 export { ForeignKeyReferenceInput as a, ForeignKeyReference as i, ForeignKeyInput as n, ReferentialAction as r, ForeignKey as t };
-//# sourceMappingURL=foreign-key-DM1UTydh.d.mts.map
+//# sourceMappingURL=foreign-key-CWCEM2IT.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-CWCEM2IT.d.mts","names":[],"sources":["../src/ir/foreign-key-reference.ts","../src/ir/foreign-key.ts"],"mappings":";;;;;;;;;;;;;;UAeiB;WACN;WACA;WACA;WACA;;;;;;;;;;;;;;;;;;cAmBE,4BAA4B;WAC9B,aAAa;WACb;WACA;WACQ;cAEL,OAAO;;;;KCxCT;UAEK;WACN,QAAQ,sBAAsB;WAC9B,QAAQ,sBAAsB;WAC9B;WACA,WAAW;WACX,WAAW;;;;;;;;;;;;;;;;;;;;;;cAuBT,mBAAmB;WACrB,QAAQ;WACR,QAAQ;WACA;WACA,WAAW;WACX,WAAW;cAEhB,OAAO"}

package/dist/foreign-key-materialization.d.mts

@@ -0,0 +1,63 @@
+import { a as ForeignKeyReferenceInput, n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-CWCEM2IT.mjs";
+import { i as IndexInput, n as UniqueConstraintInput, o as PrimaryKeyInput } from "./unique-constraint-WHfanEUq.mjs";
+//#region src/foreign-key-materialization.d.ts
+type BackingIndexCandidates = {
+  readonly indexes: readonly {
+    readonly columns: readonly string[];
+  }[];
+  readonly uniques: readonly {
+    readonly columns: readonly string[];
+  }[];
+  readonly primaryKey?: {
+    readonly columns: readonly string[];
+  } | undefined;
+};
+/**
+ * The column-list keys (`"colA,colB"`, order preserved) a table's own
+ * indexes, unique constraints, and primary key already back. A foreign key
+ * whose source columns join to one of these keys needs no separately
+ * derived backing index.
+ *
+ * Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`
+ * (deriving the discrete backing-index entities persisted at `contract emit`)
+ * and the postgres PSL inferrer (deciding whether an introspected relation
+ * needs an explicit `index: false`).
+ */
+declare function backingIndexColumnKeys(table: BackingIndexCandidates): readonly string[];
+/**
+ * Whether `columns`, in order, matches one of `backingKeys` (see
+ * {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
+ * satisfy a backing index declared as `(b, a)`.
+ */
+declare function isBackedByColumnKeys(columns: readonly string[], backingKeys: readonly string[]): boolean;
+/**
+ * A foreign key as authored, before FK1 materialization: the referential
+ * coordinates plus the `constraint`/`index` intent booleans that drive
+ * whether — and how — it survives into the persisted contract.
+ */
+interface ForeignKeyAuthoringInput {
+  readonly source: ForeignKeyReferenceInput;
+  readonly target: ForeignKeyReferenceInput;
+  readonly name?: string;
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+  readonly constraint: boolean;
+  readonly index: boolean;
+}
+interface MaterializedTableConstraints {
+  readonly foreignKeys: readonly ForeignKeyInput[];
+  readonly indexes: readonly IndexInput[];
+}
+/**
+ * Lowers a table's authored foreign keys into the discrete entities
+ * `contract.json` persists: a `constraint: false` FK contributes no
+ * `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
+ * backed by a declared index/unique/primary-key contributes a named
+ * `indexes[]` entry (`defaultIndexName`). Declared indexes always survive
+ * unchanged; a second FK sharing already-synthesized backing columns does not
+ * mint a duplicate index.
+ */
+declare function materializeForeignKeysAndIndexes(tableName: string, foreignKeys: readonly ForeignKeyAuthoringInput[], declaredIndexes: readonly IndexInput[], uniques: readonly UniqueConstraintInput[], primaryKey: PrimaryKeyInput | undefined): MaterializedTableConstraints;
+//#endregion
+export { type BackingIndexCandidates, type ForeignKeyAuthoringInput, type MaterializedTableConstraints, backingIndexColumnKeys, isBackedByColumnKeys, materializeForeignKeysAndIndexes };
+//# sourceMappingURL=foreign-key-materialization.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-materialization.d.mts","names":[],"sources":["../src/foreign-key-materialization.ts"],"mappings":";;;KAOY;WACD;aAA6B;;WAC7B;aAA6B;;WAC7B;aAAwB;;;;;;;;;;;;;;iBAcnB,uBAAuB,OAAO;;;;;;iBAa9B,qBACd,4BACA;;;;;;UAUe;WACN,QAAQ;WACR,QAAQ;WACR;WACA,WAAW;WACX,WAAW;WACX;WACA;;UAGM;WACN,sBAAsB;WACtB,kBAAkB;;;;;;;;;;;iBAYb,iCACd,mBACA,sBAAsB,4BACtB,0BAA0B,cAC1B,kBAAkB,yBAClB,YAAY,8BACX"}

package/dist/foreign-key-materialization.mjs

@@ -0,0 +1,67 @@
+import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
+//#region src/foreign-key-materialization.ts
+/**
+* The column-list keys (`"colA,colB"`, order preserved) a table's own
+* indexes, unique constraints, and primary key already back. A foreign key
+* whose source columns join to one of these keys needs no separately
+* derived backing index.
+*
+* Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`
+* (deriving the discrete backing-index entities persisted at `contract emit`)
+* and the postgres PSL inferrer (deciding whether an introspected relation
+* needs an explicit `index: false`).
+*/
+function backingIndexColumnKeys(table) {
+	return [
+		...table.indexes.map((index) => index.columns.join(",")),
+		...table.uniques.map((unique) => unique.columns.join(",")),
+		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
+	];
+}
+/**
+* Whether `columns`, in order, matches one of `backingKeys` (see
+* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
+* satisfy a backing index declared as `(b, a)`.
+*/
+function isBackedByColumnKeys(columns, backingKeys) {
+	return backingKeys.includes(columns.join(","));
+}
+/**
+* Lowers a table's authored foreign keys into the discrete entities
+* `contract.json` persists: a `constraint: false` FK contributes no
+* `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
+* backed by a declared index/unique/primary-key contributes a named
+* `indexes[]` entry (`defaultIndexName`). Declared indexes always survive
+* unchanged; a second FK sharing already-synthesized backing columns does not
+* mint a duplicate index.
+*/
+function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexes, uniques, primaryKey) {
+	const satisfiedIndexColumns = new Set(backingIndexColumnKeys({
+		indexes: declaredIndexes,
+		uniques,
+		primaryKey
+	}));
+	const synthesizedIndexes = [];
+	const materializedForeignKeys = [];
+	for (const { constraint, index, ...reference } of foreignKeys) {
+		if (constraint !== false) materializedForeignKeys.push(reference);
+		if (index !== false) {
+			const key = reference.source.columns.join(",");
+			if (!satisfiedIndexColumns.has(key)) {
+				synthesizedIndexes.push({
+					columns: reference.source.columns,
+					name: defaultIndexName(tableName, reference.source.columns)
+				});
+				satisfiedIndexColumns.add(key);
+			}
+		}
+	}
+	return {
+		foreignKeys: materializedForeignKeys,
+		indexes: [...declaredIndexes, ...synthesizedIndexes]
+	};
+}
+//#endregion
+export { backingIndexColumnKeys, isBackedByColumnKeys, materializeForeignKeysAndIndexes };
+
+//# sourceMappingURL=foreign-key-materialization.mjs.map

package/dist/foreign-key-materialization.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-materialization.mjs","names":[],"sources":["../src/foreign-key-materialization.ts"],"sourcesContent":["import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';\nimport type { ForeignKeyInput, ReferentialAction } from './ir/foreign-key';\nimport type { ForeignKeyReferenceInput } from './ir/foreign-key-reference';\nimport type { PrimaryKeyInput } from './ir/primary-key';\nimport type { IndexInput } from './ir/sql-index';\nimport type { UniqueConstraintInput } from './ir/unique-constraint';\n\nexport type BackingIndexCandidates = {\n  readonly indexes: readonly { readonly columns: readonly string[] }[];\n  readonly uniques: readonly { readonly columns: readonly string[] }[];\n  readonly primaryKey?: { readonly columns: readonly string[] } | undefined;\n};\n\n/**\n * The column-list keys (`\"colA,colB\"`, order preserved) a table's own\n * indexes, unique constraints, and primary key already back. A foreign key\n * whose source columns join to one of these keys needs no separately\n * derived backing index.\n *\n * Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`\n * (deriving the discrete backing-index entities persisted at `contract emit`)\n * and the postgres PSL inferrer (deciding whether an introspected relation\n * needs an explicit `index: false`).\n */\nexport function backingIndexColumnKeys(table: BackingIndexCandidates): readonly string[] {\n  return [\n    ...table.indexes.map((index) => index.columns.join(',')),\n    ...table.uniques.map((unique) => unique.columns.join(',')),\n    ...(table.primaryKey ? [table.primaryKey.columns.join(',')] : []),\n  ];\n}\n\n/**\n * Whether `columns`, in order, matches one of `backingKeys` (see\n * {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not\n * satisfy a backing index declared as `(b, a)`.\n */\nexport function isBackedByColumnKeys(\n  columns: readonly string[],\n  backingKeys: readonly string[],\n): boolean {\n  return backingKeys.includes(columns.join(','));\n}\n\n/**\n * A foreign key as authored, before FK1 materialization: the referential\n * coordinates plus the `constraint`/`index` intent booleans that drive\n * whether — and how — it survives into the persisted contract.\n */\nexport interface ForeignKeyAuthoringInput {\n  readonly source: ForeignKeyReferenceInput;\n  readonly target: ForeignKeyReferenceInput;\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n  readonly constraint: boolean;\n  readonly index: boolean;\n}\n\nexport interface MaterializedTableConstraints {\n  readonly foreignKeys: readonly ForeignKeyInput[];\n  readonly indexes: readonly IndexInput[];\n}\n\n/**\n * Lowers a table's authored foreign keys into the discrete entities\n * `contract.json` persists: a `constraint: false` FK contributes no\n * `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already\n * backed by a declared index/unique/primary-key contributes a named\n * `indexes[]` entry (`defaultIndexName`). Declared indexes always survive\n * unchanged; a second FK sharing already-synthesized backing columns does not\n * mint a duplicate index.\n */\nexport function materializeForeignKeysAndIndexes(\n  tableName: string,\n  foreignKeys: readonly ForeignKeyAuthoringInput[],\n  declaredIndexes: readonly IndexInput[],\n  uniques: readonly UniqueConstraintInput[],\n  primaryKey: PrimaryKeyInput | undefined,\n): MaterializedTableConstraints {\n  const satisfiedIndexColumns = new Set(\n    backingIndexColumnKeys({ indexes: declaredIndexes, uniques, primaryKey }),\n  );\n  const synthesizedIndexes: IndexInput[] = [];\n  const materializedForeignKeys: ForeignKeyInput[] = [];\n\n  for (const { constraint, index, ...reference } of foreignKeys) {\n    if (constraint !== false) {\n      materializedForeignKeys.push(reference);\n    }\n    if (index !== false) {\n      const key = reference.source.columns.join(',');\n      if (!satisfiedIndexColumns.has(key)) {\n        synthesizedIndexes.push({\n          columns: reference.source.columns,\n          name: defaultIndexName(tableName, reference.source.columns),\n        });\n        satisfiedIndexColumns.add(key);\n      }\n    }\n  }\n\n  return {\n    foreignKeys: materializedForeignKeys,\n    indexes: [...declaredIndexes, ...synthesizedIndexes],\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAwBA,SAAgB,uBAAuB,OAAkD;CACvF,OAAO;EACL,GAAG,MAAM,QAAQ,KAAK,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;EACvD,GAAG,MAAM,QAAQ,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,CAAC;EACzD,GAAI,MAAM,aAAa,CAAC,MAAM,WAAW,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;CACjE;AACF;;;;;;AAOA,SAAgB,qBACd,SACA,aACS;CACT,OAAO,YAAY,SAAS,QAAQ,KAAK,GAAG,CAAC;AAC/C;;;;;;;;;;AA+BA,SAAgB,iCACd,WACA,aACA,iBACA,SACA,YAC8B;CAC9B,MAAM,wBAAwB,IAAI,IAChC,uBAAuB;EAAE,SAAS;EAAiB;EAAS;CAAW,CAAC,CAC1E;CACA,MAAM,qBAAmC,CAAC;CAC1C,MAAM,0BAA6C,CAAC;CAEpD,KAAK,MAAM,EAAE,YAAY,OAAO,GAAG,eAAe,aAAa;EAC7D,IAAI,eAAe,OACjB,wBAAwB,KAAK,SAAS;EAExC,IAAI,UAAU,OAAO;GACnB,MAAM,MAAM,UAAU,OAAO,QAAQ,KAAK,GAAG;GAC7C,IAAI,CAAC,sBAAsB,IAAI,GAAG,GAAG;IACnC,mBAAmB,KAAK;KACtB,SAAS,UAAU,OAAO;KAC1B,MAAM,iBAAiB,WAAW,UAAU,OAAO,OAAO;IAC5D,CAAC;IACD,sBAAsB,IAAI,GAAG;GAC/B;EACF;CACF;CAEA,OAAO;EACL,aAAa;EACb,SAAS,CAAC,GAAG,iBAAiB,GAAG,kBAAkB;CACrD;AACF"}

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

@@ -1,7 +1,7 @@
-import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
-import { a as IndexTypeRegistry } from "./index-types-Czsyu7Iw.mjs";
+import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
+import "./types-lpzJtKpv.mjs";
+import { a as IndexTypeRegistry } from "./index-types-DPVhsW0v.mjs";
 import { Contract } from "@prisma-next/contract/types";
-
 //#region src/index-type-validation.d.ts
 declare function validateIndexTypes(contract: Contract<SqlStorage>, indexTypeRegistry: IndexTypeRegistry): void;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"index-type-validation.d.mts","names":[],"sources":["../src/index-type-validation.ts"],"mappings":";;;;;iBAMgB,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,GACnB,iBAAA,EAAmB,iBAAA"}
+{"version":3,"file":"index-type-validation.d.mts","names":[],"sources":["../src/index-type-validation.ts"],"mappings":";;;;;iBAMgB,mBACd,UAAU,SAAS,aACnB,mBAAmB"}

package/dist/{index-types-Czsyu7Iw.d.mts → index-types-DPVhsW0v.d.mts}

@@ -1,5 +1,4 @@
 import { Type } from "arktype";
-
 //#region src/index-types.d.ts
 interface IndexTypeEntry<TOptions = unknown> {
   readonly type: string;
@@ -7,7 +6,7 @@ interface IndexTypeEntry<TOptions = unknown> {
 }
 type IndexTypeMap = { readonly [K in string]: {
   readonly options: unknown;
-} };
+}; };
 interface IndexTypeRegistration<TMap extends IndexTypeMap = Record<never, never>> {
   readonly IndexTypes: TMap;
   readonly entries: ReadonlyArray<IndexTypeEntry>;
@@ -28,4 +27,4 @@ interface IndexTypeRegistry {
 declare function createIndexTypeRegistry(): IndexTypeRegistry;
 //#endregion
 export { IndexTypeRegistry as a, IndexTypeRegistration as i, IndexTypeEntry as n, createIndexTypeRegistry as o, IndexTypeMap as r, defineIndexTypes as s, IndexTypeBuilder as t };
-//# sourceMappingURL=index-types-Czsyu7Iw.d.mts.map
+//# sourceMappingURL=index-types-DPVhsW0v.d.mts.map

package/dist/index-types-DPVhsW0v.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-types-DPVhsW0v.d.mts","names":[],"sources":["../src/index-types.ts"],"mappings":";;UAGiB,eAAe;WACrB;WACA,SAAS,KAAK;;KAGb,2BAA2B;WAAyB;;UAE/C,sBAAsB,aAAa,eAAe;WACxD,YAAY;WACZ,SAAS,cAAc;;UAGjB,iBAAiB,aAAa,eAAe,8BACpD,sBAAsB;EAC9B,IAAI,qBAAqB,OACvB,aAAa,MACb;aAAkB,SAAS,KAAK;MAC/B,iBAAiB,OAAO,OAAO;aAAiB,SAAS;;;iBA8B9C,oBAAoB,iBAAiB;UAIpC;EACf,SAAS,OAAO;EAChB,IAAI,sBAAsB;EAC1B,IAAI;;iBA0BU,2BAA2B"}

package/dist/index-types.d.mts

@@ -1,2 +1,2 @@
-import { a as IndexTypeRegistry, i as IndexTypeRegistration, n as IndexTypeEntry, o as createIndexTypeRegistry, r as IndexTypeMap, s as defineIndexTypes, t as IndexTypeBuilder } from "./index-types-Czsyu7Iw.mjs";
+import { a as IndexTypeRegistry, i as IndexTypeRegistration, n as IndexTypeEntry, o as createIndexTypeRegistry, r as IndexTypeMap, s as defineIndexTypes, t as IndexTypeBuilder } from "./index-types-DPVhsW0v.mjs";
 export { type IndexTypeBuilder, type IndexTypeEntry, type IndexTypeMap, type IndexTypeRegistration, type IndexTypeRegistry, createIndexTypeRegistry, defineIndexTypes };

package/dist/index-types.mjs

@@ -1,3 +1,4 @@
+import { t as contractError } from "./contract-errors-CPZcBw8G.mjs";
 //#region src/index-types.ts
 var IndexTypeBuilderImpl = class IndexTypeBuilderImpl {
 	entries;
@@ -7,7 +8,7 @@ var IndexTypeBuilderImpl = class IndexTypeBuilderImpl {
 		this.IndexTypes = {};
 	}
 	add(typeLiteral, entry) {
-		if (this.entries.some((e) => e.type === typeLiteral)) throw new Error(`Index type "${typeLiteral}" is already declared in this builder`);
+		if (this.entries.some((e) => e.type === typeLiteral)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Index type "${typeLiteral}" is already declared in this builder`, { meta: { indexType: typeLiteral } });
 		return new IndexTypeBuilderImpl([...this.entries, {
 			type: typeLiteral,
 			options: entry.options
@@ -20,7 +21,7 @@ function defineIndexTypes() {
 var IndexTypeRegistryImpl = class {
 	entries = /* @__PURE__ */ new Map();
 	register(entry) {
-		if (this.entries.has(entry.type)) throw new Error(`Index type "${entry.type}" is already registered`);
+		if (this.entries.has(entry.type)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Index type "${entry.type}" is already registered`, { meta: { indexType: entry.type } });
 		this.entries.set(entry.type, entry);
 	}
 	get(typeLiteral) {

package/dist/index-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index-types.mjs","names":[],"sources":["../src/index-types.ts"],"sourcesContent":["import type { Type } from 'arktype';\n\nexport interface IndexTypeEntry<TOptions = unknown> {\n  readonly type: string;\n  readonly options: Type<TOptions>;\n}\n\nexport type IndexTypeMap = { readonly [K in string]: { readonly options: unknown } };\n\nexport interface IndexTypeRegistration<TMap extends IndexTypeMap = Record<never, never>> {\n  readonly IndexTypes: TMap;\n  readonly entries: ReadonlyArray<IndexTypeEntry>;\n}\n\nexport interface IndexTypeBuilder<TMap extends IndexTypeMap = Record<never, never>>\n  extends IndexTypeRegistration<TMap> {\n  add<TLit extends string, TOpts>(\n    typeLiteral: TLit,\n    entry: { readonly options: Type<TOpts> },\n  ): IndexTypeBuilder<TMap & Record<TLit, { readonly options: TOpts }>>;\n}\n\nclass IndexTypeBuilderImpl<TMap extends IndexTypeMap> implements IndexTypeBuilder<TMap> {\n  readonly entries: ReadonlyArray<IndexTypeEntry>;\n  readonly IndexTypes: TMap;\n\n  constructor(entries: ReadonlyArray<IndexTypeEntry>) {\n    this.entries = entries;\n    this.IndexTypes = {} as TMap;\n  }\n\n  add<TLit extends string, TOpts>(\n    typeLiteral: TLit,\n    entry: { readonly options: Type<TOpts> },\n  ): IndexTypeBuilder<TMap & Record<TLit, { readonly options: TOpts }>> {\n    if (this.entries.some((e) => e.type === typeLiteral)) {\n      throw new Error(`Index type \"${typeLiteral}\" is already declared in this builder`);\n    }\n    return new IndexTypeBuilderImpl<TMap & Record<TLit, { readonly options: TOpts }>>([\n      ...this.entries,\n      { type: typeLiteral, options: entry.options as Type<unknown> },\n    ]);\n  }\n}\n\nexport function defineIndexTypes(): IndexTypeBuilder<Record<never, never>> {\n  return new IndexTypeBuilderImpl([]);\n}\n\nexport interface IndexTypeRegistry {\n  register(entry: IndexTypeEntry): void;\n  get(typeLiteral: string): IndexTypeEntry | undefined;\n  has(typeLiteral: string): boolean;\n}\n\nclass IndexTypeRegistryImpl implements IndexTypeRegistry {\n  private readonly entries = new Map<string, IndexTypeEntry>();\n\n  register(entry: IndexTypeEntry): void {\n    if (this.entries.has(entry.type)) {\n      throw new Error(`Index type \"${entry.type}\" is already registered`);\n    }\n    this.entries.set(entry.type, entry);\n  }\n\n  get(typeLiteral: string): IndexTypeEntry | undefined {\n    return this.entries.get(typeLiteral);\n  }\n\n  has(typeLiteral: string): boolean {\n    return this.entries.has(typeLiteral);\n  }\n}\n\nexport function createIndexTypeRegistry(): IndexTypeRegistry {\n  return new IndexTypeRegistryImpl();\n}\n"],"mappings":";AAsBA,IAAM,uBAAN,MAAM,qBAAkF;CACtF;CACA;CAEA,YAAY,SAAwC;EAClD,KAAK,UAAU;EACf,KAAK,aAAa,CAAC;CACrB;CAEA,IACE,aACA,OACoE;EACpE,IAAI,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,WAAW,GACjD,MAAM,IAAI,MAAM,eAAe,YAAY,sCAAsC;EAEnF,OAAO,IAAI,qBAAuE,CAChF,GAAG,KAAK,SACR;GAAE,MAAM;GAAa,SAAS,MAAM;EAAyB,CAC/D,CAAC;CACH;AACF;AAEA,SAAgB,mBAA2D;CACzE,OAAO,IAAI,qBAAqB,CAAC,CAAC;AACpC;AAQA,IAAM,wBAAN,MAAyD;CACvD,0BAA2B,IAAI,IAA4B;CAE3D,SAAS,OAA6B;EACpC,IAAI,KAAK,QAAQ,IAAI,MAAM,IAAI,GAC7B,MAAM,IAAI,MAAM,eAAe,MAAM,KAAK,wBAAwB;EAEpE,KAAK,QAAQ,IAAI,MAAM,MAAM,KAAK;CACpC;CAEA,IAAI,aAAiD;EACnD,OAAO,KAAK,QAAQ,IAAI,WAAW;CACrC;CAEA,IAAI,aAA8B;EAChC,OAAO,KAAK,QAAQ,IAAI,WAAW;CACrC;AACF;AAEA,SAAgB,0BAA6C;CAC3D,OAAO,IAAI,sBAAsB;AACnC"}
+{"version":3,"file":"index-types.mjs","names":[],"sources":["../src/index-types.ts"],"sourcesContent":["import type { Type } from 'arktype';\nimport { contractError } from './contract-errors';\n\nexport interface IndexTypeEntry<TOptions = unknown> {\n  readonly type: string;\n  readonly options: Type<TOptions>;\n}\n\nexport type IndexTypeMap = { readonly [K in string]: { readonly options: unknown } };\n\nexport interface IndexTypeRegistration<TMap extends IndexTypeMap = Record<never, never>> {\n  readonly IndexTypes: TMap;\n  readonly entries: ReadonlyArray<IndexTypeEntry>;\n}\n\nexport interface IndexTypeBuilder<TMap extends IndexTypeMap = Record<never, never>>\n  extends IndexTypeRegistration<TMap> {\n  add<TLit extends string, TOpts>(\n    typeLiteral: TLit,\n    entry: { readonly options: Type<TOpts> },\n  ): IndexTypeBuilder<TMap & Record<TLit, { readonly options: TOpts }>>;\n}\n\nclass IndexTypeBuilderImpl<TMap extends IndexTypeMap> implements IndexTypeBuilder<TMap> {\n  readonly entries: ReadonlyArray<IndexTypeEntry>;\n  readonly IndexTypes: TMap;\n\n  constructor(entries: ReadonlyArray<IndexTypeEntry>) {\n    this.entries = entries;\n    this.IndexTypes = {} as TMap;\n  }\n\n  add<TLit extends string, TOpts>(\n    typeLiteral: TLit,\n    entry: { readonly options: Type<TOpts> },\n  ): IndexTypeBuilder<TMap & Record<TLit, { readonly options: TOpts }>> {\n    if (this.entries.some((e) => e.type === typeLiteral)) {\n      throw contractError(\n        'CONTRACT.PACK_CONTRIBUTION_INVALID',\n        `Index type \"${typeLiteral}\" is already declared in this builder`,\n        { meta: { indexType: typeLiteral } },\n      );\n    }\n    return new IndexTypeBuilderImpl<TMap & Record<TLit, { readonly options: TOpts }>>([\n      ...this.entries,\n      { type: typeLiteral, options: entry.options as Type<unknown> },\n    ]);\n  }\n}\n\nexport function defineIndexTypes(): IndexTypeBuilder<Record<never, never>> {\n  return new IndexTypeBuilderImpl([]);\n}\n\nexport interface IndexTypeRegistry {\n  register(entry: IndexTypeEntry): void;\n  get(typeLiteral: string): IndexTypeEntry | undefined;\n  has(typeLiteral: string): boolean;\n}\n\nclass IndexTypeRegistryImpl implements IndexTypeRegistry {\n  private readonly entries = new Map<string, IndexTypeEntry>();\n\n  register(entry: IndexTypeEntry): void {\n    if (this.entries.has(entry.type)) {\n      throw contractError(\n        'CONTRACT.PACK_CONTRIBUTION_INVALID',\n        `Index type \"${entry.type}\" is already registered`,\n        { meta: { indexType: entry.type } },\n      );\n    }\n    this.entries.set(entry.type, entry);\n  }\n\n  get(typeLiteral: string): IndexTypeEntry | undefined {\n    return this.entries.get(typeLiteral);\n  }\n\n  has(typeLiteral: string): boolean {\n    return this.entries.has(typeLiteral);\n  }\n}\n\nexport function createIndexTypeRegistry(): IndexTypeRegistry {\n  return new IndexTypeRegistryImpl();\n}\n"],"mappings":";;AAuBA,IAAM,uBAAN,MAAM,qBAAkF;CACtF;CACA;CAEA,YAAY,SAAwC;EAClD,KAAK,UAAU;EACf,KAAK,aAAa,CAAC;CACrB;CAEA,IACE,aACA,OACoE;EACpE,IAAI,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,WAAW,GACjD,MAAM,cACJ,sCACA,eAAe,YAAY,wCAC3B,EAAE,MAAM,EAAE,WAAW,YAAY,EAAE,CACrC;EAEF,OAAO,IAAI,qBAAuE,CAChF,GAAG,KAAK,SACR;GAAE,MAAM;GAAa,SAAS,MAAM;EAAyB,CAC/D,CAAC;CACH;AACF;AAEA,SAAgB,mBAA2D;CACzE,OAAO,IAAI,qBAAqB,CAAC,CAAC;AACpC;AAQA,IAAM,wBAAN,MAAyD;CACvD,0BAA2B,IAAI,IAA4B;CAE3D,SAAS,OAA6B;EACpC,IAAI,KAAK,QAAQ,IAAI,MAAM,IAAI,GAC7B,MAAM,cACJ,sCACA,eAAe,MAAM,KAAK,0BAC1B,EAAE,MAAM,EAAE,WAAW,MAAM,KAAK,EAAE,CACpC;EAEF,KAAK,QAAQ,IAAI,MAAM,MAAM,KAAK;CACpC;CAEA,IAAI,aAAiD;EACnD,OAAO,KAAK,QAAQ,IAAI,WAAW;CACrC;CAEA,IAAI,aAA8B;EAChC,OAAO,KAAK,QAAQ,IAAI,WAAW;CACrC;AACF;AAEA,SAAgB,0BAA6C;CAC3D,OAAO,IAAI,sBAAsB;AACnC"}

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

@@ -1 +1 @@
-{"version":3,"file":"pack-types.d.mts","names":[],"sources":["../src/pack-types.ts"],"mappings":";;AAGA;;UAAiB,mBAAA;EAAA,SACN,MAAA;EAAA,SACA,QAAA;EAAA,SACA,QAAA;EAAA,SACA,UAAA;AAAA"}
+{"version":3,"file":"pack-types.d.mts","names":[],"sources":["../src/pack-types.ts"],"mappings":";;;;UAGiB;WACN;WACA;WACA;WACA"}

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

@@ -1,5 +1,4 @@
-import { r as ReferentialAction } from "./foreign-key-DM1UTydh.mjs";
-
+import { r as ReferentialAction } from "./foreign-key-CWCEM2IT.mjs";
 //#region src/referential-action-sql.d.ts
 /**
  * Maps each `ReferentialAction` value to the SQL keyword used in ON DELETE /

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

@@ -1 +1 @@
-{"version":3,"file":"referential-action-sql.d.mts","names":[],"sources":["../src/referential-action-sql.ts"],"mappings":";;;;;AAOA;;;cAAa,sBAAA,EAAwB,MAAM,CAAC,iBAAA"}
+{"version":3,"file":"referential-action-sql.d.mts","names":[],"sources":["../src/referential-action-sql.ts"],"mappings":";;;;;;;cAOa,wBAAwB,OAAO"}

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

@@ -1,6 +1,5 @@
-import { t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
-import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
-
+import { t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
 //#region src/resolve-storage-table.d.ts
 interface ResolvedStorageTable {
   readonly namespaceId: string;

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

@@ -1 +1 @@
-{"version":3,"file":"resolve-storage-table.d.mts","names":[],"sources":["../src/resolve-storage-table.ts"],"mappings":";;;;UAIiB,oBAAA;EAAA,SACN,WAAA;EAAA,SACA,KAAA,EAAO,YAAY;AAAA;;;;;;;AAAA;AAY9B;;iBAAgB,mBAAA,CACd,OAAA,EAAS,UAAA,EACT,SAAA,UACA,WAAA,YACC,oBAAoB"}
+{"version":3,"file":"resolve-storage-table.d.mts","names":[],"sources":["../src/resolve-storage-table.ts"],"mappings":";;;UAKiB;WACN;WACA,OAAO;;;;;;;;;;;iBAYF,oBACd,SAAS,YACT,mBACA,uBACC"}

package/dist/resolve-storage-table.mjs

@@ -1,3 +1,4 @@
+import { t as contractError } from "./contract-errors-CPZcBw8G.mjs";
 import { entityAt } from "@prisma-next/framework-components/ir";
 //#region src/resolve-storage-table.ts
 /**
@@ -33,10 +34,10 @@ function resolveStorageTable(storage, tableName, namespaceId) {
 			table
 		});
 	}
-	if (matches.length > 1) {
-		const candidates = matches.map((match) => match.namespaceId).sort().join(", ");
-		throw new Error(`Storage table "${tableName}" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`);
-	}
+	if (matches.length > 1) throw contractError("CONTRACT.TABLE_AMBIGUOUS", `Storage table "${tableName}" is ambiguous across namespaces [${matches.map((match) => match.namespaceId).sort().join(", ")}]; qualify it with a namespace coordinate.`, { meta: {
+		tableName,
+		candidates: matches.map((match) => match.namespaceId).sort()
+	} });
 	return matches[0];
 }
 //#endregion