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

package/README.md

@@ -54,6 +54,8 @@ This package defines the core types for the SQL Schema IR, a target-agnostic rep
 
 3. **Shared Plane**: This package is in the **shared plane**, meaning it can be safely imported by both migration-plane (verification, migration planning) and runtime-plane code.
 
+4. **Name-identified indexes**: `SqlIndexIR` is identified by its full physical name (its diff-tree `id` is the name, so same-column-tuple siblings and expression indexes are representable). Managed indexes carry a `prefix` plus a content-hash wire name; the shared naming helpers (`formatWireName`, `parseWireName`, `normalizeSqlBody`, `computeIndexContentHash`) live in `@prisma-next/sql-schema-ir/naming`.
+
 ## Usage
 
 ### Basic Usage

package/dist/exports/naming.d.mts

@@ -1,5 +1,87 @@
-//#region src/exports/naming.d.ts
+//#region src/naming.d.ts
 declare function defaultIndexName(tableName: string, columns: readonly string[]): string;
+interface WireName {
+  /** The user-supplied part before the `_<8hex>` suffix. */
+  readonly prefix: string;
+  /** The 8-lowercase-hex content-hash suffix. */
+  readonly hash: string;
+}
+/**
+ * Assembles a wire name from its user-supplied prefix and its 8-hex
+ * content-hash suffix. This module owns the `<prefix>_<hash>` format on both
+ * sides — construction here and parsing in {@link parseWireName} — so the two
+ * never drift.
+ */
+declare function formatWireName(prefix: string, hash: string): string;
+/**
+ * Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash
+ * suffix. Returns `undefined` when the name does not follow the wire-name
+ * shape (e.g. an object created outside the toolchain) — callers treat such
+ * names as all-prefix. Consumed by introspection (prefix extraction) and by
+ * rename pairing (same hash, different prefix).
+ */
+declare function parseWireName(name: string): WireName | undefined;
+/**
+ * Stabilizes an authored SQL body (index expression, partial-index predicate,
+ * RLS policy predicate) for hashing: trim, and collapse runs of internal
+ * whitespace to a single space.
+ *
+ * This is deliberately minimal. The content hash is the equivalence relation
+ * for a wire-named object, and the wire name (prefix + hash) is the only
+ * thing ever compared — the hash is never recomputed from an introspected
+ * body, so there is no need to match the database's reprinted form. Minimal
+ * normalization also protects the no-collision property: aggressive rewriting
+ * (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
+ * distinct bodies onto one hash.
+ *
+ * The normalizer is a stability commitment: any change re-suffixes all wire names.
+ */
+declare function normalizeSqlBody(sql: string): string;
+interface IndexContentHashParts {
+  readonly expression?: string;
+  readonly where?: string;
+  readonly columns?: readonly string[];
+  readonly unique: boolean;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+}
+/**
+ * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+ * canonical content tuple for an index:
+ *
+ *   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]
+ *
+ * Columns hash in authored order — column order is semantic in an index.
+ * Option values are `String()`-coerced (matching the loose option equality
+ * used for diffing) so a hash computed from typed contract values agrees with
+ * one recomputed from introspected reloptions strings. The prefix, schema,
+ * and table are excluded (they are orthogonal to index equivalence).
+ *
+ * The tuple order and encoding are a stability commitment with the same
+ * status as the RLS tuple: any change re-suffixes every wire name.
+ */
+/**
+ * Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
+ * JS booleans and the common catalog spellings (`pg_class.reloptions`
+ * stores whatever spelling the DDL used, so a live index may carry
+ * `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
+ * else via `String()` (fully specified for numbers, so no platform
+ * variance). Shared by the wire-name hash tuple, the node's option
+ * equality, and the DDL renderer, so an authored `{ fastupdate: true }`
+ * agrees with a live index created under any boolean spelling.
+ */
+declare function normalizeIndexOptionValue(value: unknown): string;
+declare function computeIndexContentHash(parts: IndexContentHashParts): string;
+/**
+ * Postgres identifiers cap at 63 characters and the wire name appends a
+ * 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.
+ */
+declare const WIRE_NAME_PREFIX_MAX_LENGTH = 54;
+/**
+ * Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.
+ * `subject` opens the error message (e.g. `defineContract: policy prefix`).
+ */
+declare function assertWireNamePrefixLength(prefix: string, subject: string): void;
 //#endregion
-export { defaultIndexName };
+export { type IndexContentHashParts, WIRE_NAME_PREFIX_MAX_LENGTH, type WireName, assertWireNamePrefixLength, computeIndexContentHash, defaultIndexName, formatWireName, normalizeIndexOptionValue, normalizeSqlBody, parseWireName };
 //# sourceMappingURL=naming.d.mts.map

package/dist/exports/naming.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"naming.d.mts","names":[],"sources":["../../src/exports/naming.ts"],"mappings":";iBAAgB,iBAAiB,mBAAmB"}
+{"version":3,"file":"naming.d.mts","names":[],"sources":["../../src/naming.ts"],"mappings":";iBAGgB,iBAAiB,mBAAmB;UAInC;;WAEN;;WAEA;;;;;;;;iBAWK,eAAe,gBAAgB;;;;;;;;iBAW/B,cAAc,eAAe;;;;;;;;;;;;;;;;iBAuB7B,iBAAiB;UAIhB;WACN;WACA;WACA;WACA;WACA;WACA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BL,0BAA0B;iBAM1B,wBAAwB,OAAO;;;;;cAoBlC;;;;;iBAMG,2BAA2B,gBAAgB"}

package/dist/exports/naming.mjs

@@ -1,8 +1,2 @@
-//#region src/exports/naming.ts
-function defaultIndexName(tableName, columns) {
-	return `${tableName}_${columns.join("_")}_idx`;
-}
-//#endregion
-export { defaultIndexName };
-
-//# sourceMappingURL=naming.mjs.map
+import { a as formatWireName, c as parseWireName, i as defaultIndexName, n as assertWireNamePrefixLength, o as normalizeIndexOptionValue, r as computeIndexContentHash, s as normalizeSqlBody, t as WIRE_NAME_PREFIX_MAX_LENGTH } from "../naming-BD7Y-Fq1.mjs";
+export { WIRE_NAME_PREFIX_MAX_LENGTH, assertWireNamePrefixLength, computeIndexContentHash, defaultIndexName, formatWireName, normalizeIndexOptionValue, normalizeSqlBody, parseWireName };

package/dist/exports/types.d.mts

@@ -1,2 +1,2 @@
-import { C as relationalNodeGranularity, D as assertNode, E as SqlSchemaIRNode, O as defineNonEnumerable, S as relationalNodeEntityKind, T as PrimaryKeyInput, _ as SqlColumnDefaultIR, a as SqlTableIR, b as SqlCheckConstraintIRInput, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as SqlColumnDefaultIRInput, w as PrimaryKey, x as RelationalSchemaNodeKind, y as SqlCheckConstraintIR } from "../types-Bnh1XTEx.mjs";
+import { C as relationalNodeGranularity, D as assertNode, E as SqlSchemaIRNode, O as defineNonEnumerable, S as relationalNodeEntityKind, T as PrimaryKeyInput, _ as SqlColumnDefaultIR, a as SqlTableIR, b as SqlCheckConstraintIRInput, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as SqlColumnDefaultIRInput, w as PrimaryKey, x as RelationalSchemaNodeKind, y as SqlCheckConstraintIR } from "../types-DzLk5eOU.mjs";
 export { PrimaryKey, type PrimaryKeyInput, RelationalSchemaNodeKind, type SqlAnnotations, SqlCheckConstraintIR, type SqlCheckConstraintIRInput, SqlColumnDefaultIR, type SqlColumnDefaultIRInput, SqlColumnIR, type SqlColumnIRInput, SqlForeignKeyIR, type SqlForeignKeyIRInput, SqlIndexIR, type SqlIndexIRInput, type SqlReferentialAction, SqlSchemaIR, type SqlSchemaIRInput, SqlSchemaIRNode, SqlTableIR, type SqlTableIRInput, type SqlTypeMetadata, type SqlTypeMetadataRegistry, SqlUniqueIR, type SqlUniqueIRInput, assertNode, defineNonEnumerable, relationalNodeEntityKind, relationalNodeGranularity };

package/dist/exports/types.mjs

@@ -1,2 +1,2 @@
-import { a as SqlForeignKeyIR, c as SqlCheckConstraintIR, d as assertNode, f as defineNonEnumerable, h as relationalNodeGranularity, i as SqlIndexIR, l as PrimaryKey, m as relationalNodeEntityKind, n as SqlTableIR, o as SqlColumnIR, p as RelationalSchemaNodeKind, r as SqlUniqueIR, s as SqlColumnDefaultIR, t as SqlSchemaIR, u as SqlSchemaIRNode } from "../types-pxgoVAJq.mjs";
+import { a as SqlForeignKeyIR, c as SqlCheckConstraintIR, d as assertNode, f as defineNonEnumerable, h as relationalNodeGranularity, i as SqlIndexIR, l as PrimaryKey, m as relationalNodeEntityKind, n as SqlTableIR, o as SqlColumnIR, p as RelationalSchemaNodeKind, r as SqlUniqueIR, s as SqlColumnDefaultIR, t as SqlSchemaIR, u as SqlSchemaIRNode } from "../types-Btj35AIt.mjs";
 export { PrimaryKey, RelationalSchemaNodeKind, SqlCheckConstraintIR, SqlColumnDefaultIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlTableIR, SqlUniqueIR, assertNode, defineNonEnumerable, relationalNodeEntityKind, relationalNodeGranularity };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { C as relationalNodeGranularity, D as assertNode, E as SqlSchemaIRNode, O as defineNonEnumerable, S as relationalNodeEntityKind, T as PrimaryKeyInput, _ as SqlColumnDefaultIR, a as SqlTableIR, b as SqlCheckConstraintIRInput, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as SqlColumnDefaultIRInput, w as PrimaryKey, x as RelationalSchemaNodeKind, y as SqlCheckConstraintIR } from "./types-Bnh1XTEx.mjs";
+import { C as relationalNodeGranularity, D as assertNode, E as SqlSchemaIRNode, O as defineNonEnumerable, S as relationalNodeEntityKind, T as PrimaryKeyInput, _ as SqlColumnDefaultIR, a as SqlTableIR, b as SqlCheckConstraintIRInput, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as SqlColumnDefaultIRInput, w as PrimaryKey, x as RelationalSchemaNodeKind, y as SqlCheckConstraintIR } from "./types-DzLk5eOU.mjs";
 export { PrimaryKey, type PrimaryKeyInput, RelationalSchemaNodeKind, type SqlAnnotations, SqlCheckConstraintIR, type SqlCheckConstraintIRInput, SqlColumnDefaultIR, type SqlColumnDefaultIRInput, SqlColumnIR, type SqlColumnIRInput, SqlForeignKeyIR, type SqlForeignKeyIRInput, SqlIndexIR, type SqlIndexIRInput, type SqlReferentialAction, SqlSchemaIR, type SqlSchemaIRInput, SqlSchemaIRNode, SqlTableIR, type SqlTableIRInput, type SqlTypeMetadata, type SqlTypeMetadataRegistry, SqlUniqueIR, type SqlUniqueIRInput, assertNode, defineNonEnumerable, relationalNodeEntityKind, relationalNodeGranularity };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { a as SqlForeignKeyIR, c as SqlCheckConstraintIR, d as assertNode, f as defineNonEnumerable, h as relationalNodeGranularity, i as SqlIndexIR, l as PrimaryKey, m as relationalNodeEntityKind, n as SqlTableIR, o as SqlColumnIR, p as RelationalSchemaNodeKind, r as SqlUniqueIR, s as SqlColumnDefaultIR, t as SqlSchemaIR, u as SqlSchemaIRNode } from "./types-pxgoVAJq.mjs";
+import { a as SqlForeignKeyIR, c as SqlCheckConstraintIR, d as assertNode, f as defineNonEnumerable, h as relationalNodeGranularity, i as SqlIndexIR, l as PrimaryKey, m as relationalNodeEntityKind, n as SqlTableIR, o as SqlColumnIR, p as RelationalSchemaNodeKind, r as SqlUniqueIR, s as SqlColumnDefaultIR, t as SqlSchemaIR, u as SqlSchemaIRNode } from "./types-Btj35AIt.mjs";
 export { PrimaryKey, RelationalSchemaNodeKind, SqlCheckConstraintIR, SqlColumnDefaultIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlTableIR, SqlUniqueIR, assertNode, defineNonEnumerable, relationalNodeEntityKind, relationalNodeGranularity };

package/dist/naming-BD7Y-Fq1.mjs

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+import { structuredError } from "@prisma-next/utils/structured-error";
+//#region src/naming.ts
+function defaultIndexName(tableName, columns) {
+	return `${tableName}_${columns.join("_")}_idx`;
+}
+const WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;
+/**
+* Assembles a wire name from its user-supplied prefix and its 8-hex
+* content-hash suffix. This module owns the `<prefix>_<hash>` format on both
+* sides — construction here and parsing in {@link parseWireName} — so the two
+* never drift.
+*/
+function formatWireName(prefix, hash) {
+	return `${prefix}_${hash}`;
+}
+/**
+* Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash
+* suffix. Returns `undefined` when the name does not follow the wire-name
+* shape (e.g. an object created outside the toolchain) — callers treat such
+* names as all-prefix. Consumed by introspection (prefix extraction) and by
+* rename pairing (same hash, different prefix).
+*/
+function parseWireName(name) {
+	const match = WIRE_NAME_PATTERN.exec(name);
+	const prefix = match?.[1];
+	const hash = match?.[2];
+	if (prefix === void 0 || hash === void 0) return void 0;
+	return {
+		prefix,
+		hash
+	};
+}
+/**
+* Stabilizes an authored SQL body (index expression, partial-index predicate,
+* RLS policy predicate) for hashing: trim, and collapse runs of internal
+* whitespace to a single space.
+*
+* This is deliberately minimal. The content hash is the equivalence relation
+* for a wire-named object, and the wire name (prefix + hash) is the only
+* thing ever compared — the hash is never recomputed from an introspected
+* body, so there is no need to match the database's reprinted form. Minimal
+* normalization also protects the no-collision property: aggressive rewriting
+* (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
+* distinct bodies onto one hash.
+*
+* The normalizer is a stability commitment: any change re-suffixes all wire names.
+*/
+function normalizeSqlBody(sql) {
+	return sql.replace(/\s+/g, " ").trim();
+}
+/**
+* Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+* canonical content tuple for an index:
+*
+*   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]
+*
+* Columns hash in authored order — column order is semantic in an index.
+* Option values are `String()`-coerced (matching the loose option equality
+* used for diffing) so a hash computed from typed contract values agrees with
+* one recomputed from introspected reloptions strings. The prefix, schema,
+* and table are excluded (they are orthogonal to index equivalence).
+*
+* The tuple order and encoding are a stability commitment with the same
+* status as the RLS tuple: any change re-suffixes every wire name.
+*/
+/**
+* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
+* JS booleans and the common catalog spellings (`pg_class.reloptions`
+* stores whatever spelling the DDL used, so a live index may carry
+* `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
+* else via `String()` (fully specified for numbers, so no platform
+* variance). Shared by the wire-name hash tuple, the node's option
+* equality, and the DDL renderer, so an authored `{ fastupdate: true }`
+* agrees with a live index created under any boolean spelling.
+*/
+function normalizeIndexOptionValue(value) {
+	if (value === true || value === "true" || value === "on") return "on";
+	if (value === false || value === "false" || value === "off") return "off";
+	return String(value);
+}
+function computeIndexContentHash(parts) {
+	const sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	const tuple = JSON.stringify([
+		normalizeSqlBody(parts.expression ?? ""),
+		normalizeSqlBody(parts.where ?? ""),
+		parts.columns ?? [],
+		parts.unique,
+		parts.type ?? "",
+		sortedOptions
+	]);
+	return createHash("sha256").update(tuple).digest("hex").slice(0, 8);
+}
+/**
+* Postgres identifiers cap at 63 characters and the wire name appends a
+* 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.
+*/
+const WIRE_NAME_PREFIX_MAX_LENGTH = 54;
+/**
+* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.
+* `subject` opens the error message (e.g. `defineContract: policy prefix`).
+*/
+function assertWireNamePrefixLength(prefix, subject) {
+	if (prefix.length > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`, { meta: {
+		prefix,
+		maxLength: 54
+	} });
+}
+//#endregion
+export { formatWireName as a, parseWireName as c, defaultIndexName as i, assertWireNamePrefixLength as n, normalizeIndexOptionValue as o, computeIndexContentHash as r, normalizeSqlBody as s, WIRE_NAME_PREFIX_MAX_LENGTH as t };
+
+//# sourceMappingURL=naming-BD7Y-Fq1.mjs.map

package/dist/naming-BD7Y-Fq1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-BD7Y-Fq1.mjs","names":[],"sources":["../src/naming.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\nimport { structuredError } from '@prisma-next/utils/structured-error';\n\nexport function defaultIndexName(tableName: string, columns: readonly string[]): string {\n  return `${tableName}_${columns.join('_')}_idx`;\n}\n\nexport interface WireName {\n  /** The user-supplied part before the `_<8hex>` suffix. */\n  readonly prefix: string;\n  /** The 8-lowercase-hex content-hash suffix. */\n  readonly hash: string;\n}\n\nconst WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;\n\n/**\n * Assembles a wire name from its user-supplied prefix and its 8-hex\n * content-hash suffix. This module owns the `<prefix>_<hash>` format on both\n * sides — construction here and parsing in {@link parseWireName} — so the two\n * never drift.\n */\nexport function formatWireName(prefix: string, hash: string): string {\n  return `${prefix}_${hash}`;\n}\n\n/**\n * Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash\n * suffix. Returns `undefined` when the name does not follow the wire-name\n * shape (e.g. an object created outside the toolchain) — callers treat such\n * names as all-prefix. Consumed by introspection (prefix extraction) and by\n * rename pairing (same hash, different prefix).\n */\nexport function parseWireName(name: string): WireName | undefined {\n  const match = WIRE_NAME_PATTERN.exec(name);\n  const prefix = match?.[1];\n  const hash = match?.[2];\n  if (prefix === undefined || hash === undefined) return undefined;\n  return { prefix, hash };\n}\n\n/**\n * Stabilizes an authored SQL body (index expression, partial-index predicate,\n * RLS policy predicate) for hashing: trim, and collapse runs of internal\n * whitespace to a single space.\n *\n * This is deliberately minimal. The content hash is the equivalence relation\n * for a wire-named object, and the wire name (prefix + hash) is the only\n * thing ever compared — the hash is never recomputed from an introspected\n * body, so there is no need to match the database's reprinted form. Minimal\n * normalization also protects the no-collision property: aggressive rewriting\n * (lowercasing, paren-stripping, cast-alias folding) risks collapsing two\n * distinct bodies onto one hash.\n *\n * The normalizer is a stability commitment: any change re-suffixes all wire names.\n */\nexport function normalizeSqlBody(sql: string): string {\n  return sql.replace(/\\s+/g, ' ').trim();\n}\n\nexport interface IndexContentHashParts {\n  readonly expression?: string;\n  readonly where?: string;\n  readonly columns?: readonly string[];\n  readonly unique: boolean;\n  readonly type?: string;\n  readonly options?: Record<string, unknown>;\n}\n\n/**\n * Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n * canonical content tuple for an index:\n *\n *   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]\n *\n * Columns hash in authored order — column order is semantic in an index.\n * Option values are `String()`-coerced (matching the loose option equality\n * used for diffing) so a hash computed from typed contract values agrees with\n * one recomputed from introspected reloptions strings. The prefix, schema,\n * and table are excluded (they are orthogonal to index equivalence).\n *\n * The tuple order and encoding are a stability commitment with the same\n * status as the RLS tuple: any change re-suffixes every wire name.\n */\n/**\n * Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:\n * JS booleans and the common catalog spellings (`pg_class.reloptions`\n * stores whatever spelling the DDL used, so a live index may carry\n * `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything\n * else via `String()` (fully specified for numbers, so no platform\n * variance). Shared by the wire-name hash tuple, the node's option\n * equality, and the DDL renderer, so an authored `{ fastupdate: true }`\n * agrees with a live index created under any boolean spelling.\n */\nexport function normalizeIndexOptionValue(value: unknown): string {\n  if (value === true || value === 'true' || value === 'on') return 'on';\n  if (value === false || value === 'false' || value === 'off') return 'off';\n  return String(value);\n}\n\nexport function computeIndexContentHash(parts: IndexContentHashParts): string {\n  const sortedOptions = Object.entries(parts.options ?? {})\n    .map(([key, value]): readonly [string, string] => [key, normalizeIndexOptionValue(value)])\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n\n  const tuple = JSON.stringify([\n    normalizeSqlBody(parts.expression ?? ''),\n    normalizeSqlBody(parts.where ?? ''),\n    parts.columns ?? [],\n    parts.unique,\n    parts.type ?? '',\n    sortedOptions,\n  ]);\n  return createHash('sha256').update(tuple).digest('hex').slice(0, 8);\n}\n\n/**\n * Postgres identifiers cap at 63 characters and the wire name appends a\n * 9-character `_<8hex>` suffix, so an authored prefix is bounded at 54.\n */\nexport const WIRE_NAME_PREFIX_MAX_LENGTH = 54;\n\n/**\n * Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.\n * `subject` opens the error message (e.g. `defineContract: policy prefix`).\n */\nexport function assertWireNamePrefixLength(prefix: string, subject: string): void {\n  if (prefix.length > WIRE_NAME_PREFIX_MAX_LENGTH) {\n    throw structuredError(\n      'CONTRACT.WIRE_NAME_PREFIX_TOO_LONG',\n      `${subject} \"${prefix}\" exceeds the ${WIRE_NAME_PREFIX_MAX_LENGTH}-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`,\n      { meta: { prefix, maxLength: WIRE_NAME_PREFIX_MAX_LENGTH } },\n    );\n  }\n}\n"],"mappings":";;;AAGA,SAAgB,iBAAiB,WAAmB,SAAoC;CACtF,OAAO,GAAG,UAAU,GAAG,QAAQ,KAAK,GAAG,EAAE;AAC3C;AASA,MAAM,oBAAoB;;;;;;;AAQ1B,SAAgB,eAAe,QAAgB,MAAsB;CACnE,OAAO,GAAG,OAAO,GAAG;AACtB;;;;;;;;AASA,SAAgB,cAAc,MAAoC;CAChE,MAAM,QAAQ,kBAAkB,KAAK,IAAI;CACzC,MAAM,SAAS,QAAQ;CACvB,MAAM,OAAO,QAAQ;CACrB,IAAI,WAAW,KAAA,KAAa,SAAS,KAAA,GAAW,OAAO,KAAA;CACvD,OAAO;EAAE;EAAQ;CAAK;AACxB;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBAAiB,KAAqB;CACpD,OAAO,IAAI,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,0BAA0B,OAAwB;CAChE,IAAI,UAAU,QAAQ,UAAU,UAAU,UAAU,MAAM,OAAO;CACjE,IAAI,UAAU,SAAS,UAAU,WAAW,UAAU,OAAO,OAAO;CACpE,OAAO,OAAO,KAAK;AACrB;AAEA,SAAgB,wBAAwB,OAAsC;CAC5E,MAAM,gBAAgB,OAAO,QAAQ,MAAM,WAAW,CAAC,CAAC,CAAC,CACtD,KAAK,CAAC,KAAK,WAAsC,CAAC,KAAK,0BAA0B,KAAK,CAAC,CAAC,CAAC,CACzF,MAAM,CAAC,IAAI,CAAC,OAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAE;CAElD,MAAM,QAAQ,KAAK,UAAU;EAC3B,iBAAiB,MAAM,cAAc,EAAE;EACvC,iBAAiB,MAAM,SAAS,EAAE;EAClC,MAAM,WAAW,CAAC;EAClB,MAAM;EACN,MAAM,QAAQ;EACd;CACF,CAAC;CACD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACpE;;;;;AAMA,MAAa,8BAA8B;;;;;AAM3C,SAAgB,2BAA2B,QAAgB,SAAuB;CAChF,IAAI,OAAO,SAAA,IACT,MAAM,gBACJ,sCACA,GAAG,QAAQ,IAAI,OAAO,sIACtB,EAAE,MAAM;EAAE;EAAQ,WAAA;CAAuC,EAAE,CAC7D;AAEJ"}

package/dist/{types-pxgoVAJq.mjs → types-Btj35AIt.mjs}

@@ -1,7 +1,10 @@
+import { o as normalizeIndexOptionValue } from "./naming-BD7Y-Fq1.mjs";
 import { IRNodeBase, freezeNode } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
 import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { isArrayEqual } from "@prisma-next/utils/array-equal";
+import { InternalError } from "@prisma-next/utils/internal-error";
 //#region src/ir/schema-node-kinds.ts
 /**
 * The `nodeKind` discriminant for each relational schema-diff leaf node.
@@ -472,41 +475,49 @@ function referentialActionMatches(expected, actual) {
 * verifier needs to distinguish them when comparing to the Contract.
 *
 * Implements `DiffableNode` so an index is directly a table's diff-tree
-* child. Indexes are frequently unnamed, so `id` is derived from the column
-* tuple — the same tuple that makes two indexes the same index, so it
-* doubles as the pairing key. `isEqualTo` is symmetric structural equality
-* on the remaining attributes: `unique`, `type`, and `options`. A unique
-* index and a non-unique index on the same columns are different objects
-* and are not equal — there is no "stronger satisfies weaker".
+* child. Indexes are name-identified: every index — contract-derived or
+* introspected — carries its full physical name, and `id` is that name.
+* Names are catalog-unique per schema, so two indexes legitimately sharing
+* one column tuple (a unique index beside a redundant plain index) are two
+* distinct siblings, and expression indexes need no column tuple at all.
 *
-* Deliberately column-tuple-only (not `unique`): a contract `@@index`
-* (non-unique) must still pair against a live unique index of the same
-* columns so the differ can report the mismatch as an incompatible index
-* change rather than a spurious missing+extra pair — see
-* `planner.unique-index-structural.test.ts`. The corollary is that two
-* indexes legitimately coexisting on one table with the *same* column tuple
-* (e.g. a unique index and a redundant plain index Postgres has no problem
-* hosting side by side) collide on this id; the postgres control adapter's
-* introspection keeps only one such index per table+column-tuple rather
-* than handing the differ two same-tree siblings it cannot represent.
+* `isEqualTo` is selected by the receiver (the differ always calls
+* `expected.isEqualTo(actual)`) and delegates to {@link contentEquals} —
+* the single node-owned content relation: both modes compare `unique`
+* strict, `type` and option values through the named normalization seams,
+* and `columns` ordered-strict when both sides carry them; an exact-named
+* receiver (`prefix === undefined`) additionally byte-compares
+* `expression`/`where` (both sides are reprints in the supported flow —
+* normalizing would only mask real drift); a managed receiver never
+* compares bodies (the wire-name hash already commits to them).
+*
+* `expression`, `where`, and `unique` are genuine SQL-family attributes —
+* functional and partial indexes are standard SQL that any SQL target may
+* introspect, so the family node must represent them; a target declining
+* to author them is a capability decision, not target-specificity.
 */
 var SqlIndexIR = class SqlIndexIR extends SqlSchemaIRNode {
 	nodeKind = RelationalSchemaNodeKind.index;
-	columns;
+	name;
 	unique;
 	constructor(input) {
 		super();
-		this.columns = input.columns;
+		if (input.columns === void 0 === (input.expression === void 0)) throw new InternalError(`SqlIndexIR "${input.name}": exactly one of columns or expression must be set.`);
+		this.name = input.name;
 		this.unique = input.unique;
-		if (input.name !== void 0) this.name = input.name;
+		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;
 		if (input.annotations !== void 0) this.annotations = input.annotations;
 		defineNonEnumerable(this, "dependsOn", input.dependsOn);
+		defineNonEnumerable(this, "partial", input.partial);
 		freezeNode(this);
 	}
 	get id() {
-		return `index:${this.columns.join(",")}`;
+		return `index:${this.name}`;
 	}
 	children() {
 		return [];
@@ -515,32 +526,72 @@ var SqlIndexIR = class SqlIndexIR extends SqlSchemaIRNode {
 		return node.nodeKind === RelationalSchemaNodeKind.index;
 	}
 	/**
-	* Symmetric structural equality: two paired index nodes are equal iff their
-	* `unique` flag, `type`, and (loosely-compared) `options` all match. There
-	* is no satisfaction — a unique index does not equal a non-unique index.
-	* `options` compares loosely (introspection stringifies reloptions); `type`
-	* compares strictly after the introspection-side btree→undefined
-	* normalization done at construction.
+	* Mode-selected structural equality — see the class doc. Delegates to the
+	* single node-owned relation: `columns` compare ordered-strict when both
+	* sides carry them; an exact receiver (`prefix === undefined`)
+	* byte-compares `expression ?? ''` and `where ?? ''`; a managed receiver
+	* never compares bodies (the wire-name hash already commits to them).
 	*/
 	isEqualTo(other) {
 		const node = blindCast(other);
 		assertNode(node, "SqlIndexIR", SqlIndexIR.is);
-		return this.unique === node.unique && this.type === node.type && indexOptionsLooselyEqual(this.options, node.options);
+		return this.contentEquals(node, {
+			columnPresence: "when-both-defined",
+			bodies: this.prefix !== void 0 ? "ignored" : "verbatim"
+		});
+	}
+	/**
+	* The single index content-equality relation — every comparer (the differ
+	* via {@link isEqualTo}, the planner's rename content-pairing) calls this
+	* with its mode-appropriate strictness rather than growing a parallel
+	* relation:
+	*
+	* - `columnPresence: 'when-both-defined'` (the differ's rule) compares
+	*   the tuples ordered-strict only when both sides carry them — a paired
+	*   node's identity already agreed, so a column node meeting an
+	*   expression node skips the tuple.
+	* - `columnPresence: 'matching'` (the rename-pairing rule) additionally
+	*   requires presence to agree: a column index never pairs an expression
+	*   index.
+	* - `bodies: 'verbatim'` byte-compares `expression ?? ''` / `where ?? ''`
+	*   (absent ≡ empty, no normalization — both sides are reprints in the
+	*   supported flow); `bodies: 'ignored'` skips them (managed identity —
+	*   the wire-name hash commits to the content).
+	*
+	* `unique` compares strictly; `type` and option VALUES compare through
+	* the named normalization seams below.
+	*/
+	contentEquals(other, strictness) {
+		const columnsEqual = strictness.columnPresence === "matching" ? this.columns === void 0 === (other.columns === void 0) && (this.columns === void 0 || isArrayEqual(this.columns, other.columns ?? [])) : this.columns === void 0 || other.columns === void 0 || isArrayEqual(this.columns, other.columns);
+		if (!(this.unique === other.unique && normalizeIndexType(this.type) === normalizeIndexType(other.type) && indexOptionsEqual(this.options, other.options) && columnsEqual)) return false;
+		if (strictness.bodies === "ignored") return true;
+		return (this.expression ?? "") === (other.expression ?? "") && (this.where ?? "") === (other.where ?? "");
 	}
 };
 /**
-* Option-bag equality ported from the relational walk: same key set, values
-* compared via `String()` coercion — Postgres introspection returns
-* reloptions values as raw strings (`'70'`, `'false'`) while contract option
-* leaves are typed (number, boolean, string).
+* Comparison-side normalization seam: the default access method (`btree` in
+* every supported SQL target) compares as absent, so an authored
+* `type: "btree"` and a default-method introspected index (whose type the
+* adapter or constructor normalized away) are equal. Applied by
+* {@link SqlIndexIR.contentEquals} only — the wire-name hash keeps the
+* authored spelling.
+*/
+function normalizeIndexType(type) {
+	return type === "btree" ? void 0 : type;
+}
+/**
+* Option-bag equality: same key set, values compared through
+* {@link normalizeIndexOptionValue} — Postgres introspection returns
+* reloptions values as catalog-reprint strings (`'70'`, `'on'`) while
+* contract option leaves are typed (number, boolean, string).
 */
-function indexOptionsLooselyEqual(a, b) {
+function indexOptionsEqual(a, b) {
 	const aKeys = a ? Object.keys(a).sort() : [];
 	const bKeys = b ? Object.keys(b).sort() : [];
 	if (aKeys.length !== bKeys.length) return false;
 	for (let i = 0; i < aKeys.length; i += 1) if (aKeys[i] !== bKeys[i]) return false;
 	if (aKeys.length === 0) return true;
-	for (const key of aKeys) if (String(a?.[key]) !== String(b?.[key])) return false;
+	for (const key of aKeys) if (normalizeIndexOptionValue(a?.[key]) !== normalizeIndexOptionValue(b?.[key])) return false;
 	return true;
 }
 //#endregion
@@ -680,4 +731,4 @@ var SqlSchemaIR = class extends SqlSchemaIRNode {
 //#endregion
 export { SqlForeignKeyIR as a, SqlCheckConstraintIR as c, assertNode as d, defineNonEnumerable as f, relationalNodeGranularity as h, SqlIndexIR as i, PrimaryKey as l, relationalNodeEntityKind as m, SqlTableIR as n, SqlColumnIR as o, RelationalSchemaNodeKind as p, SqlUniqueIR as r, SqlColumnDefaultIR as s, SqlSchemaIR as t, SqlSchemaIRNode as u };
 
-//# sourceMappingURL=types-pxgoVAJq.mjs.map
+//# sourceMappingURL=types-Btj35AIt.mjs.map