@prisma-next/sql-contract 0.16.0-dev.3 → 0.16.0-dev.30

package/README.md

@@ -165,7 +165,7 @@ const userModel = model('user', {
 // Create a complete contract
 const c = contract({
   target: 'postgres',
-  storageHash: 'sha256:abc123',
+  storageHash: 'abc123',
   storage: s,
   models: { User: userModel },
 });

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

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;cAoDa;WACF,qBAAqB;WACrB,aAAa"}
+{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;cAwDa;WACF,qBAAqB;WACrB,aAAa"}

package/dist/canonicalization-hooks.mjs

@@ -29,6 +29,16 @@ const preserveEmptyPatterns = [
 			"foreignKeys"
 		]
 	],
+	[
+		"storage",
+		"namespaces",
+		"*",
+		"entries",
+		"table",
+		"*",
+		"indexes",
+		"unique"
+	],
 	[
 		"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  // 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"}
+{"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  // An index's `unique` flag is a required boolean: `unique: false` must\n  // survive the default-omission walk or the emitted contract fails its own\n  // IndexSchema validation on the next read.\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'indexes', 'unique'],\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;CAI7F;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;EAAW;CAAQ;CAK3E;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,4 +1,4 @@
-import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
+import { s as SqlStorage } from "./sql-storage-DjqU3XXV.mjs";
 import { DefaultNamespaceEntries, NamespacedEntities, SingleNamespaceView } from "@prisma-next/framework-components/ir";
 import { Contract } from "@prisma-next/contract/types";
 //#region src/contract-view.d.ts

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

@@ -1,5 +1,6 @@
-import { t as StorageTable } from "./storage-table-DBpYBmty.mjs";
-import { t as StorageValueSet } from "./storage-value-set-3BKuha5q.mjs";
+import { t as contractError } from "./contract-errors-CPZcBw8G.mjs";
+import { t as StorageTable } from "./storage-table-DKTrkwZt.mjs";
+import { t as StorageValueSet } from "./storage-value-set-DdL4oin-.mjs";
 import { type } from "arktype";
 //#region src/ir/storage-entry-schemas.ts
 const literalKindSchema = type("'literal'");
@@ -54,8 +55,12 @@ const UniqueConstraintSchema = type.declare().type({
 	"name?": "string"
 });
 const IndexSchema = type({
-	columns: type.string.array().readonly(),
-	"name?": "string",
+	name: "string",
+	"prefix?": "string",
+	"columns?": type.string.array().readonly(),
+	"expression?": "string",
+	"where?": "string",
+	unique: "boolean",
 	"type?": "string",
 	"options?": "Record<string, unknown>"
 });
@@ -119,7 +124,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;
@@ -127,4 +132,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-CVg6HzG2.mjs.map
+//# sourceMappingURL=entity-kinds-CdHJQGi0.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-CdHJQGi0.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  name: 'string',\n  'prefix?': 'string',\n  'columns?': type.string.array().readonly(),\n  'expression?': 'string',\n  'where?': 'string',\n  unique: 'boolean',\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,MAAM;CACN,WAAW;CACX,YAAY,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACzC,eAAe;CACf,UAAU;CACV,QAAQ;CACR,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;;;ACzHD,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,4 +1,4 @@
-import { n as StorageTableInput, t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { n as StorageTableInput, t as StorageTable } from "./storage-table-zrxIuCJ3.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

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

@@ -1 +1 @@
-{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;cAQa,iBAAiB,qBAAqB,mBAAmB;cAMzD,oBAAoB,qBAAqB,sBAAsB;;;;;;;;;iBAc5D,sBACd,qBAAoB,4BACnB,oBAAoB"}
+{"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-CVg6HzG2.mjs";
+import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-CdHJQGi0.mjs";
 export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };

package/dist/factories.d.mts

@@ -1,7 +1,8 @@
-import { i as StorageColumnInput, r as StorageColumn, t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { i as StorageColumnInput, r as StorageColumn, t as StorageTable } from "./storage-table-zrxIuCJ3.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 { r as PrimaryKey, t as UniqueConstraint } from "./unique-constraint-Bp-q-mr-.mjs";
+import { t as Index } from "./sql-index-Wzbj2nbH.mjs";
+import { T as SqlModelStorage, m as ForeignKeyOptions, w as SqlModelFieldStorage } from "./types-Bxa1Pyzg.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
 //#region src/factories.d.ts
 declare function col(nativeType: string, codecId: string, nullable?: boolean, opts?: {
@@ -9,7 +10,12 @@ declare function col(nativeType: string, codecId: string, nullable?: boolean, op
 }): StorageColumn;
 declare function pk(...columns: readonly string[]): PrimaryKey;
 declare function unique(...columns: readonly string[]): UniqueConstraint;
-declare function index(...columns: readonly string[]): Index;
+declare function index(name: string, columns: readonly string[], opts?: {
+  readonly prefix?: string;
+  readonly unique?: boolean;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}): Index;
 declare function fk(srcTableName: string, srcColumns: readonly string[], targetTableName: string, targetColumns: readonly string[], opts?: ForeignKeyOptions & {
   namespaceId?: string;
 }): ForeignKey;

package/dist/factories.d.mts.map

@@ -1 +1 @@
-{"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"}
+{"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,MACd,cACA,4BACA;WACW;WACA;WACA;WACA,UAAU;IAEpB;iBAYa,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,4 +1,4 @@
-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 { a as PrimaryKey, i as Index, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, t as StorageTable } from "./storage-table-DKTrkwZt.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
 //#region src/factories.ts
@@ -16,8 +16,16 @@ function pk(...columns) {
 function unique(...columns) {
 	return new UniqueConstraint({ columns });
 }
-function index(...columns) {
-	return new Index({ columns });
+function index(name, columns, opts) {
+	return new Index({
+		name,
+		prefix: opts?.prefix,
+		columns,
+		where: void 0,
+		unique: opts?.unique ?? false,
+		type: opts?.type,
+		options: opts?.options
+	});
 }
 function fk(srcTableName, srcColumns, targetTableName, targetColumns, opts) {
 	const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);

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  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"}
+{"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(\n  name: string,\n  columns: readonly string[],\n  opts?: {\n    readonly prefix?: string;\n    readonly unique?: boolean;\n    readonly type?: string;\n    readonly options?: Record<string, unknown>;\n  },\n): Index {\n  return new Index({\n    name,\n    prefix: opts?.prefix,\n    columns,\n    where: undefined,\n    unique: opts?.unique ?? false,\n    type: opts?.type,\n    options: opts?.options,\n  });\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,MACd,MACA,SACA,MAMO;CACP,OAAO,IAAI,MAAM;EACf;EACA,QAAQ,MAAM;EACd;EACA,OAAO,KAAA;EACP,QAAQ,MAAM,UAAU;EACxB,MAAM,MAAM;EACZ,SAAS,MAAM;CACjB,CAAC;AACH;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-materialization.d.mts

@@ -1,9 +1,10 @@
 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";
+import { i as PrimaryKeyInput, n as UniqueConstraintInput } from "./unique-constraint-Bp-q-mr-.mjs";
+import { n as IndexInput } from "./sql-index-Wzbj2nbH.mjs";
 //#region src/foreign-key-materialization.d.ts
 type BackingIndexCandidates = {
   readonly indexes: readonly {
-    readonly columns: readonly string[];
+    readonly columns?: readonly string[];
   }[];
   readonly uniques: readonly {
     readonly columns: readonly string[];
@@ -52,10 +53,10 @@ interface MaterializedTableConstraints {
  * 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.
+ * backed by a declared index/unique/primary-key contributes a managed
+ * `indexes[]` entry (default prefix + content-hash wire name). 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

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

@@ -1 +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"}
+{"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;;;;;;iBAe9B,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

@@ -1,4 +1,4 @@
-import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
+import { t as lowerAuthoredIndex } from "./index-naming-DsnarUVW.mjs";
 //#region src/foreign-key-materialization.ts
 /**
 * The column-list keys (`"colA,colB"`, order preserved) a table's own
@@ -13,7 +13,7 @@ import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 */
 function backingIndexColumnKeys(table) {
 	return [
-		...table.indexes.map((index) => index.columns.join(",")),
+		...table.indexes.flatMap((index) => index.columns !== void 0 ? [index.columns.join(",")] : []),
 		...table.uniques.map((unique) => unique.columns.join(",")),
 		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
 	];
@@ -30,10 +30,10 @@ function isBackedByColumnKeys(columns, backingKeys) {
 * 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.
+* backed by a declared index/unique/primary-key contributes a managed
+* `indexes[]` entry (default prefix + content-hash wire name). 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({
@@ -48,10 +48,13 @@ function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexe
 		if (index !== false) {
 			const key = reference.source.columns.join(",");
 			if (!satisfiedIndexColumns.has(key)) {
-				synthesizedIndexes.push({
+				synthesizedIndexes.push(lowerAuthoredIndex(tableName, {
 					columns: reference.source.columns,
-					name: defaultIndexName(tableName, reference.source.columns)
-				});
+					map: void 0,
+					name: void 0,
+					type: void 0,
+					options: void 0
+				}));
 				satisfiedIndexColumns.add(key);
 			}
 		}

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

@@ -1 +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"}
+{"version":3,"file":"foreign-key-materialization.mjs","names":[],"sources":["../src/foreign-key-materialization.ts"],"sourcesContent":["import { lowerAuthoredIndex } from './index-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.flatMap((index) =>\n      index.columns !== undefined ? [index.columns.join(',')] : [],\n    ),\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 managed\n * `indexes[]` entry (default prefix + content-hash wire name). Declared\n * indexes always survive unchanged; a second FK sharing already-synthesized\n * backing columns does not 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          lowerAuthoredIndex(tableName, {\n            columns: reference.source.columns,\n            map: undefined,\n            name: undefined,\n            type: undefined,\n            options: undefined,\n          }),\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,SAAS,UACxB,MAAM,YAAY,KAAA,IAAY,CAAC,MAAM,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC,CAC7D;EACA,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,KACjB,mBAAmB,WAAW;KAC5B,SAAS,UAAU,OAAO;KAC1B,KAAK,KAAA;KACL,MAAM,KAAA;KACN,MAAM,KAAA;KACN,SAAS,KAAA;IACX,CAAC,CACH;IACA,sBAAsB,IAAI,GAAG;GAC/B;EACF;CACF;CAEA,OAAO;EACL,aAAa;EACb,SAAS,CAAC,GAAG,iBAAiB,GAAG,kBAAkB;CACrD;AACF"}

package/dist/index-naming-DsnarUVW.mjs

@@ -0,0 +1,43 @@
+import { InternalError } from "@prisma-next/utils/internal-error";
+import { assertWireNamePrefixLength, computeIndexContentHash, defaultIndexName, formatWireName } from "@prisma-next/sql-schema-ir/naming";
+//#region src/index-naming.ts
+/**
+* Lowers an authored index into the name-identified entity `contract.json`
+* persists: exact mode adopts `map` verbatim (no prefix, no hash); managed
+* mode appends the content-hash suffix to the authored or default prefix.
+* `unique` always lowers `false` — no authoring surface sets it yet.
+*/
+function lowerAuthoredIndex(tableName, authored) {
+	if (authored.map !== void 0) {
+		if (authored.name !== void 0) throw new InternalError(`Index "${authored.map}" on table "${tableName}": map and name are mutually exclusive.`);
+		return {
+			name: authored.map,
+			prefix: void 0,
+			columns: authored.columns,
+			where: void 0,
+			unique: false,
+			type: authored.type,
+			options: authored.options
+		};
+	}
+	const prefix = authored.name ?? defaultIndexName(tableName, authored.columns);
+	assertWireNamePrefixLength(prefix, "index prefix");
+	return {
+		name: formatWireName(prefix, computeIndexContentHash({
+			columns: authored.columns,
+			unique: false,
+			...authored.type !== void 0 && { type: authored.type },
+			...authored.options !== void 0 && { options: authored.options }
+		})),
+		prefix,
+		columns: authored.columns,
+		where: void 0,
+		unique: false,
+		type: authored.type,
+		options: authored.options
+	};
+}
+//#endregion
+export { lowerAuthoredIndex as t };
+
+//# sourceMappingURL=index-naming-DsnarUVW.mjs.map

package/dist/index-naming-DsnarUVW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-naming-DsnarUVW.mjs","names":[],"sources":["../src/index-naming.ts"],"sourcesContent":["import {\n  assertWireNamePrefixLength,\n  computeIndexContentHash,\n  defaultIndexName,\n  formatWireName,\n} from '@prisma-next/sql-schema-ir/naming';\nimport { InternalError } from '@prisma-next/utils/internal-error';\nimport type { IndexInput } from './ir/sql-index';\n\n/**\n * An index as authored, before naming: `map` is an exact physical name\n * (adopted verbatim, PSL `map:`); `name` is a managed wire-name prefix\n * (TS `name:`). With neither, the managed prefix defaults to\n * `defaultIndexName(table, columns)`.\n */\nexport interface AuthoredIndexInput {\n  readonly columns: readonly string[];\n  readonly map: string | undefined;\n  readonly name: string | undefined;\n  readonly type: string | undefined;\n  readonly options: Record<string, unknown> | undefined;\n}\n\n/**\n * Lowers an authored index into the name-identified entity `contract.json`\n * persists: exact mode adopts `map` verbatim (no prefix, no hash); managed\n * mode appends the content-hash suffix to the authored or default prefix.\n * `unique` always lowers `false` — no authoring surface sets it yet.\n */\nexport function lowerAuthoredIndex(tableName: string, authored: AuthoredIndexInput): IndexInput {\n  if (authored.map !== undefined) {\n    if (authored.name !== undefined) {\n      throw new InternalError(\n        `Index \"${authored.map}\" on table \"${tableName}\": map and name are mutually exclusive.`,\n      );\n    }\n    return {\n      name: authored.map,\n      prefix: undefined,\n      columns: authored.columns,\n      where: undefined,\n      unique: false,\n      type: authored.type,\n      options: authored.options,\n    };\n  }\n\n  const prefix = authored.name ?? defaultIndexName(tableName, authored.columns);\n  assertWireNamePrefixLength(prefix, 'index prefix');\n  const hash = computeIndexContentHash({\n    columns: authored.columns,\n    unique: false,\n    ...(authored.type !== undefined && { type: authored.type }),\n    ...(authored.options !== undefined && { options: authored.options }),\n  });\n  return {\n    name: formatWireName(prefix, hash),\n    prefix,\n    columns: authored.columns,\n    where: undefined,\n    unique: false,\n    type: authored.type,\n    options: authored.options,\n  };\n}\n"],"mappings":";;;;;;;;;AA6BA,SAAgB,mBAAmB,WAAmB,UAA0C;CAC9F,IAAI,SAAS,QAAQ,KAAA,GAAW;EAC9B,IAAI,SAAS,SAAS,KAAA,GACpB,MAAM,IAAI,cACR,UAAU,SAAS,IAAI,cAAc,UAAU,wCACjD;EAEF,OAAO;GACL,MAAM,SAAS;GACf,QAAQ,KAAA;GACR,SAAS,SAAS;GAClB,OAAO,KAAA;GACP,QAAQ;GACR,MAAM,SAAS;GACf,SAAS,SAAS;EACpB;CACF;CAEA,MAAM,SAAS,SAAS,QAAQ,iBAAiB,WAAW,SAAS,OAAO;CAC5E,2BAA2B,QAAQ,cAAc;CAOjD,OAAO;EACL,MAAM,eAAe,QAPV,wBAAwB;GACnC,SAAS,SAAS;GAClB,QAAQ;GACR,GAAI,SAAS,SAAS,KAAA,KAAa,EAAE,MAAM,SAAS,KAAK;GACzD,GAAI,SAAS,YAAY,KAAA,KAAa,EAAE,SAAS,SAAS,QAAQ;EACpE,CAEkC,CAAC;EACjC;EACA,SAAS,SAAS;EAClB,OAAO,KAAA;EACP,QAAQ;EACR,MAAM,SAAS;EACf,SAAS,SAAS;CACpB;AACF"}

package/dist/index-naming.d.mts

@@ -0,0 +1,25 @@
+import { n as IndexInput } from "./sql-index-Wzbj2nbH.mjs";
+//#region src/index-naming.d.ts
+/**
+ * An index as authored, before naming: `map` is an exact physical name
+ * (adopted verbatim, PSL `map:`); `name` is a managed wire-name prefix
+ * (TS `name:`). With neither, the managed prefix defaults to
+ * `defaultIndexName(table, columns)`.
+ */
+interface AuthoredIndexInput {
+  readonly columns: readonly string[];
+  readonly map: string | undefined;
+  readonly name: string | undefined;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+}
+/**
+ * Lowers an authored index into the name-identified entity `contract.json`
+ * persists: exact mode adopts `map` verbatim (no prefix, no hash); managed
+ * mode appends the content-hash suffix to the authored or default prefix.
+ * `unique` always lowers `false` — no authoring surface sets it yet.
+ */
+declare function lowerAuthoredIndex(tableName: string, authored: AuthoredIndexInput): IndexInput;
+//#endregion
+export { type AuthoredIndexInput, lowerAuthoredIndex };
+//# sourceMappingURL=index-naming.d.mts.map

package/dist/index-naming.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-naming.d.mts","names":[],"sources":["../src/index-naming.ts"],"mappings":";;;;;;;;UAeiB;WACN;WACA;WACA;WACA;WACA,SAAS;;;;;;;;iBASJ,mBAAmB,mBAAmB,UAAU,qBAAqB"}

package/dist/index-naming.mjs

@@ -0,0 +1,2 @@
+import { t as lowerAuthoredIndex } from "./index-naming-DsnarUVW.mjs";
+export { lowerAuthoredIndex };

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

@@ -1,5 +1,5 @@
-import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
-import "./types-lpzJtKpv.mjs";
+import { s as SqlStorage } from "./sql-storage-DjqU3XXV.mjs";
+import "./types-Bxa1Pyzg.mjs";
 import { a as IndexTypeRegistry } from "./index-types-DPVhsW0v.mjs";
 import { Contract } from "@prisma-next/contract/types";
 //#region src/index-type-validation.d.ts

package/dist/index-type-validation.mjs

@@ -3,13 +3,13 @@ import { ContractValidationError } from "@prisma-next/contract/contract-validati
 //#region src/index-type-validation.ts
 function validateIndexTypes(contract, indexTypeRegistry) {
 	for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) for (const index of table.indexes) {
-		if (index.type === void 0 && index.options !== void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has options without a type`, "storage");
+		if (index.type === void 0 && index.options !== void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index "${index.name}" has options without a type`, "storage");
 		if (index.type === void 0) continue;
 		const entry = indexTypeRegistry.get(index.type);
-		if (entry === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] uses unregistered index type "${index.type}"`, "storage");
+		if (entry === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index "${index.name}" uses unregistered index type "${index.type}"`, "storage");
 		const optionsValue = index.options ?? {};
 		const result = entry.options(optionsValue);
-		if (result instanceof type.errors) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index on columns [${index.columns.join(", ")}] has invalid options for type "${index.type}": ${result.summary}`, "storage");
+		if (result instanceof type.errors) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index "${index.name}" has invalid options for type "${index.type}": ${result.summary}`, "storage");
 	}
 }
 //#endregion

package/dist/index-type-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index-type-validation.mjs","names":[],"sources":["../src/index-type-validation.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport type { Contract } from '@prisma-next/contract/types';\nimport { type } from 'arktype';\nimport type { IndexTypeRegistry } from './index-types';\nimport type { SqlStorage } from './types';\n\nexport function validateIndexTypes(\n  contract: Contract<SqlStorage>,\n  indexTypeRegistry: IndexTypeRegistry,\n): void {\n  for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {\n    for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) {\n      for (const index of table.indexes) {\n        if (index.type === undefined && index.options !== undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has options without a type`,\n            'storage',\n          );\n        }\n        if (index.type === undefined) continue;\n        const entry = indexTypeRegistry.get(index.type);\n        if (entry === undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] uses unregistered index type \"${index.type}\"`,\n            'storage',\n          );\n        }\n        const optionsValue = index.options ?? {};\n        const result = entry.options(optionsValue);\n        if (result instanceof type.errors) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index on columns [${index.columns.join(', ')}] has invalid options for type \"${index.type}\": ${result.summary}`,\n            'storage',\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,mBACd,UACA,mBACM;CACN,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,SAAS,QAAQ,UAAU,GACxE,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,QAAQ,SAAS,CAAC,CAAC,GACpE,KAAK,MAAM,SAAS,MAAM,SAAS;EACjC,IAAI,MAAM,SAAS,KAAA,KAAa,MAAM,YAAY,KAAA,GAChD,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,+BAC9F,SACF;EAEF,IAAI,MAAM,SAAS,KAAA,GAAW;EAC9B,MAAM,QAAQ,kBAAkB,IAAI,MAAM,IAAI;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,IAC3I,SACF;EAEF,MAAM,eAAe,MAAM,WAAW,CAAC;EACvC,MAAM,SAAS,MAAM,QAAQ,YAAY;EACzC,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,sBAAsB,MAAM,QAAQ,KAAK,IAAI,EAAE,kCAAkC,MAAM,KAAK,KAAK,OAAO,WACvJ,SACF;CAEJ;AAGN"}
+{"version":3,"file":"index-type-validation.mjs","names":[],"sources":["../src/index-type-validation.ts"],"sourcesContent":["import { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport type { Contract } from '@prisma-next/contract/types';\nimport { type } from 'arktype';\nimport type { IndexTypeRegistry } from './index-types';\nimport type { SqlStorage } from './types';\n\nexport function validateIndexTypes(\n  contract: Contract<SqlStorage>,\n  indexTypeRegistry: IndexTypeRegistry,\n): void {\n  for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) {\n    for (const [tableName, table] of Object.entries(ns.entries.table ?? {})) {\n      for (const index of table.indexes) {\n        if (index.type === undefined && index.options !== undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index \"${index.name}\" has options without a type`,\n            'storage',\n          );\n        }\n        if (index.type === undefined) continue;\n        const entry = indexTypeRegistry.get(index.type);\n        if (entry === undefined) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index \"${index.name}\" uses unregistered index type \"${index.type}\"`,\n            'storage',\n          );\n        }\n        const optionsValue = index.options ?? {};\n        const result = entry.options(optionsValue);\n        if (result instanceof type.errors) {\n          throw new ContractValidationError(\n            `Namespace \"${namespaceId}\" table \"${tableName}\" index \"${index.name}\" has invalid options for type \"${index.type}\": ${result.summary}`,\n            'storage',\n          );\n        }\n      }\n    }\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,mBACd,UACA,mBACM;CACN,KAAK,MAAM,CAAC,aAAa,OAAO,OAAO,QAAQ,SAAS,QAAQ,UAAU,GACxE,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,QAAQ,SAAS,CAAC,CAAC,GACpE,KAAK,MAAM,SAAS,MAAM,SAAS;EACjC,IAAI,MAAM,SAAS,KAAA,KAAa,MAAM,YAAY,KAAA,GAChD,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,WAAW,MAAM,KAAK,+BACrE,SACF;EAEF,IAAI,MAAM,SAAS,KAAA,GAAW;EAC9B,MAAM,QAAQ,kBAAkB,IAAI,MAAM,IAAI;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,WAAW,MAAM,KAAK,kCAAkC,MAAM,KAAK,IAClH,SACF;EAEF,MAAM,eAAe,MAAM,WAAW,CAAC;EACvC,MAAM,SAAS,MAAM,QAAQ,YAAY;EACzC,IAAI,kBAAkB,KAAK,QACzB,MAAM,IAAI,wBACR,cAAc,YAAY,WAAW,UAAU,WAAW,MAAM,KAAK,kCAAkC,MAAM,KAAK,KAAK,OAAO,WAC9H,SACF;CAEJ;AAGN"}

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

@@ -1 +1 @@
-{"version":3,"file":"index-types-DPVhsW0v.d.mts","names":[],"sources":["../src/index-types.ts"],"mappings":";;UAEiB,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;;;iBA0B9C,oBAAoB,iBAAiB;UAIpC;EACf,SAAS,OAAO;EAChB,IAAI,sBAAsB;EAC1B,IAAI;;iBAsBU,2BAA2B"}
+{"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.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/resolve-storage-table.d.mts

@@ -1,5 +1,5 @@
-import { t as StorageTable } from "./storage-table-mNGckl3_.mjs";
-import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
+import { t as StorageTable } from "./storage-table-zrxIuCJ3.mjs";
+import { s as SqlStorage } from "./sql-storage-DjqU3XXV.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;WACN;WACA,OAAO;;;;;;;;;;;iBAYF,oBACd,SAAS,YACT,mBACA,uBACC"}
+{"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

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

@@ -1 +1 @@
-{"version":3,"file":"resolve-storage-table.mjs","names":[],"sources":["../src/resolve-storage-table.ts"],"sourcesContent":["import { entityAt } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from './ir/sql-storage';\nimport type { StorageTable } from './ir/storage-table';\n\nexport interface ResolvedStorageTable {\n  readonly namespaceId: string;\n  readonly table: StorageTable;\n}\n\n/**\n * Resolve a bare storage table name to its namespace coordinate and table IR.\n *\n * When `namespaceId` is supplied, the table is resolved strictly within that\n * namespace (no scan). When omitted, a bare name unique across namespaces\n * resolves to its sole namespace; a bare name declared in more than one\n * namespace throws a fail-fast diagnostic naming the candidate namespaces\n * rather than silently selecting the first match.\n */\nexport function resolveStorageTable(\n  storage: SqlStorage,\n  tableName: string,\n  namespaceId?: string,\n): ResolvedStorageTable | undefined {\n  if (namespaceId !== undefined) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    return table === undefined ? undefined : { namespaceId, table };\n  }\n\n  const matches: ResolvedStorageTable[] = [];\n  for (const candidateNamespaceId of Object.keys(storage.namespaces)) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId: candidateNamespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    if (table !== undefined) {\n      matches.push({ namespaceId: candidateNamespaceId, table });\n    }\n  }\n\n  if (matches.length > 1) {\n    const candidates = matches\n      .map((match) => match.namespaceId)\n      .sort()\n      .join(', ');\n    throw new Error(\n      `Storage table \"${tableName}\" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`,\n    );\n  }\n\n  return matches[0];\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,oBACd,SACA,WACA,aACkC;CAClC,IAAI,gBAAgB,KAAA,GAAW;EAC7B,MAAM,QAAQ,SAAuB,SAAS;GAC5C;GACA,YAAY;GACZ,YAAY;EACd,CAAC;EACD,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY;GAAE;GAAa;EAAM;CAChE;CAEA,MAAM,UAAkC,CAAC;CACzC,KAAK,MAAM,wBAAwB,OAAO,KAAK,QAAQ,UAAU,GAAG;EAClE,MAAM,QAAQ,SAAuB,SAAS;GAC5C,aAAa;GACb,YAAY;GACZ,YAAY;EACd,CAAC;EACD,IAAI,UAAU,KAAA,GACZ,QAAQ,KAAK;GAAE,aAAa;GAAsB;EAAM,CAAC;CAE7D;CAEA,IAAI,QAAQ,SAAS,GAAG;EACtB,MAAM,aAAa,QAChB,KAAK,UAAU,MAAM,WAAW,CAAC,CACjC,KAAK,CAAC,CACN,KAAK,IAAI;EACZ,MAAM,IAAI,MACR,kBAAkB,UAAU,oCAAoC,WAAW,2CAC7E;CACF;CAEA,OAAO,QAAQ;AACjB"}
+{"version":3,"file":"resolve-storage-table.mjs","names":[],"sources":["../src/resolve-storage-table.ts"],"sourcesContent":["import { entityAt } from '@prisma-next/framework-components/ir';\nimport { contractError } from './contract-errors';\nimport type { SqlStorage } from './ir/sql-storage';\nimport type { StorageTable } from './ir/storage-table';\n\nexport interface ResolvedStorageTable {\n  readonly namespaceId: string;\n  readonly table: StorageTable;\n}\n\n/**\n * Resolve a bare storage table name to its namespace coordinate and table IR.\n *\n * When `namespaceId` is supplied, the table is resolved strictly within that\n * namespace (no scan). When omitted, a bare name unique across namespaces\n * resolves to its sole namespace; a bare name declared in more than one\n * namespace throws a fail-fast diagnostic naming the candidate namespaces\n * rather than silently selecting the first match.\n */\nexport function resolveStorageTable(\n  storage: SqlStorage,\n  tableName: string,\n  namespaceId?: string,\n): ResolvedStorageTable | undefined {\n  if (namespaceId !== undefined) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    return table === undefined ? undefined : { namespaceId, table };\n  }\n\n  const matches: ResolvedStorageTable[] = [];\n  for (const candidateNamespaceId of Object.keys(storage.namespaces)) {\n    const table = entityAt<StorageTable>(storage, {\n      namespaceId: candidateNamespaceId,\n      entityKind: 'table',\n      entityName: tableName,\n    });\n    if (table !== undefined) {\n      matches.push({ namespaceId: candidateNamespaceId, table });\n    }\n  }\n\n  if (matches.length > 1) {\n    const candidates = matches\n      .map((match) => match.namespaceId)\n      .sort()\n      .join(', ');\n    throw contractError(\n      'CONTRACT.TABLE_AMBIGUOUS',\n      `Storage table \"${tableName}\" is ambiguous across namespaces [${candidates}]; qualify it with a namespace coordinate.`,\n      { meta: { tableName, candidates: matches.map((match) => match.namespaceId).sort() } },\n    );\n  }\n\n  return matches[0];\n}\n"],"mappings":";;;;;;;;;;;;AAmBA,SAAgB,oBACd,SACA,WACA,aACkC;CAClC,IAAI,gBAAgB,KAAA,GAAW;EAC7B,MAAM,QAAQ,SAAuB,SAAS;GAC5C;GACA,YAAY;GACZ,YAAY;EACd,CAAC;EACD,OAAO,UAAU,KAAA,IAAY,KAAA,IAAY;GAAE;GAAa;EAAM;CAChE;CAEA,MAAM,UAAkC,CAAC;CACzC,KAAK,MAAM,wBAAwB,OAAO,KAAK,QAAQ,UAAU,GAAG;EAClE,MAAM,QAAQ,SAAuB,SAAS;GAC5C,aAAa;GACb,YAAY;GACZ,YAAY;EACd,CAAC;EACD,IAAI,UAAU,KAAA,GACZ,QAAQ,KAAK;GAAE,aAAa;GAAsB;EAAM,CAAC;CAE7D;CAEA,IAAI,QAAQ,SAAS,GAKnB,MAAM,cACJ,4BACA,kBAAkB,UAAU,oCANX,QAChB,KAAK,UAAU,MAAM,WAAW,CAAC,CACjC,KAAK,CAAC,CACN,KAAK,IAGmE,EAAE,6CAC3E,EAAE,MAAM;EAAE;EAAW,YAAY,QAAQ,KAAK,UAAU,MAAM,WAAW,CAAC,CAAC,KAAK;CAAE,EAAE,CACtF;CAGF,OAAO,QAAQ;AACjB"}