@vibeorm/schema 5.9.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) {
@@ -479,7 +483,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   filteredAggregates: "filterClause",
   groupingSets: "groupingSets",
   rowCapture: true,
-  returningReadsJoinedSource: true
+  returningReadsJoinedSource: true,
+  upsertSkipUnchanged: true
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -526,7 +531,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   filteredAggregates: "filterClause",
   groupingSets: "none",
   rowCapture: false,
-  returningReadsJoinedSource: false
+  returningReadsJoinedSource: false,
+  upsertSkipUnchanged: true
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -573,7 +579,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   filteredAggregates: "caseWhen",
   groupingSets: "rollup",
   rowCapture: false,
-  returningReadsJoinedSource: false
+  returningReadsJoinedSource: false,
+  upsertSkipUnchanged: true
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -1566,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" });
   }
@@ -1589,6 +1665,7 @@ function assertNativeRlsAdmission(params) {
       });
     }
   }
+  rememberAdmittedSchemaIR({ schema, dialect });
 }
 // packages/schema/src/model-sql-namespace.ts
 function modelSqlNamespace(params) {
@@ -2554,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 });
@@ -2717,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;
@@ -2755,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`);
       }
@@ -3043,6 +3267,8 @@ var RESERVED_ENUM_NAMES = [
   "BagKeys",
   "__VibeBagKeysIn",
   "__VibeCertain",
+  "__VibeAllOn",
+  "__VibeAggregateSelection",
   "IncludedRelation",
   "IncludedCount",
   "ViewDelegateMap",
@@ -3051,8 +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",
@@ -3065,6 +3304,7 @@ var RESERVED_ENUM_NAMES = [
   "Partial",
   "Omit",
   "NonNullable",
+  "NoInfer",
   "Promise",
   "PromiseLike",
   "Awaited",
@@ -3137,6 +3377,7 @@ var RESERVED_ENUM_NAMES = [
   "TransactionLocalSettings",
   "VibeUpdateManySources",
   "VibeModelRows",
+  "VibeUniqueKeys",
   "VibeHandleTypes",
   "ClientContext",
   "QueryOperation",
@@ -3251,6 +3492,10 @@ var GENERATED_TYPE_NAMES = {
     "OmitBase",
     "CountResult",
     "CountPayload",
+    "AggregateEntries",
+    "AggregateEntryArgs",
+    "AggregateOf",
+    "AggregatePayload",
     "AggregateValues",
     "AggregateSelection",
     "CountOutput",
@@ -3267,6 +3512,7 @@ var GENERATED_TYPE_NAMES = {
     "ViewNestedArgs",
     "ViewFindManyArgs",
     "ViewFindUniqueArgs",
+    "ViewAggregateBag",
     "ViewScalars",
     "ViewSelectScalars",
     "ViewReveal",
@@ -4531,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 });
@@ -4849,13 +5101,259 @@ 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,
@@ -4910,13 +5408,17 @@ export {
   defaultRowRuleName,
   defineExtension,
   dialectCollation,
+  didYouMean,
+  editDistance,
   encodePrismaString,
   enumStorageOf,
   exactDecimalLiteral,
   exactIntegerLiteral,
+  exclusionFields,
   extensionDeclarations,
   extensionManifestEntry,
   extensionOptionsHash,
+  failureKindOf,
   fieldTypeIdentity,
   fitDefaultName,
   generatedColumnFromSql,
@@ -4939,6 +5441,7 @@ export {
   internalError,
   invalidStoredData,
   isCanonicalLocalDate,
+  isConnectionFailureReason,
   isEnumType,
   isExpressionIndex,
   isImplicitManyToManyRelation,
@@ -4950,17 +5453,20 @@ export {
   isSqlObjectDefinition,
   isSqlObjectIdentity,
   isToastStorageKey,
+  isUnknownNameRefusal,
   jsonSchemaRefIssue,
   jsonTypeAnnotationIssue,
   jsonTypeAnnotationRef,
   localDateCheckName,
   mergeExtensionDeclarations,
   modelSqlNamespace,
+  modelUniqueKeys,
   mysqlIndexKeyWidth,
   mysqlRowRuleMessageByteLength,
   normalizeJsonSchemaRef,
   normalizeRowRules,
   normalizeValidatorRef,
+  normalizeWhere,
   parseTableStorageValue,
   postgresGeneratedObjectName,
   predicateCapabilityIssue,
@@ -4984,12 +5490,14 @@ export {
   rowRuleTriggerName,
   scalarListDefault,
   schemaRowRuleIdentities,
+  sealSchemaIR,
   serializeJsonDefault,
   setDefaultRelationOf,
   sqlNamespaceIssue,
   sqlObjectKey,
   sqlObjectNamespace,
   sqliteRowRuleConstraint,
+  suggestName,
   tableStorageEntries,
   tableStorageKeyFromPrisma,
   tableStoragePrismaKey,
@@ -5001,7 +5509,8 @@ export {
   validateRlsContextIR,
   validateRowRules,
   validateSchemaIR,
-  validatorRefIssue
+  validatorRefIssue,
+  withSuggestion
 };
 
-//# debugId=61CF54A7622E428F64756E2164756E21
+//# debugId=D9E0341E199A9F8664756E2164756E21