@prisma-next/sql-contract 0.16.0-dev.25 → 0.16.0-dev.26

package/dist/{storage-table-9O0ZNiMs.mjs → storage-table-DKTrkwZt.mjs}

@@ -1,6 +1,8 @@
 import { IRNodeBase, freezeNode } from "@prisma-next/framework-components/ir";
 import { InternalError } from "@prisma-next/utils/internal-error";
 import { asNamespaceId } from "@prisma-next/contract/types";
+import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
+import { formatWireName, parseWireName } from "@prisma-next/sql-schema-ir/naming";
 //#region src/ir/sql-node.ts
 /**
 * SQL family IR node base. Carries the family-level `kind` discriminator
@@ -157,7 +159,17 @@ var PrimaryKey = class extends SqlNode {
 //#endregion
 //#region src/ir/sql-index.ts
 /**
-* SQL Contract IR node for a table-level secondary index.
+* SQL Contract IR node for a table-level secondary index, name-identified:
+* `name` is the full physical name; a present `prefix` marks the index as
+* managed (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`
+* marks it exact (the name is adopted verbatim).
+*
+* `expression`, `where`, and `unique` are genuine SQL-family attributes —
+* functional and partial indexes are standard SQL supported natively by
+* Postgres and SQLite alike, and the family IR must be able to represent
+* anything any SQL target can introspect. A target declining to AUTHOR them
+* (SQLite's rejection at namespace construction) is a capability decision,
+* not evidence of target-specificity.
 *
 * Note that this class shadows the global TypeScript `Index` lib type
 * at the family-shared name; consumer files that need both should
@@ -165,11 +177,22 @@ var PrimaryKey = class extends SqlNode {
 * `import { Index as SqlIndexNode } from '@prisma-next/sql-contract/types'`).
 */
 var Index = class extends SqlNode {
-	columns;
+	name;
+	unique;
 	constructor(input) {
 		super();
-		this.columns = input.columns;
-		if (input.name !== void 0) this.name = input.name;
+		if (input.name === void 0 || input.name.length === 0) throw new ContractValidationError("Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).", "storage");
+		if (input.columns === void 0 === (input.expression === void 0)) throw new ContractValidationError(`Index "${input.name}": exactly one of columns or expression must be set.`, "storage");
+		if (input.prefix !== void 0) {
+			const parsed = parseWireName(input.name);
+			if (parsed === void 0 || parsed.prefix !== input.prefix) throw new ContractValidationError(`Index "${input.name}": prefix "${input.prefix}" does not match the wire name (expected "${formatWireName(input.prefix, "<8hex>")}").`, "storage");
+		}
+		this.name = input.name;
+		this.unique = input.unique;
+		if (input.prefix !== void 0) this.prefix = input.prefix;
+		if (input.columns !== void 0) this.columns = input.columns;
+		if (input.expression !== void 0) this.expression = input.expression;
+		if (input.where !== void 0) this.where = input.where;
 		if (input.type !== void 0) this.type = input.type;
 		if (input.options !== void 0) this.options = input.options;
 		freezeNode(this);
@@ -270,4 +293,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-9O0ZNiMs.mjs.map
+//# sourceMappingURL=storage-table-DKTrkwZt.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-DKTrkwZt.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 { ContractValidationError } from '@prisma-next/contract/contract-validation-error';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { formatWireName, parseWireName } from '@prisma-next/sql-schema-ir/naming';\nimport { SqlNode } from './sql-node';\n\n/**\n * An index's element structure — exactly one of a column tuple or an opaque\n * expression, made unrepresentable-otherwise at the type level. No\n * discriminant is stored: the JSON shape stays flat (`columns` or\n * `expression`, never both), and the runtime xor guard in the constructor\n * remains as the backstop for JSON loads that bypass this input type.\n */\nexport type IndexElements =\n  | {\n      /** Column-tuple elements. */\n      readonly columns: readonly string[];\n      readonly expression?: never;\n    }\n  | {\n      readonly columns?: never;\n      /**\n       * Opaque SQL: the entire element list between the parens of CREATE\n       * INDEX — one string, never parsed.\n       */\n      readonly expression: string;\n    };\n\n/**\n * Construction input for {@link Index}. Internal seam (built by lowering and\n * FK materialization, not by end users), so every non-element key is\n * required and absence is stated explicitly as `undefined` — matching the\n * `SqlIndexIRInput` convention.\n */\nexport type IndexInput = IndexElements & {\n  /** Full wire name (managed) or verbatim physical name (exact). Always present. */\n  readonly name: string;\n  /**\n   * The managed-mode name prefix — its PRESENCE is the naming-mode\n   * discriminator (there is no stored enum). Present ⇔ managed: the\n   * toolchain owns the physical name and `name === formatWireName(prefix,\n   * <8hex content hash>)`, so the author chooses the prefix but never the\n   * whole name. Absent ⇔ exact: `name` is an adopted verbatim physical name\n   * (PSL `map:`) whose identity the author owns entirely.\n   */\n  readonly prefix: string | undefined;\n  /** Opaque SQL: partial-index predicate (WHERE body, without the keyword). */\n  readonly where: string | undefined;\n  /** Rendered as CREATE UNIQUE INDEX. */\n  readonly unique: boolean;\n  readonly type: string | undefined;\n  readonly options: Record<string, unknown> | undefined;\n};\n\n/**\n * SQL Contract IR node for a table-level secondary index, name-identified:\n * `name` is the full physical name; a present `prefix` marks the index as\n * managed (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`\n * marks it exact (the name is adopted verbatim).\n *\n * `expression`, `where`, and `unique` are genuine SQL-family attributes —\n * functional and partial indexes are standard SQL supported natively by\n * Postgres and SQLite alike, and the family IR must be able to represent\n * anything any SQL target can introspect. A target declining to AUTHOR them\n * (SQLite's rejection at namespace construction) is a capability decision,\n * not evidence of target-specificity.\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 name: string;\n  readonly unique: boolean;\n  /** See {@link IndexInput.prefix} — presence is the naming-mode discriminator. */\n  declare readonly prefix?: string;\n  declare readonly columns?: readonly string[];\n  declare readonly expression?: string;\n  declare readonly where?: string;\n  declare readonly type?: string;\n  declare readonly options?: Record<string, unknown>;\n\n  constructor(input: IndexInput) {\n    super();\n    if (input.name === undefined || input.name.length === 0) {\n      throw new ContractValidationError(\n        'Index: every index carries a full physical name; an expression index must be explicitly named (a default name cannot be derived from an expression).',\n        'storage',\n      );\n    }\n    if ((input.columns === undefined) === (input.expression === undefined)) {\n      throw new ContractValidationError(\n        `Index \"${input.name}\": exactly one of columns or expression must be set.`,\n        'storage',\n      );\n    }\n    if (input.prefix !== undefined) {\n      const parsed = parseWireName(input.name);\n      if (parsed === undefined || parsed.prefix !== input.prefix) {\n        throw new ContractValidationError(\n          `Index \"${input.name}\": prefix \"${input.prefix}\" does not match the wire name (expected \"${formatWireName(input.prefix, '<8hex>')}\").`,\n          'storage',\n        );\n      }\n    }\n    this.name = input.name;\n    this.unique = input.unique;\n    if (input.prefix !== undefined) this.prefix = input.prefix;\n    if (input.columns !== undefined) this.columns = input.columns;\n    if (input.expression !== undefined) this.expression = input.expression;\n    if (input.where !== undefined) this.where = input.where;\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 { InternalError } from '@prisma-next/utils/internal-error';\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 InternalError(`Expected a StorageTable at ${coordinate}`);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{storage-table-mNGckl3_.d.mts → storage-table-zrxIuCJ3.d.mts}

@@ -1,6 +1,7 @@
 import { t as SqlNode } from "./sql-node-QXu33IeX.mjs";
 import { n as ForeignKeyInput, t as ForeignKey } from "./foreign-key-CWCEM2IT.mjs";
-import { a as PrimaryKey, i as IndexInput, n as UniqueConstraintInput, o as PrimaryKeyInput, r as Index, t as UniqueConstraint } from "./unique-constraint-WHfanEUq.mjs";
+import { i as PrimaryKeyInput, n as UniqueConstraintInput, r as PrimaryKey, t as UniqueConstraint } from "./unique-constraint-Bp-q-mr-.mjs";
+import { n as IndexInput, t as Index } from "./sql-index-Wzbj2nbH.mjs";
 import { ColumnDefault, ControlPolicy, ValueSetRef } from "@prisma-next/contract/types";
 //#region src/ir/check-constraint.d.ts
 /**
@@ -125,4 +126,4 @@ declare class StorageTable extends SqlNode {
 }
 //#endregion
 export { CheckConstraint as a, StorageColumnInput as i, StorageTableInput as n, CheckConstraintInput as o, StorageColumn as r, StorageTable as t };
-//# sourceMappingURL=storage-table-mNGckl3_.d.mts.map
+//# sourceMappingURL=storage-table-zrxIuCJ3.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-table-zrxIuCJ3.d.mts","names":[],"sources":["../src/ir/check-constraint.ts","../src/ir/storage-column.ts","../src/ir/storage-table.ts"],"mappings":";;;;;;;;;;;UASiB;WACN;WACA;WACA,UAAU;;;;;;;;;;;;;;;;cAiBR,wBAAwB;WAC1B;WACA;WACA,UAAU;cAEP,OAAO;;;;;;;;;;;;;;UCpBJ;WACN;WACA;WACA;WACA;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;;;;;;;;;;;;;;;cAgBT,sBAAsB;WACxB;WACA;WACA;WACQ;WACA,aAAa;WACb;WACA,UAAU;WACV,UAAU;WACV,WAAW;cAEhB,OAAO;;;;UCvCJ;WACN,SAAS,eAAe,gBAAgB;WACxC,aAAa,aAAa;WAC1B,SAAS,cAAc,mBAAmB;WAC1C,SAAS,cAAc,QAAQ;WAC/B,aAAa,cAAc,aAAa;WACxC,UAAU;WACV,SAAS,cAAc,kBAAkB;;;;;;;;;;;;;;cAevC,qBAAqB;WACvB,SAAS,SAAS,eAAe;WACjC,SAAS,cAAc;WACvB,SAAS,cAAc;WACvB,aAAa,cAAc;WACnB,aAAa;WACb,UAAU;WACV,SAAS,cAAc;cAE5B,OAAO;;;;;;;;SAqCZ,GAAG,OAAO,2BAA2B,SAAS;SAK9C,OACL,OAAO,0BACP,6BACS,SAAS"}

package/dist/{storage-value-set-DiGJT-LT.mjs → storage-value-set-DdL4oin-.mjs}

@@ -1,4 +1,4 @@
-import { l as SqlNode } from "./storage-table-9O0ZNiMs.mjs";
+import { l as SqlNode } from "./storage-table-DKTrkwZt.mjs";
 import { freezeNode } from "@prisma-next/framework-components/ir";
 //#region src/ir/storage-value-set.ts
 /**
@@ -35,4 +35,4 @@ function isStorageValueSet(value) {
 //#endregion
 export { isStorageValueSet as n, StorageValueSet as t };
 
-//# sourceMappingURL=storage-value-set-DiGJT-LT.mjs.map
+//# sourceMappingURL=storage-value-set-DdL4oin-.mjs.map

package/dist/{storage-value-set-DiGJT-LT.mjs.map → storage-value-set-DdL4oin-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"storage-value-set-DiGJT-LT.mjs","names":[],"sources":["../src/ir/storage-value-set.ts"],"sourcesContent":["import type { JsonValue } 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 StorageValueSet}.\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 StorageValueSetInput {\n  readonly kind: 'valueSet';\n  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */\n  readonly values: readonly JsonValue[];\n}\n\n/**\n * SQL Contract IR node for a value-set entry in a namespace's `valueSet`\n * map (`SqlNamespace.entries.valueSet`).\n *\n * A value-set records the ordered set of permitted codec-encoded values for\n * an enum-like column restriction. It does not carry a `codecId` — the\n * column that references it already holds the codec; the value-set holds\n * only the permitted values.\n *\n * The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope\n * carries the discriminator and the serializer hydration walker can\n * dispatch on it. This follows the per-leaf enumerable-kind convention\n * established in the SQL-node comment (future polymorphic dispatch on\n * namespace entries needs the discriminator in JSON).\n *\n * The entry's name is not on the class — value-sets are keyed by name in\n * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.\n */\nexport class StorageValueSet extends SqlNode {\n  override readonly kind = 'valueSet' as const;\n  readonly values: readonly JsonValue[];\n\n  constructor(input: StorageValueSetInput) {\n    super();\n    this.values = Object.freeze([...input.values]);\n    freezeNode(this);\n  }\n}\n\nexport function isStorageValueSet(value: unknown): value is StorageValueSet {\n  if (typeof value !== 'object' || value === null) return false;\n  return 'kind' in value && value.kind === 'valueSet' && 'values' in value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,kBAAb,cAAqC,QAAQ;CAC3C,OAAyB;CACzB;CAEA,YAAY,OAA6B;EACvC,MAAM;EACN,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC;EAC7C,WAAW,IAAI;CACjB;AACF;AAEA,SAAgB,kBAAkB,OAA0C;CAC1E,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,OAAO,UAAU,SAAS,MAAM,SAAS,cAAc,YAAY;AACrE"}
+{"version":3,"file":"storage-value-set-DdL4oin-.mjs","names":[],"sources":["../src/ir/storage-value-set.ts"],"sourcesContent":["import type { JsonValue } 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 StorageValueSet}.\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 StorageValueSetInput {\n  readonly kind: 'valueSet';\n  /** Ordered permitted values, codec-encoded. Declaration order is preserved. */\n  readonly values: readonly JsonValue[];\n}\n\n/**\n * SQL Contract IR node for a value-set entry in a namespace's `valueSet`\n * map (`SqlNamespace.entries.valueSet`).\n *\n * A value-set records the ordered set of permitted codec-encoded values for\n * an enum-like column restriction. It does not carry a `codecId` — the\n * column that references it already holds the codec; the value-set holds\n * only the permitted values.\n *\n * The node's `kind` is enumerable (`'valueSet'`) so the JSON envelope\n * carries the discriminator and the serializer hydration walker can\n * dispatch on it. This follows the per-leaf enumerable-kind convention\n * established in the SQL-node comment (future polymorphic dispatch on\n * namespace entries needs the discriminator in JSON).\n *\n * The entry's name is not on the class — value-sets are keyed by name in\n * the parent namespace's `valueSet: Record<string, StorageValueSet>` map.\n */\nexport class StorageValueSet extends SqlNode {\n  override readonly kind = 'valueSet' as const;\n  readonly values: readonly JsonValue[];\n\n  constructor(input: StorageValueSetInput) {\n    super();\n    this.values = Object.freeze([...input.values]);\n    freezeNode(this);\n  }\n}\n\nexport function isStorageValueSet(value: unknown): value is StorageValueSet {\n  if (typeof value !== 'object' || value === null) return false;\n  return 'kind' in value && value.kind === 'valueSet' && 'values' in value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,kBAAb,cAAqC,QAAQ;CAC3C,OAAyB;CACzB;CAEA,YAAY,OAA6B;EACvC,MAAM;EACN,KAAK,SAAS,OAAO,OAAO,CAAC,GAAG,MAAM,MAAM,CAAC;EAC7C,WAAW,IAAI;CACjB;AACF;AAEA,SAAgB,kBAAkB,OAA0C;CAC1E,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,OAAO,UAAU,SAAS,MAAM,SAAS,cAAc,YAAY;AACrE"}

package/dist/{types-lpzJtKpv.d.mts → types-Bxa1Pyzg.d.mts}

@@ -1,8 +1,9 @@
 import "./sql-node-QXu33IeX.mjs";
-import "./storage-table-mNGckl3_.mjs";
+import "./storage-table-zrxIuCJ3.mjs";
 import { r as ReferentialAction } from "./foreign-key-CWCEM2IT.mjs";
-import "./unique-constraint-WHfanEUq.mjs";
-import "./sql-storage-BIErcfFA.mjs";
+import "./unique-constraint-Bp-q-mr-.mjs";
+import "./sql-index-Wzbj2nbH.mjs";
+import "./sql-storage-DjqU3XXV.mjs";
 import "./storage-value-set-DPHvvSdB.mjs";
 import { CodecTrait } from "@prisma-next/framework-components/codec";
 import { ControlDriverInstance } from "@prisma-next/framework-components/control";
@@ -128,4 +129,4 @@ type ExtractStorageColumnInputTypes<T> = StorageColumnInputTypesOf<ExtractTypeMa
 type ResolveCodecTypes<TContract, TTypeMaps> = [TTypeMaps] extends [never] ? ExtractCodecTypes<TContract> : CodecTypesOf<TTypeMaps>;
 //#endregion
 export { TypeMapsPhantomKey as A, SqlControlDriverInstance as C, StorageColumnInputTypesOf as D, SqlQueryOperationTypes as E, StorageColumnTypesOf as O, ResolveCodecTypes as S, SqlModelStorage as T, QueryOperationReturn as _, ExtractCodecTypes as a, QueryOperationTypesBase as b, ExtractQueryOperationTypes as c, ExtractTypeMapsFromContract as d, FieldInputTypesOf as f, NamespacedStorageColumnTypeMap as g, NamespacedFieldTypeMap as h, DEFAULT_FK_INDEX as i, applyFkDefaults as j, TypeMaps as k, ExtractStorageColumnInputTypes as l, ForeignKeyOptions as m, ContractWithTypeMaps as n, ExtractFieldInputTypes as o, FieldOutputTypesOf as p, DEFAULT_FK_CONSTRAINT as r, ExtractFieldOutputTypes as s, CodecTypesOf as t, ExtractStorageColumnTypes as u, QueryOperationSelfSpec as v, SqlModelFieldStorage as w, QueryOperationTypesOf as x, QueryOperationTypeEntry as y };
-//# sourceMappingURL=types-lpzJtKpv.d.mts.map
+//# sourceMappingURL=types-Bxa1Pyzg.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-Bxa1Pyzg.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;UAIiB,yBAAyB,mCAChC,6BAA6B;EACrC,MAAM,MAAM,yBACV,aACA,8BACC;aAAmB,MAAM;;;KAgDlB;WACD;WACA,WAAW;WACX,WAAW;;KAGV;WACD;WACA;WACA;;KAGC;WACD;WACA;WACA,QAAQ,eAAe;;cAGrB;cACA;iBAEG,gBACd;EAAM;EAAkC;GACxC;EAAqB;EAAkC;;EACpD;EAAqB;;KASd,yBAAyB,eAAe,eAAe;KAEvD,iCAAiC,eAE3C,eAAe;KAGL,SACV,oBAAoB;EAAiB;KAAqB,uBAC1D,6BAA6B,0BAA0B,uBACvD,0BAA0B,yBAAyB,uBACnD,yBAAyB,yBAAyB,uBAClD,4BAA4B,iCAAiC,uBAC7D,iCAAiC,iCAAiC;WAEzD,YAAY;WACZ,qBAAqB;WACrB,kBAAkB;WAClB,iBAAiB;WACjB,oBAAoB;WACpB,yBAAyB;;KAGxB,aAAa,MAAM,qBAC3B,wBACA;WAAqB,kBAAkB;IACrC,UAAU;EAAiB;KACzB,IACA,wBACF;;;;;;;;;KAUM;WACG;WAA0B;WAAyB;;WACnD,iBAAiB;WAAuB;WAA0B;;WAElE;WACA,yBAAyB;WACzB;WACA;;;;;;;;;;KAWH;WACD;aAAuB;aAA0B;;;KAGhD;WACD,OAAO;WACP,UAAU,kBAAkB;;KAG3B,uBACV,YAAY;WAA0B;WAAyB;IAC/D,UAAU,eAAe,4BACvB;KAEQ,0BAA0B,eAAe;KAEzC,sBAAsB,MAAM,qBACpC,wBACA;WAAqB,2BAA2B;IAC9C,UAAU,0BACR,IACA,wBACF;KAEM;KAEA,qBAAqB,WAAW,aAAa,wBAC7C,KAAK,sBAAsB;KAG3B,4BAA4B,KAAK,iCAAiC,IAC1E,YAAY,EAAE,2BAA2B;KAGjC,mBAAmB,MAAM,qBACjC,wBACA;WAAqB,wBAAwB;IAC3C,UAAU,yBACR,IACA,wBACF;KAEM,kBAAkB,MAAM,qBAChC,wBACA;WAAqB,uBAAuB;IAC1C,UAAU,yBACR,IACA,wBACF;KAEM,qBAAqB,MAAM,qBACnC,wBACA;WAAqB,0BAA0B;IAC7C,UAAU,iCACR,IACA,wBACF;KAEM,0BAA0B,MAAM,qBACxC,wBACA;WAAqB,+BAA+B;IAClD,UAAU,iCACR,IACA,wBACF;KAEM,kBAAkB,KAAK,aAAa,4BAA4B;KAChE,2BAA2B,KAAK,sBAAsB,4BAA4B;KAClF,wBAAwB,KAAK,mBAAmB,4BAA4B;KAC5E,uBAAuB,KAAK,kBAAkB,4BAA4B;KAC1E,0BAA0B,KAAK,qBAAqB,4BAA4B;KAChF,+BAA+B,KAAK,0BAC9C,4BAA4B;KAGlB,kBAAkB,WAAW,cAAc,6BACnD,kBAAkB,aAClB,aAAa"}

package/dist/types.d.mts

@@ -1,10 +1,11 @@
 import { t as SqlNode } from "./sql-node-QXu33IeX.mjs";
-import { a as CheckConstraint, i as StorageColumnInput, n as StorageTableInput, o as CheckConstraintInput, r as StorageColumn, t as StorageTable } from "./storage-table-mNGckl3_.mjs";
+import { a as CheckConstraint, i as StorageColumnInput, n as StorageTableInput, o as CheckConstraintInput, r as StorageColumn, t as StorageTable } from "./storage-table-zrxIuCJ3.mjs";
 import { a as ForeignKeyReferenceInput, i as ForeignKeyReference, n as ForeignKeyInput, r as ReferentialAction, t as ForeignKey } from "./foreign-key-CWCEM2IT.mjs";
-import { a as PrimaryKey, i as IndexInput, n as UniqueConstraintInput, o as PrimaryKeyInput, r as Index, t as UniqueConstraint } from "./unique-constraint-WHfanEUq.mjs";
-import { a as SqlNamespaceFactory, c as SqlStorageInput, d as isSqlAuthoringContributions, f as CODEC_INSTANCE_KIND, g as toStorageTypeInstance, h as isStorageTypeInstance, i as SqlNamespaceEntries, l as SqlStorageTypeEntry, m as StorageTypeInstanceInput, n as SqlNamespace, o as SqlNamespaceInput, p as StorageTypeInstance, r as SqlNamespaceBase, s as SqlStorage, t as SqlAuthoringContributions, u as isMaterializedSqlNamespace } from "./sql-storage-BIErcfFA.mjs";
+import { i as PrimaryKeyInput, n as UniqueConstraintInput, r as PrimaryKey, t as UniqueConstraint } from "./unique-constraint-Bp-q-mr-.mjs";
+import { n as IndexInput, t as Index } from "./sql-index-Wzbj2nbH.mjs";
+import { a as SqlNamespaceFactory, c as SqlStorageInput, d as isSqlAuthoringContributions, f as CODEC_INSTANCE_KIND, g as toStorageTypeInstance, h as isStorageTypeInstance, i as SqlNamespaceEntries, l as SqlStorageTypeEntry, m as StorageTypeInstanceInput, n as SqlNamespace, o as SqlNamespaceInput, p as StorageTypeInstance, r as SqlNamespaceBase, s as SqlStorage, t as SqlAuthoringContributions, u as isMaterializedSqlNamespace } from "./sql-storage-DjqU3XXV.mjs";
 import { n as StorageValueSetInput, r as isStorageValueSet, t as StorageValueSet } from "./storage-value-set-DPHvvSdB.mjs";
-import { A as TypeMapsPhantomKey, C as SqlControlDriverInstance, D as StorageColumnInputTypesOf, E as SqlQueryOperationTypes, O as StorageColumnTypesOf, S as ResolveCodecTypes, T as SqlModelStorage, _ as QueryOperationReturn, a as ExtractCodecTypes, b as QueryOperationTypesBase, c as ExtractQueryOperationTypes, d as ExtractTypeMapsFromContract, f as FieldInputTypesOf, g as NamespacedStorageColumnTypeMap, h as NamespacedFieldTypeMap, i as DEFAULT_FK_INDEX, j as applyFkDefaults, k as TypeMaps, l as ExtractStorageColumnInputTypes, m as ForeignKeyOptions, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as FieldOutputTypesOf, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, u as ExtractStorageColumnTypes, v as QueryOperationSelfSpec, w as SqlModelFieldStorage, x as QueryOperationTypesOf, y as QueryOperationTypeEntry } from "./types-lpzJtKpv.mjs";
+import { A as TypeMapsPhantomKey, C as SqlControlDriverInstance, D as StorageColumnInputTypesOf, E as SqlQueryOperationTypes, O as StorageColumnTypesOf, S as ResolveCodecTypes, T as SqlModelStorage, _ as QueryOperationReturn, a as ExtractCodecTypes, b as QueryOperationTypesBase, c as ExtractQueryOperationTypes, d as ExtractTypeMapsFromContract, f as FieldInputTypesOf, g as NamespacedStorageColumnTypeMap, h as NamespacedFieldTypeMap, i as DEFAULT_FK_INDEX, j as applyFkDefaults, k as TypeMaps, l as ExtractStorageColumnInputTypes, m as ForeignKeyOptions, n as ContractWithTypeMaps, o as ExtractFieldInputTypes, p as FieldOutputTypesOf, r as DEFAULT_FK_CONSTRAINT, s as ExtractFieldOutputTypes, t as CodecTypesOf, u as ExtractStorageColumnTypes, v as QueryOperationSelfSpec, w as SqlModelFieldStorage, x as QueryOperationTypesOf, y as QueryOperationTypeEntry } from "./types-Bxa1Pyzg.mjs";
 //#region src/column-type-resolution.d.ts
 type StorageColumnMapAt<SCT, NsId extends string, TableName extends string> = string extends keyof SCT ? never : NsId extends keyof SCT ? string extends keyof SCT[NsId] ? never : TableName extends keyof SCT[NsId] ? SCT[NsId][TableName] : never : never;
 type StorageColumnTypeAcrossNamespaces<SCT, TableName extends string, ColumnName extends string> = { [Ns in keyof SCT]: TableName extends keyof SCT[Ns] ? ColumnName extends keyof SCT[Ns][TableName] ? SCT[Ns][TableName][ColumnName] : never : never; }[keyof SCT];

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/column-type-resolution.ts"],"mappings":";;;;;;;;KACY,mBACV,KACA,qBACA,iDACuB,cAErB,mBAAmB,2BACI,IAAI,gBAEvB,wBAAwB,IAAI,QAC1B,IAAI,MAAM;KAIR,kCACV,KACA,0BACA,gCAEC,YAAY,MAAM,wBAAwB,IAAI,MAC3C,yBAAyB,IAAI,IAAI,aAC/B,IAAI,IAAI,WAAW,qCAGnB"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/column-type-resolution.ts"],"mappings":";;;;;;;;;KACY,mBACV,KACA,qBACA,iDACuB,cAErB,mBAAmB,2BACI,IAAI,gBAEvB,wBAAwB,IAAI,QAC1B,IAAI,MAAM;KAIR,kCACV,KACA,0BACA,gCAEC,YAAY,MAAM,wBAAwB,IAAI,MAC3C,yBAAyB,IAAI,IAAI,aAC/B,IAAI,IAAI,WAAW,qCAGnB"}

package/dist/types.mjs

@@ -1,5 +1,5 @@
-import { a as PrimaryKey, c as CheckConstraint, i as Index, l as SqlNode, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, s as ForeignKeyReference, t as StorageTable } from "./storage-table-9O0ZNiMs.mjs";
-import { n as isStorageValueSet, t as StorageValueSet } from "./storage-value-set-DiGJT-LT.mjs";
+import { a as PrimaryKey, c as CheckConstraint, i as Index, l as SqlNode, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, s as ForeignKeyReference, t as StorageTable } from "./storage-table-DKTrkwZt.mjs";
+import { n as isStorageValueSet, t as StorageValueSet } from "./storage-value-set-DdL4oin-.mjs";
 import { NamespaceBase, freezeNode, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { InternalError } from "@prisma-next/utils/internal-error";
 //#region src/ir/storage-type-instance.ts

package/dist/unique-constraint-Bp-q-mr-.d.mts

@@ -0,0 +1,31 @@
+import { t as SqlNode } from "./sql-node-QXu33IeX.mjs";
+//#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/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
+export { PrimaryKeyInput as i, UniqueConstraintInput as n, PrimaryKey as r, UniqueConstraint as t };
+//# sourceMappingURL=unique-constraint-Bp-q-mr-.d.mts.map

package/dist/unique-constraint-Bp-q-mr-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-constraint-Bp-q-mr-.d.mts","names":[],"sources":["../src/ir/primary-key.ts","../src/ir/unique-constraint.ts"],"mappings":";;UAGiB;WACN;WACA;;;;;cAME,mBAAmB;WACrB;WACQ;cAEL,OAAO;;;;UCZJ;WACN;WACA;;;;;cAME,yBAAyB;WAC3B;WACQ;cAEL,OAAO"}

package/dist/validators.d.mts

@@ -1,7 +1,7 @@
 import { n as ForeignKeyInput, r as ReferentialAction } from "./foreign-key-CWCEM2IT.mjs";
-import { n as UniqueConstraintInput, o as PrimaryKeyInput } from "./unique-constraint-WHfanEUq.mjs";
-import { s as SqlStorage } from "./sql-storage-BIErcfFA.mjs";
-import "./types-lpzJtKpv.mjs";
+import { i as PrimaryKeyInput, n as UniqueConstraintInput } from "./unique-constraint-Bp-q-mr-.mjs";
+import { s as SqlStorage } from "./sql-storage-DjqU3XXV.mjs";
+import "./types-Bxa1Pyzg.mjs";
 import { AnyEntityKindDescriptor } from "@prisma-next/framework-components/ir";
 import { Type } from "arktype";
 import { Contract } from "@prisma-next/contract/types";
@@ -27,8 +27,12 @@ declare const StorageValueSetSchema: import("arktype/internal/variants/object.ts
   values: readonly (string | number | boolean | Record<string, unknown> | unknown[] | null)[];
 }, {}>;
 declare const IndexSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-  columns: readonly string[];
-  name?: string;
+  name: string;
+  unique: boolean;
+  prefix?: string;
+  columns?: readonly string[];
+  expression?: string;
+  where?: string;
   type?: string;
   options?: Record<string, unknown>;
 }, {}>;
@@ -78,8 +82,12 @@ declare const StorageTableSchema: import("arktype/internal/variants/object.ts").
   };
   uniques: readonly UniqueConstraintInput[];
   indexes: readonly {
-    columns: readonly string[];
-    name?: string;
+    name: string;
+    unique: boolean;
+    prefix?: string;
+    columns?: readonly string[];
+    expression?: string;
+    where?: string;
     type?: string;
     options?: Record<string, unknown>;
   }[];

package/dist/validators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/validators.ts"],"mappings":";;;;;;;;KAMK;WACM;WACA,mCAAmC;;KAEzC;WAAmC;WAA2B;;cAMtD,0EAA0B,WAAA;cAK1B,2EAA2B,WAAA;cAK3B,mEAAmB,WAAA,uBAAA;;;;;;cAiCnB,qEAAqB;;gDAArB;;cAiBA,2DAAW;;;;YAAX;;cAOA,yEAAyB;;;;;;cAQzB,sEAAsB;;;;;cAOtB,uEAAuB,WAAA;cAIvB,gEAAgB,WAAA;cAQhB,qEAAqB;;;;;;;;;;;cAOrB,kEAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCZlB,kEAAkB;;;;mDAAlB;;;;;;;;;;;iBA+BG,2BACd,OAAO,oBAAoB,2BAC1B;;;;;;;iBA4Ca,uBACd,OAAO,oBAAoB,2BAC1B;;;;;;iBAwJa,wBACd,OAAO,oBAAoB,2BAC1B;;;;;;;;;;iBAsCa,gBAAgB;iBAchB,cAAc;;;;;;;;;;;;;;iBAoEd,yBAAyB,SAAS;;;;;;;iBAmKlC,+BAA+B,UAAU,SAAS;;;;;;;iBA4DlD,8BAA8B,UAAU,SAAS;UAwGhD;;;;;;;;;WASN,iBAAiB;;;;;;;;;;iBAWZ,yBAAyB,UAAU,SAAS,aAC1D,gBACA,UAAU,kCACT"}
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/validators.ts"],"mappings":";;;;;;;;KAMK;WACM;WACA,mCAAmC;;KAEzC;WAAmC;WAA2B;;cAMtD,0EAA0B,WAAA;cAK1B,2EAA2B,WAAA;cAK3B,mEAAmB,WAAA,uBAAA;;;;;;cAiCnB,qEAAqB;;gDAArB;;cAiBA,2DAAW;;;;;;;;YAAX;;cAWA,yEAAyB;;;;;;cAQzB,sEAAsB;;;;;cAOtB,uEAAuB,WAAA;cAIvB,gEAAgB,WAAA;cAQhB,qEAAqB;;;;;;;;;;;cAOrB,kEAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cChBlB,kEAAkB;;;;mDAAlB;;;;;;;;;;;iBA+BG,2BACd,OAAO,oBAAoB,2BAC1B;;;;;;;iBA4Ca,uBACd,OAAO,oBAAoB,2BAC1B;;;;;;iBAwJa,wBACd,OAAO,oBAAoB,2BAC1B;;;;;;;;;;iBAsCa,gBAAgB;iBAchB,cAAc;;;;;;;;;;;;;;iBAoEd,yBAAyB,SAAS;;;;;;;iBAsKlC,+BAA+B,UAAU,SAAS;;;;;;;iBA4DlD,8BAA8B,UAAU,SAAS;UAwGhD;;;;;;;;;WASN,iBAAiB;;;;;;;;;;iBAWZ,yBAAyB,UAAU,SAAS,aAC1D,gBACA,UAAU,kCACT"}

package/dist/validators.mjs

@@ -1,5 +1,5 @@
 import { t as contractError } from "./contract-errors-CPZcBw8G.mjs";
-import { a as ColumnDefaultFunctionSchema, c as ForeignKeyReferenceSchema, d as IndexSchema, f as ReferentialActionSchema, i as CheckConstraintSchema, l as ForeignKeySchema, m as StorageValueSetSchema, o as ColumnDefaultLiteralSchema, p as StorageTableSchema, s as ColumnDefaultSchema, t as composeSqlEntityKinds, u as ForeignKeySourceSchema } from "./entity-kinds-La8Jg-jW.mjs";
+import { a as ColumnDefaultFunctionSchema, c as ForeignKeyReferenceSchema, d as IndexSchema, f as ReferentialActionSchema, i as CheckConstraintSchema, l as ForeignKeySchema, m as StorageValueSetSchema, o as ColumnDefaultLiteralSchema, p as StorageTableSchema, s as ColumnDefaultSchema, t as composeSqlEntityKinds, u as ForeignKeySourceSchema } from "./entity-kinds-CdHJQGi0.mjs";
 import { isPlainRecord } from "@prisma-next/framework-components/ir";
 import { type } from "arktype";
 import { CrossReferenceSchema } from "@prisma-next/contract/types";
@@ -320,15 +320,18 @@ function validateStorageSemantics(storage) {
 		const sortOptions = (o) => o ? Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b))) : null;
 		const seenIndexDefinitions = /* @__PURE__ */ new Set();
 		for (const index of table.indexes) {
-			const duplicateColumn = findDuplicateValue(index.columns);
+			const duplicateColumn = findDuplicateValue(index.columns ?? []);
 			if (duplicateColumn !== void 0) errors.push(`Namespace "${namespaceId}" table "${tableName}": index contains duplicate column "${duplicateColumn}"`);
 			const signature = JSON.stringify({
-				columns: index.columns,
+				columns: index.columns ?? null,
+				expression: index.expression ?? null,
+				where: index.where ?? null,
+				unique: index.unique,
 				type: index.type ?? null,
 				options: sortOptions(index.options)
 			});
 			if (seenIndexDefinitions.has(signature)) {
-				errors.push(`Namespace "${namespaceId}" table "${tableName}": duplicate index definition on columns [${index.columns.join(", ")}]`);
+				errors.push(`Namespace "${namespaceId}" table "${tableName}": duplicate index definition on columns [${(index.columns ?? []).join(", ")}]`);
 				continue;
 			}
 			seenIndexDefinitions.add(signature);
@@ -415,7 +418,7 @@ function validateSqlStorageConsistency(contract) {
 			for (const colName of table.primaryKey.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" primaryKey references non-existent column "${colName}"`, "storage");
 		}
 		for (const unique of table.uniques) for (const colName of unique.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" unique constraint references non-existent column "${colName}"`, "storage");
-		for (const index of table.indexes) for (const colName of index.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index references non-existent column "${colName}"`, "storage");
+		for (const index of table.indexes) for (const colName of index.columns ?? []) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index references non-existent column "${colName}"`, "storage");
 		for (const check of table.checks ?? []) if (!columnNames.has(check.column)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" check constraint "${check.name}" references non-existent column "${check.column}"`, "storage");
 		for (const [colName, column] of Object.entries(table.columns)) if (!column.nullable && column.default?.kind === "literal" && column.default.value === null) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" column "${colName}" is NOT NULL but has a literal null default`, "storage");
 		for (const fk of table.foreignKeys) {