@prisma-next/sql-contract 0.14.0-dev.90 → 0.15.0-dev.1

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,gCAAA;EAAA,SACF,mBAAA,EAAqB,sBAAA;EAAA,SACrB,WAAA,EAAa,WAAW;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 (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;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-view.d.mts

@@ -1,4 +1,4 @@
-import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
+import { s as SqlStorage } from "./sql-storage-p-Wzt_MO.mjs";
 import { DefaultNamespaceEntries, NamespacedEntities, SingleNamespaceView } from "@prisma-next/framework-components/ir";
 import { Contract } from "@prisma-next/contract/types";
 

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

@@ -1,5 +1,5 @@
-import { t as StorageTable } from "./storage-table-y6R6pxyI.mjs";
-import { t as StorageValueSet } from "./storage-value-set-Tx3CFoS_.mjs";
+import { t as StorageTable } from "./storage-table-DBpYBmty.mjs";
+import { t as StorageValueSet } from "./storage-value-set-3BKuha5q.mjs";
 import { type } from "arktype";
 //#region src/ir/storage-entry-schemas.ts
 const literalKindSchema = type("'literal'");
@@ -78,9 +78,7 @@ const ForeignKeySchema = type.declare().type({
 	target: ForeignKeyReferenceSchema,
 	"name?": "string",
 	"onDelete?": ReferentialActionSchema,
-	"onUpdate?": ReferentialActionSchema,
-	constraint: "boolean",
-	index: "boolean"
+	"onUpdate?": ReferentialActionSchema
 });
 const CheckConstraintSchema = type({
 	"+": "reject",
@@ -129,4 +127,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-CVg6HzG2.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-CVg6HzG2.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 { 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,4 @@
-import { n as StorageTableInput, t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
+import { n as StorageTableInput, t as StorageTable } from "./storage-table-CE-Ns6wa.mjs";
 import { n as StorageValueSetInput, t as StorageValueSet } from "./storage-value-set-D-jww77l.mjs";
 import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma-next/framework-components/ir";
 

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-CVg6HzG2.mjs";
 export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };

package/dist/factories.d.mts

@@ -1,6 +1,7 @@
-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-CE-Ns6wa.mjs";
+import { t as ForeignKey } from "./foreign-key-DuCoGJCf.mjs";
+import { a as PrimaryKey, r as Index, t as UniqueConstraint } from "./unique-constraint-C0De4sLU.mjs";
+import { T as SqlModelStorage, m as ForeignKeyOptions, w as SqlModelFieldStorage } from "./types-3vOIrnvp.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
 
 //#region src/factories.d.ts
@@ -11,8 +12,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,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,WAAA;AAAA,IAC5B,UAAU;AAAA,iBAWG,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,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-DBpYBmty.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-DuCoGJCf.d.mts}

@@ -51,13 +51,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 +75,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 +82,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-DuCoGJCf.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"foreign-key-DuCoGJCf.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;AAAA;;;;ADQJ;AAmBlB;;;;;;;;;;;;;;;;cCJa,UAAA,SAAmB,OAAA;EAAA,SACrB,MAAA,EAAQ,mBAAA;EAAA,SACR,MAAA,EAAQ,mBAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAA;cAEhB,KAAA,EAAO,eAAA;AAAA"}

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

@@ -0,0 +1,64 @@
+import { a as ForeignKeyReferenceInput, n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-DuCoGJCf.mjs";
+import { i as IndexInput, n as UniqueConstraintInput, o as PrimaryKeyInput } from "./unique-constraint-C0De4sLU.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,sBAAA;EAAA,SACD,OAAA;IAAA,SAA6B,OAAA;EAAA;EAAA,SAC7B,OAAA;IAAA,SAA6B,OAAA;EAAA;EAAA,SAC7B,UAAA;IAAA,SAAwB,OAAA;EAAA;AAAA;AAcnC;;;;AAAoE;AAapE;;;;AAEgC;AAUhC;AAzBA,iBAAgB,sBAAA,CAAuB,KAA6B,EAAtB,sBAAsB;;;;;;iBAapD,oBAAA,CACd,OAAA,qBACA,WAA8B;;;;;;UAUf,wBAAA;EAAA,SACN,MAAA,EAAQ,wBAAA;EAAA,SACR,MAAA,EAAQ,wBAAA;EAAA,SACR,IAAA;EAAA,SACA,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAA;EAAA,SACX,UAAA;EAAA,SACA,KAAA;AAAA;AAAA,UAGM,4BAAA;EAAA,SACN,WAAA,WAAsB,eAAA;EAAA,SACtB,OAAA,WAAkB,UAAU;AAAA;;;;;;AAAA;AAYvC;;;iBAAgB,gCAAA,CACd,SAAA,UACA,WAAA,WAAsB,wBAAA,IACtB,eAAA,WAA0B,UAAA,IAC1B,OAAA,WAAkB,qBAAA,IAClB,UAAA,EAAY,eAAA,eACX,4BAAA"}

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,4 +1,4 @@
-import { s as SqlStorage } from "./sql-storage-Dt5ipcRl.mjs";
+import { s as SqlStorage } from "./sql-storage-p-Wzt_MO.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-DM1UTydh.mjs";
+import { r as ReferentialAction } from "./foreign-key-DuCoGJCf.mjs";
 
 //#region src/referential-action-sql.d.ts
 /**

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

@@ -1,5 +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-CE-Ns6wa.mjs";
+import { s as SqlStorage } from "./sql-storage-p-Wzt_MO.mjs";
 
 //#region src/resolve-storage-table.d.ts
 interface ResolvedStorageTable {

package/dist/{sql-storage-Dt5ipcRl.d.mts → sql-storage-p-Wzt_MO.d.mts}

@@ -1,5 +1,5 @@
 import { t as SqlNode } from "./sql-node-V214WXQD.mjs";
-import { t as StorageTable } from "./storage-table-Bj1ZN1P7.mjs";
+import { t as StorageTable } from "./storage-table-CE-Ns6wa.mjs";
 import { t as StorageValueSet } from "./storage-value-set-D-jww77l.mjs";
 import { Namespace, NamespaceBase, Storage, StorageType } from "@prisma-next/framework-components/ir";
 import { StorageHashBase } from "@prisma-next/contract/types";
@@ -168,4 +168,4 @@ declare class SqlStorage<THash extends string = string> extends SqlNode implemen
 }
 //#endregion
 export { SqlNamespaceFactory as a, SqlStorageInput as c, isSqlAuthoringContributions as d, CODEC_INSTANCE_KIND as f, toStorageTypeInstance as g, isStorageTypeInstance as h, SqlNamespaceEntries as i, SqlStorageTypeEntry as l, StorageTypeInstanceInput as m, SqlNamespace as n, SqlNamespaceInput as o, StorageTypeInstance as p, SqlNamespaceBase as r, SqlStorage as s, SqlAuthoringContributions as t, isMaterializedSqlNamespace as u };
-//# sourceMappingURL=sql-storage-Dt5ipcRl.d.mts.map
+//# sourceMappingURL=sql-storage-p-Wzt_MO.d.mts.map

package/dist/{sql-storage-Dt5ipcRl.d.mts.map → sql-storage-p-Wzt_MO.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"sql-storage-Dt5ipcRl.d.mts","names":[],"sources":["../src/ir/storage-type-instance.ts","../src/ir/sql-storage.ts"],"mappings":";;;;;;;;;;;;;;;cASa,mBAAA;;;;AAA+C;AAU5D;;;;UAAiB,mBAAA,SAA4B,WAAA;EAAA,SAClC,IAAA,SAAa,mBAAA;EAAA,SACb,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,EAAY,MAAA;AAAA;;;;;;;AAAM;UAUZ,wBAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;;;AAAA;iBAQd,qBAAA,CAAsB,KAAA,EAAO,wBAAA,GAA2B,mBAAmB;;;;;;iBAc3E,qBAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,mBAAmB;;;;AAjDnF;;;;AAA4D;AAU5D;KCOY,mBAAA,GAAsB,mBAAA,GAAsB,wBAAwB;AAAA,UAE/D,iBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;KAOzC,mBAAA,IAAuB,KAAA,EAAO,iBAAA,KAAsB,SAAS;;;;;;ADd5C;AAU7B;UCaiB,yBAAA,SAAkC,sBAAsB;EAAA,SAC9D,eAAA,GAAkB,mBAAA;AAAA;;;;;iBAOb,2BAAA,CACd,SAAA,EAAW,sBAAA,eACV,SAAA,IAAa,yBAAyB;AAAA,UAOxB,eAAA;EAAA,SACN,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,KAAA,GAAQ,MAAA,SAAe,mBAAA;EAAA,SACvB,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,gBAAA;AAAA;;;;;ADtB4C;AAc3F;;;;;;;;AAAmF;;;;AChCnF;;;;AAAgF;AAEhF;;;;;AAFgF,KAsEpE,mBAAA,GAAsB,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;EAAA,SACxD,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAChC,QAAA,GAAW,QAAA,CAAS,MAAA,SAAe,eAAA;AAAA;;;;;;;;AApEa;AAO3D;UAyEiB,YAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA;EAAA,SACA,OAAA,EAAS,mBAAmB;EAAA,SAC5B,SAAA;EACT,YAAA,EAAc,SAAA;AAAA;AA9EyD;AASzE;;;;;AATyE,uBAuFnD,gBAAA,SAAyB,aAAA,YAAyB,YAAA;EAAA,kBAC3C,EAAA;EAAA,kBACA,OAAA,EAAS,mBAAA;EAAA,SAE3B,YAAA,CAAa,SAAA;AAAA;;;;;;;;;AAxEiB;AAOzC;iBA8EgB,0BAAA,CAA2B,CAAA,YAAa,CAAA,IAAK,gBAAgB;AAAA,cAKhE,UAAA,wCAAkD,OAAA,YAAmB,OAAA;EAAA,SACvE,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAC5B,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,mBAAA;cAErC,KAAA,EAAO,eAAA,CAAgB,KAAA;AAAA"}
+{"version":3,"file":"sql-storage-p-Wzt_MO.d.mts","names":[],"sources":["../src/ir/storage-type-instance.ts","../src/ir/sql-storage.ts"],"mappings":";;;;;;;;;;;;;;;cASa,mBAAA;;;;AAA+C;AAU5D;;;;UAAiB,mBAAA,SAA4B,WAAA;EAAA,SAClC,IAAA,SAAa,mBAAA;EAAA,SACb,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,EAAY,MAAA;AAAA;;;;;;;AAAM;UAUZ,wBAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;;;AAAA;iBAQd,qBAAA,CAAsB,KAAA,EAAO,wBAAA,GAA2B,mBAAmB;;;;;;iBAc3E,qBAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,mBAAmB;;;;AAjDnF;;;;AAA4D;AAU5D;KCOY,mBAAA,GAAsB,mBAAA,GAAsB,wBAAwB;AAAA,UAE/D,iBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;KAOzC,mBAAA,IAAuB,KAAA,EAAO,iBAAA,KAAsB,SAAS;;;;;;ADd5C;AAU7B;UCaiB,yBAAA,SAAkC,sBAAsB;EAAA,SAC9D,eAAA,GAAkB,mBAAA;AAAA;;;;;iBAOb,2BAAA,CACd,SAAA,EAAW,sBAAA,eACV,SAAA,IAAa,yBAAyB;AAAA,UAOxB,eAAA;EAAA,SACN,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,KAAA,GAAQ,MAAA,SAAe,mBAAA;EAAA,SACvB,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,gBAAA;AAAA;;;;;ADtB4C;AAc3F;;;;;;;;AAAmF;;;;AChCnF;;;;AAAgF;AAEhF;;;;;AAFgF,KAsEpE,mBAAA,GAAsB,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;EAAA,SACxD,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAChC,QAAA,GAAW,QAAA,CAAS,MAAA,SAAe,eAAA;AAAA;;;;;;;;AApEa;AAO3D;UAyEiB,YAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA;EAAA,SACA,OAAA,EAAS,mBAAmB;EAAA,SAC5B,SAAA;EACT,YAAA,EAAc,SAAA;AAAA;AA9EyD;AASzE;;;;;AATyE,uBAuFnD,gBAAA,SAAyB,aAAA,YAAyB,YAAA;EAAA,kBAC3C,EAAA;EAAA,kBACA,OAAA,EAAS,mBAAA;EAAA,SAE3B,YAAA,CAAa,SAAA;AAAA;;;;;;;;;AAxEiB;AAOzC;iBA8EgB,0BAAA,CAA2B,CAAA,YAAa,CAAA,IAAK,gBAAgB;AAAA,cAKhE,UAAA,wCAAkD,OAAA,YAAmB,OAAA;EAAA,SACvE,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,SAC5B,KAAA,GAAQ,QAAA,CAAS,MAAA,SAAe,mBAAA;cAErC,KAAA,EAAO,eAAA,CAAgB,KAAA;AAAA"}

package/dist/{storage-table-Bj1ZN1P7.d.mts → storage-table-CE-Ns6wa.d.mts}

@@ -1,5 +1,6 @@
 import { t as SqlNode } from "./sql-node-V214WXQD.mjs";
-import { n as ForeignKeyInput, t as ForeignKey } from "./foreign-key-DM1UTydh.mjs";
+import { n as ForeignKeyInput, t as ForeignKey } from "./foreign-key-DuCoGJCf.mjs";
+import { a as PrimaryKey, i as IndexInput, n as UniqueConstraintInput, o as PrimaryKeyInput, r as Index, t as UniqueConstraint } from "./unique-constraint-C0De4sLU.mjs";
 import { ColumnDefault, ControlPolicy, ValueSetRef } from "@prisma-next/contract/types";
 
 //#region src/ir/check-constraint.d.ts
@@ -34,43 +35,6 @@ declare class CheckConstraint extends SqlNode {
   constructor(input: CheckConstraintInput);
 }
 //#endregion
-//#region src/ir/primary-key.d.ts
-interface PrimaryKeyInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-/**
- * SQL Contract IR node for a table's primary-key constraint.
- */
-declare class PrimaryKey extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  constructor(input: PrimaryKeyInput);
-}
-//#endregion
-//#region src/ir/sql-index.d.ts
-interface IndexInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-}
-/**
- * SQL Contract IR node for a table-level secondary index.
- *
- * Note that this class shadows the global TypeScript `Index` lib type
- * at the family-shared name; consumer files that need both should
- * alias one (e.g.
- * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
- */
-declare class Index extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-  constructor(input: IndexInput);
-}
-//#endregion
 //#region src/ir/storage-column.d.ts
 /**
  * Hydration / construction input shape for {@link StorageColumn}. Mirrors
@@ -119,20 +83,6 @@ declare class StorageColumn extends SqlNode {
   constructor(input: StorageColumnInput);
 }
 //#endregion
-//#region src/ir/unique-constraint.d.ts
-interface UniqueConstraintInput {
-  readonly columns: readonly string[];
-  readonly name?: string;
-}
-/**
- * SQL Contract IR node for a table-level unique constraint.
- */
-declare class UniqueConstraint extends SqlNode {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  constructor(input: UniqueConstraintInput);
-}
-//#endregion
 //#region src/ir/storage-table.d.ts
 interface StorageTableInput {
   readonly columns: Record<string, StorageColumn | StorageColumnInput>;
@@ -175,5 +125,5 @@ declare class StorageTable extends SqlNode {
   static assert(value: StorageTable | undefined, coordinate: string): asserts value is StorageTable;
 }
 //#endregion
-export { StorageColumn as a, IndexInput as c, CheckConstraint as d, CheckConstraintInput as f, UniqueConstraintInput as i, PrimaryKey as l, StorageTableInput as n, StorageColumnInput as o, UniqueConstraint as r, Index as s, StorageTable as t, PrimaryKeyInput as u };
-//# sourceMappingURL=storage-table-Bj1ZN1P7.d.mts.map
+export { CheckConstraint as a, StorageColumnInput as i, StorageTableInput as n, CheckConstraintInput as o, StorageColumn as r, StorageTable as t };
+//# sourceMappingURL=storage-table-CE-Ns6wa.d.mts.map

package/dist/storage-table-CE-Ns6wa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-CE-Ns6wa.d.mts","names":[],"sources":["../src/ir/check-constraint.ts","../src/ir/storage-column.ts","../src/ir/storage-table.ts"],"mappings":";;;;;;;;;;AASA;UAAiB,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,EAAU,WAAW;AAAA;;;;AAAA;AAiBhC;;;;;;;;;;cAAa,eAAA,SAAwB,OAAA;EAAA,SAC1B,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,EAAU,WAAA;cAEP,KAAA,EAAO,oBAAA;AAAA;;;;;;;AAzBrB;;;;;;UCKiB,kBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,UAAA,GAAa,MAAA;EAAA,SACb,OAAA;EAAA,SACA,OAAA,GAAU,aAAA;EAAA,SACV,OAAA,GAAU,aAAA;EAAA,SACV,QAAA,GAAW,WAAA;AAAA;;;;;;;;;;;ADWmB;;;cCK5B,aAAA,SAAsB,OAAA;EAAA,SACxB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACQ,IAAA;EAAA,SACA,UAAA,GAAa,MAAA;EAAA,SACb,OAAA;EAAA,SACA,OAAA,GAAU,aAAA;EAAA,SACV,OAAA,GAAU,aAAA;EAAA,SACV,QAAA,GAAW,WAAA;cAEhB,KAAA,EAAO,kBAAA;AAAA;;;UCxCJ,iBAAA;EAAA,SACN,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA;EAAA,SACxC,UAAA,GAAa,UAAA,GAAa,eAAA;EAAA,SAC1B,OAAA,EAAS,aAAA,CAAc,gBAAA,GAAmB,qBAAA;EAAA,SAC1C,OAAA,EAAS,aAAA,CAAc,KAAA,GAAQ,UAAA;EAAA,SAC/B,WAAA,EAAa,aAAA,CAAc,UAAA,GAAa,eAAA;EAAA,SACxC,OAAA,GAAU,aAAA;EAAA,SACV,MAAA,GAAS,aAAA,CAAc,eAAA,GAAkB,oBAAA;AAAA;;;;;;;;;;;;;cAevC,YAAA,SAAqB,OAAA;EAAA,SACvB,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,aAAA;EAAA,SACjC,OAAA,EAAS,aAAA,CAAc,gBAAA;EAAA,SACvB,OAAA,EAAS,aAAA,CAAc,KAAA;EAAA,SACvB,WAAA,EAAa,aAAA,CAAc,UAAA;EAAA,SACnB,UAAA,GAAa,UAAA;EAAA,SACb,OAAA,GAAU,aAAA;EAAA,SACV,MAAA,GAAS,aAAA,CAAc,eAAA;cAE5B,KAAA,EAAO,iBAAA;ED3Bc;;;;;;;EAAA,OCgE1B,EAAA,CAAG,KAAA,EAAO,YAAA,eAA2B,KAAA,IAAS,YAAA;EAAA,OAK9C,MAAA,CACL,KAAA,EAAO,YAAA,cACP,UAAA,mBACS,KAAA,IAAS,YAAA;AAAA"}

package/dist/{storage-table-y6R6pxyI.mjs → storage-table-DBpYBmty.mjs}

@@ -107,7 +107,15 @@ var ForeignKeyReference = class extends SqlNode {
 //#endregion
 //#region src/ir/foreign-key.ts
 /**
-* 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
@@ -121,14 +129,10 @@ var ForeignKeyReference = class extends SqlNode {
 var ForeignKey = class extends SqlNode {
 	source;
 	target;
-	constraint;
-	index;
 	constructor(input) {
 		super();
 		this.source = input.source instanceof ForeignKeyReference ? input.source : new ForeignKeyReference(input.source);
 		this.target = input.target instanceof ForeignKeyReference ? input.target : new ForeignKeyReference(input.target);
-		this.constraint = input.constraint;
-		this.index = input.index;
 		if (input.name !== void 0) this.name = input.name;
 		if (input.onDelete !== void 0) this.onDelete = input.onDelete;
 		if (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;
@@ -265,4 +269,4 @@ var StorageTable = class StorageTable extends SqlNode {
 //#endregion
 export { PrimaryKey as a, CheckConstraint as c, Index as i, SqlNode as l, UniqueConstraint as n, ForeignKey as o, StorageColumn as r, ForeignKeyReference as s, StorageTable as t };
 
-//# sourceMappingURL=storage-table-y6R6pxyI.mjs.map
+//# sourceMappingURL=storage-table-DBpYBmty.mjs.map

package/dist/storage-table-DBpYBmty.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-DBpYBmty.mjs","names":[],"sources":["../src/ir/sql-node.ts","../src/ir/check-constraint.ts","../src/ir/foreign-key-reference.ts","../src/ir/foreign-key.ts","../src/ir/primary-key.ts","../src/ir/sql-index.ts","../src/ir/storage-column.ts","../src/ir/unique-constraint.ts","../src/ir/storage-table.ts"],"sourcesContent":["import { IRNodeBase } from '@prisma-next/framework-components/ir';\n\n/**\n * SQL family IR node base. Carries the family-level `kind` discriminator\n * `'sql'` and inherits the framework's `freezeNode` affordance.\n *\n * Single family-level discriminator (not per-leaf) reflects the fact that\n * SQL IR has no polymorphic dispatch today — verifiers and serializers\n * walk by structural position (`storage.tables[name].columns[name]`),\n * not by inspecting `kind`. The abstract bar for per-leaf discriminators\n * isn't earned until a future polymorphic consumer arrives.\n *\n * `kind` is installed as a non-enumerable own property on every instance,\n * which keeps three things clean simultaneously:\n *\n * - `JSON.stringify(node)` produces the canonical pre-lift JSON envelope\n *   shape (no `kind` field), so emitted contract.json files and the\n *   `validateSqlContractFully` arktype schemas stay unchanged.\n * - Test assertions that use `toEqual({...})` against the pre-lift flat\n *   shape continue to pass — only enumerable own properties are\n *   compared.\n * - Direct access (`node.kind`) and runtime narrowing\n *   (`if (node.kind === 'sql')`) still work, so future polymorphic\n *   dispatch can begin reading `kind` without a runtime change.\n *\n * Future per-leaf overrides land cleanly: a class that gains a\n * polymorphic-dispatch consumer (e.g. an enum type instance walked\n * alongside other types) overrides `kind` with its narrower literal\n * at that leaf level. Per-leaf overrides will use enumerable kind\n * (matching the Mongo per-class-discriminator precedent) because they\n * encode dispatch-relevant information that callers need to see in\n * JSON envelopes; the family-level `'sql'` is uniform across all SQL\n * IR and carries no dispatch-relevant information.\n */\nexport abstract class SqlNode extends IRNodeBase {\n  readonly kind?: string;\n\n  constructor() {\n    super();\n    Object.defineProperty(this, 'kind', {\n      value: 'sql',\n      writable: false,\n      enumerable: false,\n      // configurable so per-leaf subclasses (e.g. StorageValueSet)\n      // can override `kind` with their narrower\n      // enumerable literal via a class-field initializer. SqlNode\n      // itself never needs to mutate the property again, so\n      // configurability has no surface impact at this layer.\n      configurable: true,\n    });\n  }\n}\n","import type { ValueSetRef } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Hydration / construction input shape for {@link CheckConstraint}.\n * Mirrors the on-disk storage JSON envelope so the serializer hydration\n * walker can hand a validated literal straight to `new`.\n */\nexport interface CheckConstraintInput {\n  readonly name: string;\n  readonly column: string;\n  readonly valueSet: ValueSetRef;\n}\n\n/**\n * SQL Contract IR node for a table-level check constraint that restricts\n * a column to the permitted values of a value-set.\n *\n * The constraint is **structured** (names a column and a value-set\n * reference), not a raw SQL expression. Each target renders its own DDL\n * from the structured form, keeping the contract target-agnostic.\n *\n * Construction is idempotent: passing an existing `CheckConstraint`\n * instance as input produces a new instance with identical fields.\n * The constructor does not use `instanceof` for input discrimination —\n * it reads plain named properties, which is sufficient since\n * `CheckConstraintInput` is a structural type.\n */\nexport class CheckConstraint extends SqlNode {\n  readonly name: string;\n  readonly column: string;\n  readonly valueSet: ValueSetRef;\n\n  constructor(input: CheckConstraintInput) {\n    super();\n    this.name = input.name;\n    this.column = input.column;\n    this.valueSet = input.valueSet;\n    freezeNode(this);\n  }\n}\n","import { asNamespaceId, type NamespaceId } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Input for a foreign-key reference (one side of a foreign-key declaration).\n *\n * When `spaceId` is absent the reference is local — the referenced table lives\n * in the same contract-space. When `spaceId` is present the reference is\n * cross-space — the referenced table lives in a different contract-space\n * identified by `spaceId`.\n *\n * Presence-based discrimination keeps local FK JSON byte-identical to\n * contracts authored before cross-space support was added.\n */\nexport interface ForeignKeyReferenceInput {\n  readonly namespaceId: string;\n  readonly tableName: string;\n  readonly columns: readonly string[];\n  readonly spaceId?: string;\n}\n\n/**\n * SQL Contract IR node for one side (source or target) of a foreign-key\n * declaration. Carries the full coordinate: namespace, table, and columns.\n *\n * Cross-space discrimination is based on `spaceId` presence: absent means\n * local (same contract-space); present means cross-space (the referenced\n * table lives in the contract-space identified by `spaceId`).\n *\n * For local references `spaceId` is absent from JSON, keeping the serialized\n * shape byte-identical to contracts authored before cross-space support was\n * added. For cross-space references `spaceId` appears in JSON so round-trips\n * are lossless.\n *\n * Use `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`\n * as the sentinel `namespaceId` for single-namespace (unbound) references.\n */\nexport class ForeignKeyReference extends SqlNode {\n  readonly namespaceId: NamespaceId;\n  readonly tableName: string;\n  readonly columns: readonly string[];\n  declare readonly spaceId?: string;\n\n  constructor(input: ForeignKeyReferenceInput) {\n    super();\n    this.namespaceId = asNamespaceId(input.namespaceId);\n    this.tableName = input.tableName;\n    this.columns = input.columns;\n    if (input.spaceId !== undefined) this.spaceId = input.spaceId;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { ForeignKeyReference, type ForeignKeyReferenceInput } from './foreign-key-reference';\nimport { SqlNode } from './sql-node';\n\nexport type ReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';\n\nexport interface ForeignKeyInput {\n  readonly source: ForeignKeyReference | ForeignKeyReferenceInput;\n  readonly target: ForeignKeyReference | ForeignKeyReferenceInput;\n  readonly name?: string;\n  readonly onDelete?: ReferentialAction;\n  readonly onUpdate?: ReferentialAction;\n}\n\n/**\n * SQL Contract IR node for a table-level foreign-key declaration — the\n * referential constraint only (source, target, `onDelete`/`onUpdate`).\n *\n * A persisted `foreignKeys[]` entry always denotes a real constraint: whether\n * to emit the constraint at all, and whether to back it with an index, are\n * authoring-time decisions (PSL `@relation(index:)`, TS `fk({ constraint,\n * index })`) resolved once at `contract emit` — a `constraint: false` FK\n * simply has no entry here, and a backing index (if any) is its own discrete,\n * named entry in the table's `indexes[]`.\n *\n * Each FK carries explicit `source` and `target` {@link ForeignKeyReference}\n * coordinates (namespace, table, columns). For single-namespace contracts the\n * sentinel `UNBOUND_NAMESPACE_ID` appears on both sides.\n *\n * The nested references are normalised to {@link ForeignKeyReference}\n * instances inside the constructor so downstream walks see a uniform AST\n * regardless of whether the input was a JSON literal or an already-constructed\n * class instance.\n */\nexport class ForeignKey extends SqlNode {\n  readonly source: ForeignKeyReference;\n  readonly target: ForeignKeyReference;\n  declare readonly name?: string;\n  declare readonly onDelete?: ReferentialAction;\n  declare readonly onUpdate?: ReferentialAction;\n\n  constructor(input: ForeignKeyInput) {\n    super();\n    this.source =\n      input.source instanceof ForeignKeyReference\n        ? input.source\n        : new ForeignKeyReference(input.source);\n    this.target =\n      input.target instanceof ForeignKeyReference\n        ? input.target\n        : new ForeignKeyReference(input.target);\n    if (input.name !== undefined) this.name = input.name;\n    if (input.onDelete !== undefined) this.onDelete = input.onDelete;\n    if (input.onUpdate !== undefined) this.onUpdate = input.onUpdate;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface PrimaryKeyInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n}\n\n/**\n * SQL Contract IR node for a table's primary-key constraint.\n */\nexport class PrimaryKey extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n\n  constructor(input: PrimaryKeyInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface IndexInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n  readonly type?: string;\n  readonly options?: Record<string, unknown>;\n}\n\n/**\n * SQL Contract IR node for a table-level secondary index.\n *\n * Note that this class shadows the global TypeScript `Index` lib type\n * at the family-shared name; consumer files that need both should\n * alias one (e.g.\n * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).\n */\nexport class Index extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n  declare readonly type?: string;\n  declare readonly options?: Record<string, unknown>;\n\n  constructor(input: IndexInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    if (input.type !== undefined) this.type = input.type;\n    if (input.options !== undefined) this.options = input.options;\n    freezeNode(this);\n  }\n}\n","import type { ColumnDefault, ControlPolicy, ValueSetRef } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\n/**\n * Hydration / construction input shape for {@link StorageColumn}. Mirrors\n * the on-disk storage JSON envelope exactly so the family-base\n * serializer's hydration walker can hand an arktype-validated literal\n * straight to `new`.\n *\n * `typeParams` and `typeRef` remain mutually exclusive (one or the\n * other, not both); the constructor preserves whichever caller-side\n * choice the input encodes.\n */\nexport interface StorageColumnInput {\n  readonly nativeType: string;\n  readonly codecId: string;\n  readonly nullable: boolean;\n  readonly many?: boolean;\n  readonly typeParams?: Record<string, unknown>;\n  readonly typeRef?: string;\n  readonly default?: ColumnDefault;\n  readonly control?: ControlPolicy;\n  readonly valueSet?: ValueSetRef;\n}\n\n/**\n * SQL Contract IR node for a single column entry in `StorageTable.columns`.\n *\n * Single concrete family-shared class — every SQL target reads the\n * same column shape today, so there is no per-target subclass. The\n * class type accepts any caller that constructs via\n * `new StorageColumn(input)`; literal construction sites must pass\n * through the constructor or the family-base hydration walker.\n *\n * The column's `name` is not on the class — columns are keyed by name\n * in the parent `StorageTable.columns: Record<string, StorageColumn>`\n * map, so a `name` field would be redundant with the key.\n */\nexport class StorageColumn extends SqlNode {\n  readonly nativeType: string;\n  readonly codecId: string;\n  readonly nullable: boolean;\n  declare readonly many?: boolean;\n  declare readonly typeParams?: Record<string, unknown>;\n  declare readonly typeRef?: string;\n  declare readonly default?: ColumnDefault;\n  declare readonly control?: ControlPolicy;\n  declare readonly valueSet?: ValueSetRef;\n\n  constructor(input: StorageColumnInput) {\n    super();\n    this.nativeType = input.nativeType;\n    this.codecId = input.codecId;\n    this.nullable = input.nullable;\n    if (input.many !== undefined) this.many = input.many;\n    if (input.typeParams !== undefined) this.typeParams = input.typeParams;\n    if (input.typeRef !== undefined) this.typeRef = input.typeRef;\n    if (input.default !== undefined) this.default = input.default;\n    if (input.control !== undefined) this.control = input.control;\n    if (input.valueSet !== undefined) this.valueSet = input.valueSet;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlNode } from './sql-node';\n\nexport interface UniqueConstraintInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n}\n\n/**\n * SQL Contract IR node for a table-level unique constraint.\n */\nexport class UniqueConstraint extends SqlNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n\n  constructor(input: UniqueConstraintInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    freezeNode(this);\n  }\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { CheckConstraint, type CheckConstraintInput } from './check-constraint';\nimport { ForeignKey, type ForeignKeyInput } from './foreign-key';\nimport { PrimaryKey, type PrimaryKeyInput } from './primary-key';\nimport { Index, type IndexInput } from './sql-index';\nimport { SqlNode } from './sql-node';\nimport { StorageColumn, type StorageColumnInput } from './storage-column';\nimport { UniqueConstraint, type UniqueConstraintInput } from './unique-constraint';\n\nexport interface StorageTableInput {\n  readonly columns: Record<string, StorageColumn | StorageColumnInput>;\n  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;\n  readonly uniques: ReadonlyArray<UniqueConstraint | UniqueConstraintInput>;\n  readonly indexes: ReadonlyArray<Index | IndexInput>;\n  readonly foreignKeys: ReadonlyArray<ForeignKey | ForeignKeyInput>;\n  readonly control?: ControlPolicy;\n  readonly checks?: ReadonlyArray<CheckConstraint | CheckConstraintInput>;\n}\n\n/**\n * SQL Contract IR node for a single table entry in a namespace's\n * `tables` map.\n *\n * The constructor normalises nested IR-class fields (columns, primary\n * key, uniques, indexes, foreign keys) into the appropriate class\n * instances so downstream walks see a uniform AST regardless of whether\n * the input was a JSON literal or an already-constructed class.\n *\n * The table's `name` is not on the class — tables are keyed by name in\n * the parent namespace's `tables: Record<string, StorageTable>` map.\n */\nexport class StorageTable extends SqlNode {\n  readonly columns: Readonly<Record<string, StorageColumn>>;\n  readonly uniques: ReadonlyArray<UniqueConstraint>;\n  readonly indexes: ReadonlyArray<Index>;\n  readonly foreignKeys: ReadonlyArray<ForeignKey>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly control?: ControlPolicy;\n  declare readonly checks?: ReadonlyArray<CheckConstraint>;\n\n  constructor(input: StorageTableInput) {\n    super();\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([name, col]) => [\n          name,\n          col instanceof StorageColumn ? col : new StorageColumn(col),\n        ]),\n      ),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof UniqueConstraint ? u : new UniqueConstraint(u))),\n    );\n    this.indexes = Object.freeze(input.indexes.map((i) => (i instanceof Index ? i : new Index(i))));\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof ForeignKey ? fk : new ForeignKey(fk))),\n    );\n    if (input.control !== undefined) this.control = input.control;\n    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));\n    }\n    freezeNode(this);\n  }\n\n  /**\n   * Runtime guard that a namespace `table` entry is really a `StorageTable`.\n   * The compiler already types the entry as `StorageTable`, but a\n   * freshly-deserialized contract may carry plain JSON at that slot until\n   * hydration; this duck-types the structural shape. Accepts `undefined` so\n   * optional-chained entry lookups pass straight through.\n   */\n  static is(value: StorageTable | undefined): value is StorageTable {\n    if (typeof value !== 'object' || value === null) return false;\n    return 'columns' in value && 'uniques' in value && 'indexes' in value && 'foreignKeys' in value;\n  }\n\n  static assert(\n    value: StorageTable | undefined,\n    coordinate: string,\n  ): asserts value is StorageTable {\n    if (!StorageTable.is(value)) {\n      throw new Error(`Expected a StorageTable at ${coordinate}`);\n    }\n  }\n}\n"],"mappings":"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"}