@vibeorm/schema 5.8.0 → 5.10.0

package/dist/index.js

@@ -222,9 +222,12 @@ var RESERVED_DELEGATE_NAMES = [
   "delete",
   "deleteMany",
   "count",
+  "exists",
   "aggregate",
   "groupBy",
-  "fields"
+  "fields",
+  "uniques",
+  "exclusions"
 ];
 var RESERVED_CLIENT_NAMES = [
   "$connect",
@@ -254,7 +257,8 @@ var RESERVED_CLIENT_NAMES = [
   "$withContext",
   "$advisoryLock",
   "$advisoryLocks",
-  "$tryAdvisoryLock"
+  "$tryAdvisoryLock",
+  "$sql"
 ];
 var RESERVED_COLUMN_PREFIX = "__vibe_";
 function isReservedDelegateName(params) {
@@ -442,6 +446,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   fixedNamespaces: true,
   externalObjects: true,
   indexOperatorClasses: true,
+  indexIncludeColumns: true,
+  tableStorageParameters: true,
   exclusionConstraints: true,
   exclusionExtensions: Object.freeze(["btree_gist"]),
   checkNormalization: "rollback",
@@ -474,7 +480,11 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   uuidColumns: "native",
   localDateColumns: true,
   dateTruncation: true,
-  rowCapture: true
+  filteredAggregates: "filterClause",
+  groupingSets: "groupingSets",
+  rowCapture: true,
+  returningReadsJoinedSource: true,
+  upsertSkipUnchanged: true
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -484,6 +494,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
   externalObjects: false,
   indexOperatorClasses: false,
+  indexIncludeColumns: false,
+  tableStorageParameters: false,
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "sourceText",
@@ -516,7 +528,11 @@ var SQLITE_CAPABILITIES = Object.freeze({
   uuidColumns: "text",
   localDateColumns: true,
   dateTruncation: false,
-  rowCapture: false
+  filteredAggregates: "filterClause",
+  groupingSets: "none",
+  rowCapture: false,
+  returningReadsJoinedSource: false,
+  upsertSkipUnchanged: true
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -526,6 +542,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
   externalObjects: false,
   indexOperatorClasses: false,
+  indexIncludeColumns: false,
+  tableStorageParameters: false,
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "temporary",
@@ -558,7 +576,11 @@ var MYSQL_CAPABILITIES = Object.freeze({
   uuidColumns: "unsupported",
   localDateColumns: true,
   dateTruncation: false,
-  rowCapture: false
+  filteredAggregates: "caseWhen",
+  groupingSets: "rollup",
+  rowCapture: false,
+  returningReadsJoinedSource: false,
+  upsertSkipUnchanged: true
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -1070,10 +1092,12 @@ function shapeIssue(params) {
   const { index } = params;
   if (!dataOnly({ value: index }))
     return "Expression indexes accept JSON-safe plain data only, not accessors, callbacks or cycles";
-  if (!record({ value: index, required: ["kind", "fields", "expressions"], optional: ["name", "clientName", "constraintName", "where", "wherePredicate", "nullsNotDistinct"] }))
+  if (!record({ value: index, required: ["kind", "fields", "expressions"], optional: ["name", "clientName", "constraintName", "where", "wherePredicate", "nullsNotDistinct", "include"] }))
     return "Expression indexes require canonical index data properties";
   if (typeof index.kind !== "string")
     return "Index kind must be a string";
+  if (index.include !== undefined && (!Array.isArray(index.include) || index.include.some((name) => !text({ value: name }))))
+    return "Expression index INCLUDE columns must be a list of field names";
   if (index.nullsNotDistinct !== undefined && typeof index.nullsNotDistinct !== "boolean" || index.name !== undefined && !text({ value: index.name }) || index.where !== undefined && !text({ value: index.where }))
     return "Expression index names, predicates and flags must have their canonical data types";
   const descriptor = Object.getOwnPropertyDescriptor(index, "expressions");
@@ -1139,14 +1163,15 @@ function structuralData(params) {
 }
 function indexKeyDefinitionKey(params) {
   const { index, model } = params;
+  const include = index.include === undefined ? [] : [{ include: index.include.map((name) => model?.fields.find((entry) => entry.name === name)?.dbName ?? name) }];
   if (!isExpressionIndex({ index })) {
     const columns = index.fields.map((field) => [model?.fields.find((entry) => entry.name === field.name)?.dbName ?? field.name, field.sort === "desc", field.operatorClass === undefined ? null : [field.operatorClass.namespace, field.operatorClass.name]]);
-    return JSON.stringify([index.kind === "unique", index.nullsNotDistinct === true, index.kind === "unique" ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
+    return JSON.stringify([index.kind === "unique", index.nullsNotDistinct === true, index.kind === "unique" ? "btree" : index.kind, columns, index.where?.trim() ?? "", ...include]);
   }
   const issue = shapeIssue({ index });
   if (issue !== undefined)
     throw invalid({ message: issue });
-  return JSON.stringify(["expression", index.kind, structuralData({ value: index.expressions, model }), index.nullsNotDistinct === true, index.where?.trim() ?? "", structuralData({ value: index.wherePredicate, model }) ?? null]);
+  return JSON.stringify(["expression", index.kind, structuralData({ value: index.expressions, model }), index.nullsNotDistinct === true, index.where?.trim() ?? "", structuralData({ value: index.wherePredicate, model }) ?? null, ...include]);
 }
 function scalarType(params) {
   const { expression, model, dialect, add } = params;
@@ -1548,12 +1573,81 @@ function assertSqlNamespace(params) {
 function qualifiedSqlName(params) {
   return { namespace: params.namespace ?? params.defaultNamespace ?? SQL_NAMESPACES.postgres, name: params.name };
 }
+// packages/schema/src/sealed.ts
+var sealed = new WeakSet;
+var valid = new WeakSet;
+var admitted = new WeakMap;
+function sealSchemaIR(params) {
+  if (sealed.has(params.schema))
+    return params.schema;
+  const copy = frozenPlainCopy({ value: params.schema });
+  if (copy === undefined)
+    return params.schema;
+  sealed.add(copy);
+  return copy;
+}
+function isKnownValidSchemaIR(params) {
+  return valid.has(params.schema);
+}
+function rememberValidSchemaIR(params) {
+  if (sealed.has(params.schema))
+    valid.add(params.schema);
+}
+function isKnownAdmittedSchemaIR(params) {
+  return admitted.get(params.schema)?.includes(params.dialect) === true;
+}
+function rememberAdmittedSchemaIR(params) {
+  if (!sealed.has(params.schema))
+    return;
+  const dialects = admitted.get(params.schema);
+  if (dialects === undefined)
+    admitted.set(params.schema, [params.dialect]);
+  else if (!dialects.includes(params.dialect))
+    dialects.push(params.dialect);
+}
+function frozenPlainCopy(params) {
+  const { value } = params;
+  if (typeof value === "function" || typeof value === "symbol")
+    return;
+  if (typeof value !== "object" || value === null)
+    return value;
+  if (Array.isArray(value)) {
+    if (Object.getPrototypeOf(value) !== Array.prototype)
+      return;
+    const out = [];
+    for (let index = 0;index < value.length; index++) {
+      const member = value[index];
+      const item = frozenPlainCopy({ value: member });
+      if (item === undefined && member !== undefined)
+        return;
+      out.push(item);
+    }
+    return Object.freeze(out);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    return;
+  if (Object.getOwnPropertySymbols(value).length > 0)
+    return;
+  const out = prototype === null ? Object.create(null) : {};
+  for (const key of Object.keys(value)) {
+    const member = value[key];
+    const item = frozenPlainCopy({ value: member });
+    if (item === undefined && member !== undefined)
+      return;
+    Object.defineProperty(out, key, { value: item, enumerable: true, writable: true, configurable: true });
+  }
+  return Object.freeze(out);
+}
+
 // packages/schema/src/native-rls-admission.ts
 function assertNativeRlsAdmission(params) {
   const { schema } = params;
   if (schema.rls === undefined && !schema.models.some((model) => model.rls !== undefined))
     return;
   const dialect = params.dialect ?? providerToDialect({ provider: schema.datasource.provider });
+  if (isKnownAdmittedSchemaIR({ schema, dialect }))
+    return;
   if (!DIALECT_CAPABILITIES[dialect].nativeRowLevelSecurity) {
     throw unsupportedCapability({ dialect, feature: "nativeRowLevelSecurity" });
   }
@@ -1571,6 +1665,7 @@ function assertNativeRlsAdmission(params) {
       });
     }
   }
+  rememberAdmittedSchemaIR({ schema, dialect });
 }
 // packages/schema/src/model-sql-namespace.ts
 function modelSqlNamespace(params) {
@@ -2335,6 +2430,172 @@ function assertIndexOperatorClasses(params) {
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.name, field: field.name } });
       }
 }
+// packages/schema/src/index-include.ts
+var INCLUDE_INDEX_KINDS = Object.freeze(["btree", "unique", "gist", "spgist"]);
+function hasIndexIncludeColumns(params) {
+  return params.schema.models.some((model) => model.indexes.some((index) => index.include !== undefined));
+}
+function assertIndexIncludeColumns(params) {
+  const { schema, dialect } = params;
+  for (const model of schema.models)
+    for (const index of model.indexes) {
+      const include = index.include;
+      if (include === undefined)
+        continue;
+      const site = `${index.kind === "unique" ? "@@unique" : "@@index"}${index.name === undefined ? "" : ` "${index.name}"`} on "${model.name}"`;
+      const invalid = (params) => new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `${site}: ${params.message}`, meta: { rule: params.rule, model: model.name, ...index.name === undefined ? {} : { index: index.name }, ...params.field === undefined ? {} : { field: params.field } } });
+      if (!Array.isArray(include) || include.length === 0 || include.some((name) => typeof name !== "string" || name === ""))
+        throw invalid({ rule: "index-include-shape", message: "include must be a non-empty list of field names (omit it for an index without INCLUDE columns)" });
+      if (!DIALECT_CAPABILITIES[dialect].indexIncludeColumns)
+        throw unsupportedCapability({ dialect, feature: "indexIncludeColumns", hint: `${site} declares INCLUDE columns; covering indexes are PostgreSQL only` });
+      if (!INCLUDE_INDEX_KINDS.includes(index.kind))
+        throw unsupportedCapability({ dialect, feature: `INCLUDE columns on a ${index.kind} index`, hint: `${site}: PostgreSQL stores INCLUDE columns in btree, unique, GiST and SP-GiST indexes only` });
+      const keys = keyColumns({ index });
+      const seen = new Set;
+      for (const name of include) {
+        if (!model.fields.some((field) => field.name === name))
+          throw invalid({ rule: "index-include-field", message: `include names "${name}", which is not a scalar field of the model`, field: name });
+        if (seen.has(name))
+          throw invalid({ rule: "index-include-duplicate", message: `include lists "${name}" twice`, field: name });
+        if (keys.has(name))
+          throw invalid({ rule: "index-include-key-column", message: `"${name}" is already a key column of the index; PostgreSQL refuses a column that is both key and included`, field: name });
+        seen.add(name);
+      }
+    }
+}
+function keyColumns(params) {
+  return new Set(indexKeyTerms({ index: params.index }).flatMap((term) => term.kind === "field" ? [term.field.name] : []));
+}
+// packages/schema/src/table-storage.ts
+var INT_MAX = 2147483647;
+var HEAP_ONLY = {
+  fillfactor: { type: "integer", min: 10, max: 100 },
+  toast_tuple_target: { type: "integer", min: 128, max: 8160 },
+  parallel_workers: { type: "integer", min: 0, max: 1024 },
+  autovacuum_analyze_threshold: { type: "integer", min: 0, max: INT_MAX },
+  autovacuum_analyze_scale_factor: { type: "real", min: 0, max: 100 }
+};
+var VACUUM = {
+  autovacuum_enabled: { type: "boolean" },
+  vacuum_index_cleanup: { type: "enum", values: ["auto", "on", "off"] },
+  vacuum_truncate: { type: "boolean" },
+  autovacuum_vacuum_threshold: { type: "integer", min: 0, max: INT_MAX },
+  autovacuum_vacuum_scale_factor: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_insert_threshold: { type: "integer", min: -1, max: INT_MAX },
+  autovacuum_vacuum_insert_scale_factor: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_cost_delay: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_cost_limit: { type: "integer", min: 1, max: 1e4 },
+  autovacuum_freeze_min_age: { type: "integer", min: 0, max: 1e9 },
+  autovacuum_freeze_max_age: { type: "integer", min: 1e5, max: 2000000000 },
+  autovacuum_freeze_table_age: { type: "integer", min: 0, max: 2000000000 },
+  autovacuum_multixact_freeze_min_age: { type: "integer", min: 0, max: 1e9 },
+  autovacuum_multixact_freeze_max_age: { type: "integer", min: 1e4, max: 2000000000 },
+  autovacuum_multixact_freeze_table_age: { type: "integer", min: 0, max: 2000000000 },
+  log_autovacuum_min_duration: { type: "integer", min: -1, max: INT_MAX }
+};
+var TABLE_STORAGE_PARAMETERS = Object.freeze({
+  ...HEAP_ONLY,
+  ...VACUUM,
+  ...Object.fromEntries(Object.entries(VACUUM).map(([key, spec]) => [`toast.${key}`, spec]))
+});
+var TABLE_STORAGE_KEYS = Object.freeze(Object.keys(TABLE_STORAGE_PARAMETERS));
+var TOAST_PREFIX = "toast.";
+function specOf(params) {
+  return Object.hasOwn(TABLE_STORAGE_PARAMETERS, params.key) ? TABLE_STORAGE_PARAMETERS[params.key] : undefined;
+}
+function isToastStorageKey(params) {
+  return params.key.startsWith(TOAST_PREFIX);
+}
+function tableStoragePrismaKey(params) {
+  return isToastStorageKey(params) ? `toast_${params.key.slice(TOAST_PREFIX.length)}` : params.key;
+}
+function tableStorageKeyFromPrisma(params) {
+  if (specOf({ key: params.name }) !== undefined)
+    return params.name;
+  if (!params.name.startsWith("toast_"))
+    return;
+  const key = `${TOAST_PREFIX}${params.name.slice("toast_".length)}`;
+  return specOf({ key }) === undefined ? undefined : key;
+}
+var TRUE_WORDS = new Set(["true", "t", "on", "yes", "y", "1"]);
+var FALSE_WORDS = new Set(["false", "f", "off", "no", "n", "0"]);
+function parseTableStorageValue(params) {
+  const spec = specOf({ key: params.key });
+  if (spec === undefined)
+    return;
+  const text = params.text.trim().toLowerCase();
+  switch (spec.type) {
+    case "boolean":
+      return TRUE_WORDS.has(text) ? true : FALSE_WORDS.has(text) ? false : undefined;
+    case "enum":
+      return spec.values?.includes(text) === true ? text : TRUE_WORDS.has(text) ? "on" : FALSE_WORDS.has(text) ? "off" : undefined;
+    case "integer":
+    case "real": {
+      if (text === "" || !/^[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(text))
+        return;
+      const value = Number(text);
+      return Number.isFinite(value) ? value : undefined;
+    }
+  }
+}
+function renderTableStorageValue(params) {
+  return typeof params.value === "boolean" ? params.value ? "true" : "false" : String(params.value);
+}
+function valueIssue(params) {
+  const { spec, value } = params;
+  switch (spec.type) {
+    case "boolean":
+      return typeof value === "boolean" ? undefined : "takes true or false";
+    case "enum":
+      return typeof value === "string" && spec.values?.includes(value) === true ? undefined : `takes one of ${spec.values?.map((entry) => `"${entry}"`).join(", ")}`;
+    case "integer":
+    case "real": {
+      const bounds = `between ${spec.min} and ${spec.max}`;
+      if (typeof value !== "number" || !Number.isFinite(value))
+        return `takes a number ${bounds}`;
+      if (spec.type === "integer" && !Number.isInteger(value))
+        return `takes a whole number ${bounds}`;
+      return value < (spec.min ?? -Infinity) || value > (spec.max ?? Infinity) ? `takes a value ${bounds}` : undefined;
+    }
+  }
+}
+function hasTableStorage(params) {
+  return params.schema.models.some((model) => model.storage !== undefined);
+}
+function assertTableStorage(params) {
+  const { schema, dialect } = params;
+  for (const model of schema.models) {
+    const storage = model.storage;
+    if (storage === undefined)
+      continue;
+    const invalid = (issue) => new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `@@storage on "${model.name}": ${issue.message}`, meta: { rule: issue.rule, model: model.name, ...issue.parameter === undefined ? {} : { parameter: issue.parameter } } });
+    if (storage === null || typeof storage !== "object" || Array.isArray(storage) || Object.keys(storage).length === 0)
+      throw invalid({ rule: "table-storage-shape", message: "storage takes a non-empty record of parameters (omit it for a table without any)" });
+    if (model.isView)
+      throw invalid({ rule: "table-storage-view", message: "a view has no table storage parameters" });
+    if (!DIALECT_CAPABILITIES[dialect].tableStorageParameters)
+      throw unsupportedCapability({ dialect, feature: "tableStorageParameters", hint: `@@storage on "${model.name}" declares table storage parameters; they are PostgreSQL only` });
+    for (const [key, value] of Object.entries(storage)) {
+      const spec = specOf({ key });
+      if (spec === undefined)
+        throw invalid({ rule: "table-storage-parameter", message: `"${key}" is not a table storage parameter VibeORM declares (${TABLE_STORAGE_KEYS.filter((entry) => !isToastStorageKey({ key: entry })).join(", ")}, and toast. variants of the vacuum ones)`, parameter: key });
+      const issue = valueIssue({ spec, value });
+      if (issue !== undefined)
+        throw invalid({ rule: "table-storage-value", message: `"${key}" ${issue}`, parameter: key });
+    }
+  }
+}
+function tableStorageEntries(params) {
+  const storage = params.model.storage;
+  if (storage === undefined)
+    return [];
+  const known = TABLE_STORAGE_KEYS.flatMap((key) => {
+    const value = Object.hasOwn(storage, key) ? storage[key] : undefined;
+    return value === undefined ? [] : [[key, value]];
+  });
+  const unknown = Object.entries(storage).flatMap(([key, value]) => specOf({ key }) !== undefined || value === undefined ? [] : [[key, value]]);
+  return [...known, ...unknown];
+}
 // packages/schema/src/module-schema.ts
 function prepareDatabaseModuleSchema(params) {
   const { schema, module } = params;
@@ -2370,6 +2631,24 @@ function prepareDatabaseModuleSchema(params) {
     enums: schema.enums.map((entry) => enumStorageOf({ enumDef: entry }) === "database" ? { ...entry, namespace } : entry)
   };
 }
+// packages/schema/src/exclusion.ts
+function exclusionFields(params) {
+  const { source } = params.exclusion;
+  if (source === undefined)
+    return;
+  const fields = new Set;
+  for (const key of source.keys) {
+    if ("field" in key)
+      fields.add(key.field);
+    else
+      for (const field of key.fields)
+        fields.add(field);
+  }
+  for (const endpoint of [source.range.lower, source.range.upper])
+    if ("field" in endpoint)
+      fields.add(endpoint.field);
+  return [...fields];
+}
 // packages/schema/src/check-rules.ts
 var CHECK_RULE_GROUP_MAX = 8;
 var field = (name) => ({ kind: "field", name });
@@ -2533,6 +2812,133 @@ function dialectCollation(params) {
       return;
   }
 }
+// packages/schema/src/failure-kind.ts
+var CONNECTION_FAILURE_REASONS = Object.freeze([
+  "connection-refused",
+  "connection-timeout",
+  "connection-lost",
+  "connection-not-writable",
+  "acquire-timeout",
+  "pool-exhausted",
+  "pool-closed",
+  "too-many-connections",
+  "server-shutdown"
+]);
+var CONNECTION_REASON_SET = new Set(CONNECTION_FAILURE_REASONS);
+function isConnectionFailureReason(params) {
+  return typeof params.value === "string" && CONNECTION_REASON_SET.has(params.value);
+}
+var FAILURE_KINDS = Object.freeze([
+  "connection",
+  "conflict",
+  "timeout",
+  "constraint"
+]);
+var VIBE_CODE_SET = new Set(VIBE_ERROR_CODES);
+var CONFLICT_REASONS = new Set(["deadlock", "serialization-failure", "busy"]);
+var TIMEOUT_REASONS = new Set(["timeout", "transaction-deadline"]);
+var POSTGRES_CONSTRAINT_SQLSTATES = new Set(["23502", "23514"]);
+var SQLITE_CONSTRAINT_CODES = new Set([
+  "SQLITE_CONSTRAINT_NOTNULL",
+  "SQLITE_CONSTRAINT_CHECK",
+  "SQLITE_CONSTRAINT_TRIGGER"
+]);
+var MYSQL_CONSTRAINT_ERRNOS = new Set([1048, 1364, 3819]);
+function constraintRefusal(params) {
+  const { meta } = params;
+  if (typeof meta.sqlstate === "string")
+    return POSTGRES_CONSTRAINT_SQLSTATES.has(meta.sqlstate);
+  if (typeof meta.sqlState === "string" && typeof meta.errno === "number")
+    return MYSQL_CONSTRAINT_ERRNOS.has(meta.errno);
+  return typeof meta.code === "string" && SQLITE_CONSTRAINT_CODES.has(meta.code);
+}
+function failureKindOf(params) {
+  const { error } = params;
+  if (typeof error !== "object" || error === null)
+    return;
+  const { code, meta } = error;
+  if (typeof code !== "string" || !VIBE_CODE_SET.has(code))
+    return;
+  const facts = typeof meta === "object" && meta !== null ? meta : {};
+  const reason = facts.reason;
+  switch (code) {
+    case "VIBE_ADAPTER":
+      if (isConnectionFailureReason({ value: reason }))
+        return "connection";
+      return typeof reason === "string" && TIMEOUT_REASONS.has(reason) ? "timeout" : undefined;
+    case "VIBE_TRANSACTION":
+      if (typeof reason !== "string")
+        return;
+      if (CONFLICT_REASONS.has(reason))
+        return "conflict";
+      return TIMEOUT_REASONS.has(reason) ? "timeout" : undefined;
+    case "VIBE_UNIQUE_VIOLATION":
+    case "VIBE_FK_VIOLATION":
+    case "VIBE_EXCLUSION_VIOLATION":
+      return "constraint";
+    case "VIBE_VALIDATION":
+      return constraintRefusal({ meta: facts }) ? "constraint" : undefined;
+    default:
+      return;
+  }
+}
+// packages/schema/src/suggest.ts
+function editDistance(params) {
+  const { from, to } = params;
+  const rows = from.length + 1;
+  const columns = to.length + 1;
+  const table = new Array(rows * columns).fill(0);
+  for (let row = 0;row < rows; row++)
+    table[row * columns] = row;
+  for (let column = 0;column < columns; column++)
+    table[column] = column;
+  for (let row = 1;row < rows; row++) {
+    for (let column = 1;column < columns; column++) {
+      const cost = from[row - 1] === to[column - 1] ? 0 : 1;
+      let best = Math.min(table[(row - 1) * columns + column] + 1, table[row * columns + column - 1] + 1, table[(row - 1) * columns + column - 1] + cost);
+      if (row > 1 && column > 1 && from[row - 1] === to[column - 2] && from[row - 2] === to[column - 1]) {
+        best = Math.min(best, table[(row - 2) * columns + column - 2] + 1);
+      }
+      table[row * columns + column] = best;
+    }
+  }
+  return table[rows * columns - 1];
+}
+function suggestName(params) {
+  const { name } = params;
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let tied = false;
+  for (const candidate of new Set(params.candidates)) {
+    if (candidate === name)
+      continue;
+    const distance = editDistance({ from: name, to: candidate });
+    const limit = Math.max(2, Math.floor(Math.max(name.length, candidate.length) / 3));
+    if (distance > limit || distance >= name.length)
+      continue;
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+      tied = false;
+    } else if (distance === bestDistance) {
+      tied = true;
+    }
+  }
+  return tied ? undefined : best;
+}
+function didYouMean(params) {
+  return params.suggestion === undefined ? "" : ` \u2014 did you mean ${JSON.stringify(params.suggestion)}?`;
+}
+var unknownNameMetas = new WeakSet;
+function withSuggestion(params) {
+  const suggestion = suggestName({ name: params.name, candidates: params.candidates });
+  const meta = suggestion === undefined ? params.meta : { ...params.meta, suggestion };
+  unknownNameMetas.add(meta);
+  return { message: suggestion === undefined ? params.message : `${params.message}${didYouMean({ suggestion })}`, meta };
+}
+function isUnknownNameRefusal(params) {
+  return unknownNameMetas.has(params.meta);
+}
 // packages/schema/src/computed.ts
 function buildComputedManifest(params) {
   const { computed } = params;
@@ -2571,6 +2977,8 @@ function validateComputedConfig(params) {
       }
       if (fieldName === "_count")
         problems.push(`"${at}" collides with the _count projection`);
+      if (fieldName === "_aggregate")
+        problems.push(`"${at}" collides with the _aggregate projection`);
       if (model.fields.some((field) => field.name === fieldName)) {
         problems.push(`"${at}" collides with a schema field of the same name`);
       }
@@ -2857,6 +3265,10 @@ var RESERVED_ENUM_NAMES = [
   "SelectionMember",
   "SelectionValue",
   "BagKeys",
+  "__VibeBagKeysIn",
+  "__VibeCertain",
+  "__VibeAllOn",
+  "__VibeAggregateSelection",
   "IncludedRelation",
   "IncludedCount",
   "ViewDelegateMap",
@@ -2865,6 +3277,21 @@ var RESERVED_ENUM_NAMES = [
   "__VibeAt",
   "__VibeItem",
   "__VibeExact",
+  "__VibeLiteral",
+  "__VibePreviousInput",
+  "__VibePrevious",
+  "__VibeUpdated",
+  "__VibeDeleted",
+  "__VibeOrNullRow",
+  "__VibeUpserted",
+  "__VibeCreated",
+  "__VibeAggregateValue",
+  "__VibeSplitEntries",
+  "__VibeViewAggregates",
+  "__VibeViewBucket",
+  "__VibeViewFiltered",
+  "__VibeViewBy",
+  "__VibeViewByKey",
   "extensionManifest",
   "extensionMounts",
   "computedManifest",
@@ -2877,6 +3304,7 @@ var RESERVED_ENUM_NAMES = [
   "Partial",
   "Omit",
   "NonNullable",
+  "NoInfer",
   "Promise",
   "PromiseLike",
   "Awaited",
@@ -2905,6 +3333,12 @@ var RESERVED_ENUM_NAMES = [
   "RowLockRequest",
   "GroupByTruncateUnit",
   "GroupByKeyName",
+  "GroupByPath",
+  "GroupByExpressionValues",
+  "GroupByKeyOrderInput",
+  "GroupByOrderKeys",
+  "GroupByKeyOrderCheck",
+  "GroupingSetRow",
   "JsonValue",
   "InputJsonValue",
   "InputJsonArray",
@@ -2930,9 +3364,21 @@ var RESERVED_ENUM_NAMES = [
   "createClient",
   "DatabaseAdapter",
   "DbNow",
+  "BigIntFieldRef",
+  "BooleanFieldRef",
+  "DateTimeFieldRef",
+  "DecimalFieldRef",
+  "EnumFieldRef",
+  "FloatFieldRef",
+  "IntFieldRef",
+  "NumericFieldRef",
+  "StringFieldRef",
   "JoinedField",
   "TransactionLocalSettings",
   "VibeUpdateManySources",
+  "VibeModelRows",
+  "VibeUniqueKeys",
+  "VibeHandleTypes",
   "ClientContext",
   "QueryOperation",
   "QueryEvent",
@@ -3016,6 +3462,12 @@ var GENERATED_TYPE_NAMES = {
     "HavingInput",
     "GroupByOrderByInput",
     "GroupByTruncatedKey",
+    "GroupByExpressionKey",
+    "FilteredAggregateInput",
+    "FilteredAggregateHavingInput",
+    "FilteredAggregateOrderByInput",
+    "FilteredResult",
+    "CoalesceOrderInput",
     "FindManyArgs",
     "FindPageArgs",
     "FindFirstArgs",
@@ -3040,6 +3492,10 @@ var GENERATED_TYPE_NAMES = {
     "OmitBase",
     "CountResult",
     "CountPayload",
+    "AggregateEntries",
+    "AggregateEntryArgs",
+    "AggregateOf",
+    "AggregatePayload",
     "AggregateValues",
     "AggregateSelection",
     "CountOutput",
@@ -3056,6 +3512,7 @@ var GENERATED_TYPE_NAMES = {
     "ViewNestedArgs",
     "ViewFindManyArgs",
     "ViewFindUniqueArgs",
+    "ViewAggregateBag",
     "ViewScalars",
     "ViewSelectScalars",
     "ViewReveal",
@@ -3065,6 +3522,7 @@ var GENERATED_TYPE_NAMES = {
     "ViewDelegate",
     "ReadOnlyDelegate"
   ],
+  generatedColumnSuffixes: ["WritableScalarFieldEnum", "GeneratedWriteGuard", "GeneratedBulkWriteRow"],
   nestedPrefixes: [
     "Create",
     "UncheckedCreate",
@@ -3140,33 +3598,118 @@ var INVALID_BINDING_NAMES = new Set([
   "object",
   "undefined"
 ]);
-function validateGeneratedNames(params) {
-  const { schema, issues } = params;
-  const owners = new Map(RESERVED_ENUM_NAMES.map((name) => [name, "generated client"]));
+var DISAMBIGUATED_TYPE_SUFFIXES = {
+  ListRelationFilter: true,
+  RelationFilter: true,
+  RelationOrderByInput: true,
+  RelationFindManyArgs: true,
+  CreateArgs: true,
+  UpdateArgs: true,
+  UpdateWhereInput: true,
+  UpsertArgs: true,
+  DeleteArgs: true,
+  CountArgs: true,
+  CountSelect: true,
+  AggregateArgs: true,
+  ViewSelect: true,
+  ViewInclude: true,
+  ViewFindManyArgs: true,
+  ViewFindUniqueArgs: true,
+  ViewDelegate: true
+};
+function isDisambiguatedTypeSuffix(suffix) {
+  return Object.hasOwn(DISAMBIGUATED_TYPE_SUFFIXES, suffix);
+}
+function generatedNameClaims(params) {
+  const { schema } = params;
+  const claims = [];
+  const fixed = (options) => {
+    for (const name of options.names)
+      claims.push({ name, owner: options.owner, kind: "client", stem: name, suffix: "" });
+  };
+  fixed({ names: RESERVED_ENUM_NAMES, owner: "generated client" });
   if (schema.rls !== undefined) {
-    owners.set("RlsContext", "native RLS client");
-    owners.set("BoundVibeClientInstance", "native RLS client");
-    owners.set("BoundVibeTransactionClientInstance", "native RLS client");
-    owners.set("OperatorVibeClientInstance", "native RLS client");
-    owners.set("OperatorVibeTransactionClientInstance", "native RLS client");
+    fixed({ names: ["RlsContext", "BoundVibeClientInstance", "BoundVibeTransactionClientInstance", "OperatorVibeClientInstance", "OperatorVibeTransactionClientInstance"], owner: "native RLS client" });
   }
   if (schema.models.some((model) => model.policy !== undefined))
-    owners.set("PolicyClientInstance", "policy client");
+    fixed({ names: ["PolicyClientInstance"], owner: "policy client" });
   if (schema.models.some((model) => model.fields.some((field) => isLocalDateField({ field })))) {
-    for (const name of ["LocalDate", "LocalDateFilter", "LocalDateNullableFilter"])
-      owners.set(name, "local-date filters");
+    fixed({ names: ["LocalDate", "LocalDateFilter", "LocalDateNullableFilter"], owner: "local-date filters" });
+  }
+  for (const model of schema.models) {
+    const owner = `model "${model.name}"`;
+    const claim = (suffix) => {
+      claims.push({ name: `${model.name}${suffix}`, owner, kind: "model", stem: model.name, suffix });
+    };
+    for (const suffix of GENERATED_TYPE_NAMES.modelSuffixes)
+      claim(suffix);
+    if (model.fields.some((field) => field.generated !== undefined && field.isUnsupported !== true)) {
+      for (const suffix of GENERATED_TYPE_NAMES.generatedColumnSuffixes)
+        claim(suffix);
+    }
+    const withouts = ["", ...model.relations.map((relation) => `Without${relation.name.charAt(0).toUpperCase()}${relation.name.slice(1)}`)];
+    for (const without of withouts) {
+      for (const prefix of GENERATED_TYPE_NAMES.nestedPrefixes)
+        claim(`${prefix}${without}Input`);
+    }
   }
-  const register = (params) => {
-    if (!/^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(params.name) || INVALID_BINDING_NAMES.has(params.name)) {
-      issues.push({ rule: "invalid-generated-identifier", message: `Generated name "${params.name}" from ${params.owner} is not a legal TypeScript identifier` });
+  for (const declared of schema.enums) {
+    for (const suffix of GENERATED_TYPE_NAMES.enumSuffixes) {
+      claims.push({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"`, kind: "enum", stem: declared.name, suffix });
     }
-    const previous = owners.get(params.name);
-    if (previous !== undefined && previous !== params.owner) {
-      issues.push({ rule: "generated-name-collision", message: `Generated name "${params.name}" from ${params.owner} conflicts with ${previous}` });
-    } else {
-      owners.set(params.name, params.owner);
+  }
+  return claims;
+}
+function renameHint(params) {
+  const named = [params.claim, params.keeper].filter((claim) => claim.kind !== "client");
+  const table = named.some((claim) => claim.kind === "model") ? " (@@map, or map in the DSL, keeps a model's table name)" : "";
+  return `rename ${[...new Set(named.map((claim) => claim.owner))].join(" or ")}${table}`;
+}
+function resolveGeneratedNames(params) {
+  const claims = generatedNameClaims({ schema: params.schema });
+  const issues = [];
+  const keepers = new Map;
+  for (const claim of claims) {
+    if (claim.kind !== "client" && (!/^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(claim.name) || INVALID_BINDING_NAMES.has(claim.name))) {
+      issues.push({ rule: "invalid-generated-identifier", message: `Generated name "${claim.name}" from ${claim.owner} is not a legal TypeScript identifier` });
+    }
+    const keeper = keepers.get(claim.name);
+    if (keeper === undefined || claim.stem.length > keeper.stem.length)
+      keepers.set(claim.name, claim);
+  }
+  const renamed = new Map;
+  const moved = [];
+  for (const claim of claims) {
+    const keeper = keepers.get(claim.name) ?? claim;
+    if (keeper.owner === claim.owner)
+      continue;
+    if (claim.kind === "model" && isDisambiguatedTypeSuffix(claim.suffix) && keeper.suffix !== "" && claim.stem.length < keeper.stem.length) {
+      const name = `${claim.stem}_${claim.suffix}`;
+      renamed.set(`${claim.stem}\x00${claim.suffix}`, name);
+      moved.push({ claim, keeper, name });
+      continue;
     }
+    issues.push({ rule: "generated-name-collision", message: `Generated name "${claim.name}" from ${claim.owner} conflicts with ${keeper.owner}; ${renameHint({ claim, keeper })}` });
+  }
+  for (const { claim, keeper, name } of moved) {
+    const taken = keepers.get(name);
+    if (taken === undefined || taken.owner === claim.owner)
+      continue;
+    issues.push({
+      rule: "generated-name-collision",
+      message: `Generated name "${name}" from ${claim.owner} (renamed because ${keeper.owner} keeps "${claim.name}") conflicts with ${taken.owner}; ${renameHint({ claim, keeper: taken })}`
+    });
+  }
+  return { renamed, issues };
+}
+function generatedTypeNames(params) {
+  const { renamed } = resolveGeneratedNames({ schema: params.schema });
+  return {
+    model: ({ model, suffix }) => renamed.get(`${model}\x00${suffix}`) ?? `${model}${suffix}`
   };
+}
+function validateGeneratedNames(params) {
+  const { schema, issues } = params;
   const aliases = new Map;
   for (const model of schema.models) {
     const clientName = model.name.charAt(0).toLowerCase() + model.name.slice(1);
@@ -3180,19 +3723,8 @@ function validateGeneratedNames(params) {
     if (RESERVED_CLIENT_NAMES.includes(clientName)) {
       issues.push({ rule: "reserved-client-name", message: `Model "${model.name}" conflicts with client member "${clientName}"`, model: model.name });
     }
-    const owner = `model "${model.name}"`;
-    for (const suffix of GENERATED_TYPE_NAMES.modelSuffixes)
-      register({ name: `${model.name}${suffix}`, owner });
-    const withouts = ["", ...model.relations.map((relation) => `Without${relation.name.charAt(0).toUpperCase()}${relation.name.slice(1)}`)];
-    for (const without of withouts) {
-      for (const prefix of GENERATED_TYPE_NAMES.nestedPrefixes)
-        register({ name: `${model.name}${prefix}${without}Input`, owner });
-    }
-  }
-  for (const declared of schema.enums) {
-    for (const suffix of GENERATED_TYPE_NAMES.enumSuffixes)
-      register({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"` });
   }
+  issues.push(...resolveGeneratedNames({ schema }).issues);
 }
 function foreignKeyKeys(params) {
   const distinct = new Set;
@@ -3495,7 +4027,7 @@ function validatePhysicalNameUniqueness(params) {
     for (const { index, site } of declarations) {
       const unique = index.kind === "unique";
       const columns = index.fields.map((entry) => [columnOf(entry.name), entry.sort === "desc", entry.operatorClass === undefined ? null : [entry.operatorClass.namespace, entry.operatorClass.name]]);
-      const key = isExpressionIndex({ index }) ? indexKeyDefinitionKey({ index, model }) : JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
+      const key = isExpressionIndex({ index }) ? indexKeyDefinitionKey({ index, model }) : JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? "", ...index.include === undefined ? [] : [{ include: index.include.map(columnOf) }]]);
       if (seenIndexKeys.has(key))
         continue;
       seenIndexKeys.add(key);
@@ -3933,6 +4465,27 @@ function validateModel(params) {
         }
       }
     }
+    if (relation.inverseKey !== undefined) {
+      const { fields, references } = relation.inverseKey;
+      if (relation.isList || hasFields || hasReferences || !Array.isArray(fields) || !Array.isArray(references) || fields.length === 0 || fields.length !== references.length) {
+        issues.push({
+          rule: "inverse-key-shape",
+          message: `Relation "${model.name}.${relation.name}" declares an inverse key, which needs a to-one without foreign-key fields and as many references as fields`,
+          model: model.name,
+          field: relation.name
+        });
+      } else {
+        for (const name of fields) {
+          if (!fieldNames.has(name))
+            issues.push({ rule: "unknown-relation-field", message: `Relation "${model.name}.${relation.name}" uses unknown inverse-key field "${name}"`, model: model.name, field: relation.name });
+        }
+        const targetFields = target === undefined ? undefined : lookups.fieldsByModel.get(target);
+        for (const name of references) {
+          if (targetFields !== undefined && !targetFields.has(name))
+            issues.push({ rule: "unknown-relation-reference", message: `Relation "${model.name}.${relation.name}" references unknown inverse-key field "${relation.targetModel}.${name}"`, model: model.name, field: relation.name });
+        }
+      }
+    }
   }
   for (const field of model.fields) {
     if (field.collation !== undefined && (field.type !== "String" || isLocalDateField({ field }))) {
@@ -4224,6 +4777,12 @@ function assertMysqlCheckReferentialActions(params) {
   }
 }
 function assertValidSchemaIR(params) {
+  if (isKnownValidSchemaIR(params))
+    return;
+  assertSchemaIRNow(params);
+  rememberValidSchemaIR(params);
+}
+function assertSchemaIRNow(params) {
   const rowRules = createRowRuleValidationContext(params);
   const dialect = providerToDialect({ provider: params.schema.datasource.provider });
   assertIndexExpressions({ schema: params.schema, dialect });
@@ -4240,6 +4799,8 @@ function assertValidSchemaIR(params) {
   }
   assertExtensionPlacement({ schema: params.schema, dialect });
   assertIndexOperatorClasses({ schema: params.schema, dialect });
+  assertIndexIncludeColumns({ schema: params.schema, dialect });
+  assertTableStorage({ schema: params.schema, dialect });
   for (const entry of [...params.schema.models, ...params.schema.enums])
     if (entry.namespace !== undefined)
       assertSqlNamespace({ namespace: entry.namespace, dialect });
@@ -4540,14 +5101,261 @@ function validRlsForeignKey(params) {
   ];
   return validFields && uniqueSets.some((set) => set.length === refs.length && set.every((name) => refs.includes(name)));
 }
+// packages/schema/src/partial-predicate.ts
+function normalizeWhere(params) {
+  const { where } = params;
+  if (where === undefined || where.trim() === "")
+    return "";
+  if (/\$|\\|--|\/\*/.test(where))
+    return `raw:${where.trim()}`;
+  const tokens = tokenizeWhere({ text: where });
+  const parsed = parseOrExpression({ tokens, at: 0 });
+  return parsed !== undefined && parsed.at === tokens.length ? parsed.text : tokens.join(" ");
+}
+function tokenizeWhere(params) {
+  const { text } = params;
+  const tokens = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (/\s/.test(ch)) {
+      i += 1;
+      continue;
+    }
+    if (ch === "'") {
+      let literal = "'";
+      i += 1;
+      while (i < text.length) {
+        literal += text[i];
+        if (text[i] === "'") {
+          if (text[i + 1] === "'") {
+            literal += "'";
+            i += 2;
+            continue;
+          }
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      tokens.push(literal);
+      continue;
+    }
+    if (ch === '"' || ch === "`") {
+      let name = "";
+      i += 1;
+      while (i < text.length) {
+        if (text[i] === ch) {
+          if (text[i + 1] !== ch) {
+            i += 1;
+            break;
+          }
+          name += ch;
+          i += 2;
+        } else {
+          name += text[i];
+          i += 1;
+        }
+      }
+      tokens.push(JSON.stringify(name));
+      continue;
+    }
+    if (ch === "[") {
+      const end = text.indexOf("]", i + 1);
+      const inner = end === -1 ? undefined : text.slice(i + 1, end);
+      if (inner !== undefined && tokens[tokens.length - 1] !== "array" && /^[A-Za-z_][A-Za-z_0-9$]*$/.test(inner)) {
+        tokens.push(JSON.stringify(inner));
+        i = end + 1;
+        continue;
+      }
+      tokens.push(ch);
+      i += 1;
+      continue;
+    }
+    const word = /^[A-Za-z_][A-Za-z_0-9$]*/.exec(text.slice(i));
+    if (word !== null) {
+      tokens.push(word[0].toLowerCase());
+      i += word[0].length;
+      continue;
+    }
+    const number = /^[0-9]+(?:\.[0-9]+)?/.exec(text.slice(i));
+    if (number !== null) {
+      tokens.push(number[0]);
+      i += number[0].length;
+      continue;
+    }
+    tokens.push(ch);
+    i += 1;
+  }
+  return tokens;
+}
+function parseOrExpression(params) {
+  const first = parseAndExpression({ tokens: params.tokens, at: params.at });
+  if (first === undefined)
+    return;
+  let at = first.at;
+  const parts = [first.text];
+  while (params.tokens[at] === "or") {
+    const next = parseAndExpression({ tokens: params.tokens, at: at + 1 });
+    if (next === undefined)
+      return;
+    parts.push(next.text);
+    at = next.at;
+  }
+  return parts.length === 1 ? { text: parts[0], at, kind: first.kind } : { text: parts.join(" or "), at, kind: "or" };
+}
+function parseAndExpression(params) {
+  const first = parsePrimaryExpression({ tokens: params.tokens, at: params.at });
+  if (first === undefined)
+    return;
+  let at = first.at;
+  const operands = [first];
+  while (params.tokens[at] === "and") {
+    const next = parsePrimaryExpression({ tokens: params.tokens, at: at + 1 });
+    if (next === undefined)
+      return;
+    operands.push(next);
+    at = next.at;
+  }
+  return operands.length === 1 ? { text: first.text, at, kind: first.kind } : {
+    text: operands.map((operand) => operand.kind === "or" ? `(${operand.text})` : operand.text).join(" and "),
+    at,
+    kind: "and"
+  };
+}
+function parsePrimaryExpression(params) {
+  const { tokens } = params;
+  let at = params.at;
+  if (tokens[at] === "not") {
+    const operand = parsePrimaryExpression({ tokens, at: at + 1 });
+    if (operand === undefined)
+      return;
+    const inner = operand.kind === "atom" ? operand.text : `(${operand.text})`;
+    return { text: `not ${inner}`, at: operand.at, kind: "atom" };
+  }
+  if (tokens[at] === "(") {
+    const inner = parseOrExpression({ tokens, at: at + 1 });
+    if (inner === undefined || tokens[inner.at] !== ")")
+      return;
+    return { text: inner.text, at: inner.at + 1, kind: inner.kind };
+  }
+  const parts = [];
+  let depth = 0;
+  while (at < tokens.length) {
+    const token = tokens[at];
+    if (depth === 0 && (token === "and" || token === "or" || token === ")"))
+      break;
+    if (token === "(")
+      depth += 1;
+    if (token === ")")
+      depth -= 1;
+    parts.push(token);
+    at += 1;
+  }
+  if (parts.length === 0)
+    return;
+  if (parts[1] === "is" && (parts.length === 3 && parts[2] === "null" || parts.length === 4 && parts[2] === "not" && parts[3] === "null")) {
+    const quoted = /^"([a-z_][a-z_0-9]*)"$/.exec(parts[0]);
+    if (quoted !== null && !/^(?:true|false|null|unknown|default|user|current_.*|session_user|system_user|localtime|localtimestamp|and|or|not|is)$/.test(quoted[1]))
+      parts[0] = quoted[1];
+  }
+  return { text: parts.join(" "), at, kind: "atom" };
+}
+
+// packages/schema/src/unique-keys.ts
+var RANK = { primaryKey: 0, field: 1, block: 2, partial: 3, expression: 4 };
+function comparisonKey(params) {
+  const { model, index } = params;
+  const common = [index.nullsNotDistinct === true, normalizeWhere({ where: index.where }), index.include ?? []];
+  if (isExpressionIndex({ index }))
+    return JSON.stringify(["expression", indexKeyDefinitionKey({ index, model }), ...common]);
+  return JSON.stringify(["fields", index.fields.map((field) => [field.name, field.sort === "desc", field.operatorClass ?? null]), ...common]);
+}
+function modelUniqueKeys(params) {
+  const { model, dialect } = params;
+  if (model.isView)
+    return [];
+  const table = model.dbName ?? model.name;
+  const columnOf = (name) => model.fields.find((field) => field.name === name)?.dbName ?? name;
+  const candidates = [];
+  const primaryKey = model.primaryKey?.fields ?? model.fields.filter((field) => field.isId).map((field) => field.name);
+  if (primaryKey.length > 0) {
+    const name = dialect === "mysql" ? "PRIMARY" : dialect === "sqlite" ? null : model.primaryKeyConstraintName ?? defaultPrimaryKeyName({ table, dialect });
+    candidates.push({
+      rank: RANK.primaryKey,
+      order: 0,
+      natural: model.primaryKey?.clientName ?? primaryKey.join("_"),
+      fallback: model.primaryKeyConstraintName ?? defaultPrimaryKeyName({ table, dialect: "sqlite" }),
+      entry: { name, names: name === null ? [] : [name], fields: primaryKey, primaryKey: true, partial: false }
+    });
+  }
+  const seen = new Set;
+  const add = (params) => {
+    const { index } = params;
+    const identity = comparisonKey({ model, index });
+    if (seen.has(identity))
+      return;
+    seen.add(identity);
+    const partial = index.where !== undefined;
+    if (isExpressionIndex({ index })) {
+      const sourceFields = indexKeyFieldNames({ index });
+      const indexName = index.name ?? (sourceFields === undefined ? undefined : defaultExpressionIndexName({ table, model, index, dialect }));
+      if (indexName === undefined)
+        return;
+      const names = [...new Set([index.constraintName ?? indexName, indexName])];
+      candidates.push({
+        rank: RANK.expression,
+        order: params.order,
+        natural: sourceFields?.join("_"),
+        fallback: index.name ?? defaultExpressionIndexName({ table, model, index, dialect: "sqlite" }),
+        entry: { name: names[0], names, ...sourceFields === undefined ? {} : { sourceFields }, primaryKey: false, partial }
+      });
+      return;
+    }
+    const fields = index.fields.map((field) => field.name);
+    const indexName = index.name ?? defaultIndexName({ table, columns: fields.map(columnOf), unique: true, dialect });
+    const names = [...new Set([index.constraintName ?? indexName, indexName])];
+    candidates.push({
+      rank: partial ? RANK.partial : params.rank,
+      order: params.order,
+      natural: index.clientName ?? fields.join("_"),
+      fallback: index.constraintName ?? index.name ?? defaultIndexName({ table, columns: fields.map(columnOf), unique: true, dialect: "sqlite" }),
+      entry: { name: names[0], names, fields, primaryKey: false, partial }
+    });
+  };
+  const fieldKey = (name) => ({ kind: "unique", fields: [{ name }] });
+  model.indexes.forEach((index, position) => {
+    if (index.kind !== "unique")
+      return;
+    const own = isExpressionIndex({ index }) || index.fields.length !== 1 ? -1 : model.fields.findIndex((field) => field.isUnique && field.name === index.fields[0].name && comparisonKey({ model, index }) === comparisonKey({ model, index: fieldKey(field.name) }));
+    add({ index, rank: own >= 0 ? RANK.field : RANK.block, order: own >= 0 ? own : position });
+  });
+  model.fields.forEach((field, position) => {
+    if (field.isUnique)
+      add({ index: fieldKey(field.name), rank: RANK.field, order: position });
+  });
+  const claimed = new Set;
+  const keyed = new Map;
+  for (const candidate of [...candidates].sort((left, right) => left.rank - right.rank || left.order - right.order)) {
+    let key = candidate.natural !== undefined && !claimed.has(candidate.natural) ? candidate.natural : candidate.fallback;
+    for (let suffix = 2;claimed.has(key); suffix++)
+      key = `${candidate.fallback}_${suffix}`;
+    claimed.add(key);
+    keyed.set(candidate, key);
+  }
+  return candidates.sort((left, right) => left.rank - right.rank || left.order - right.order).map((candidate) => ({ key: keyed.get(candidate), ...candidate.entry }));
+}
 export {
   CHECK_RULE_GROUP_MAX,
+  CONNECTION_FAILURE_REASONS,
   DATE_TRUNCATION_UNITS,
   DIALECTS,
   DIALECT_CAPABILITIES,
   EMPTY_EXTENSION_REGISTRY,
   ENUM_STORAGES,
+  FAILURE_KINDS,
   IDENTIFIER_LIMITS,
+  INCLUDE_INDEX_KINDS,
   MYSQL_CAPABILITIES,
   MYSQL_FUNCTIONAL_KEY_LIMITS,
   MYSQL_ROW_RULE_MESSAGE_MAX_BYTES,
@@ -4565,6 +5373,8 @@ export {
   SQLITE_ROW_RULE_ERROR_PREFIX,
   SQL_NAMESPACES,
   ScopedQueryError,
+  TABLE_STORAGE_KEYS,
+  TABLE_STORAGE_PARAMETERS,
   VIBE_ERROR_CODES,
   VibeError,
   assertExtensionModelPlacement,
@@ -4573,6 +5383,7 @@ export {
   assertGeneratedColumns,
   assertIdentifierFits,
   assertIndexExpressions,
+  assertIndexIncludeColumns,
   assertIndexOperatorClasses,
   assertJsonSchemaRef,
   assertMigrationObjects,
@@ -4582,6 +5393,7 @@ export {
   assertRowRuleEquality,
   assertRowRuleReferentialActions,
   assertSqlNamespace,
+  assertTableStorage,
   assertValidSchemaIR,
   assertValidatorRef,
   buildComputedManifest,
@@ -4596,18 +5408,25 @@ export {
   defaultRowRuleName,
   defineExtension,
   dialectCollation,
+  didYouMean,
+  editDistance,
   encodePrismaString,
   enumStorageOf,
   exactDecimalLiteral,
   exactIntegerLiteral,
+  exclusionFields,
   extensionDeclarations,
   extensionManifestEntry,
   extensionOptionsHash,
+  failureKindOf,
   fieldTypeIdentity,
   fitDefaultName,
   generatedColumnFromSql,
   generatedColumnShapeIssue,
+  generatedTypeNames,
+  hasIndexIncludeColumns,
   hasJsonSchemaAnnotation,
+  hasTableStorage,
   hasValidatorAnnotation,
   identifierLength,
   implicitJoinTable,
@@ -4622,6 +5441,7 @@ export {
   internalError,
   invalidStoredData,
   isCanonicalLocalDate,
+  isConnectionFailureReason,
   isEnumType,
   isExpressionIndex,
   isImplicitManyToManyRelation,
@@ -4632,17 +5452,22 @@ export {
   isReservedDelegateName,
   isSqlObjectDefinition,
   isSqlObjectIdentity,
+  isToastStorageKey,
+  isUnknownNameRefusal,
   jsonSchemaRefIssue,
   jsonTypeAnnotationIssue,
   jsonTypeAnnotationRef,
   localDateCheckName,
   mergeExtensionDeclarations,
   modelSqlNamespace,
+  modelUniqueKeys,
   mysqlIndexKeyWidth,
   mysqlRowRuleMessageByteLength,
   normalizeJsonSchemaRef,
   normalizeRowRules,
   normalizeValidatorRef,
+  normalizeWhere,
+  parseTableStorageValue,
   postgresGeneratedObjectName,
   predicateCapabilityIssue,
   predicateFieldNames,
@@ -4650,6 +5475,7 @@ export {
   prepareDatabaseModuleSchema,
   providerToDialect,
   qualifiedSqlName,
+  renderTableStorageValue,
   resolveOnDelete,
   resolveOnUpdate,
   resolveReferentialActions,
@@ -4664,12 +5490,17 @@ export {
   rowRuleTriggerName,
   scalarListDefault,
   schemaRowRuleIdentities,
+  sealSchemaIR,
   serializeJsonDefault,
   setDefaultRelationOf,
   sqlNamespaceIssue,
   sqlObjectKey,
   sqlObjectNamespace,
   sqliteRowRuleConstraint,
+  suggestName,
+  tableStorageEntries,
+  tableStorageKeyFromPrisma,
+  tableStoragePrismaKey,
   timeOfDayType,
   unsupportedCapability,
   validateComputedConfig,
@@ -4678,7 +5509,8 @@ export {
   validateRlsContextIR,
   validateRowRules,
   validateSchemaIR,
-  validatorRefIssue
+  validatorRefIssue,
+  withSuggestion
 };
 
-//# debugId=16597011ACA85C7264756E2164756E21
+//# debugId=D9E0341E199A9F8664756E2164756E21