prisma-sql 1.37.0 → 1.39.0

package/dist/index.js

@@ -41,6 +41,148 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// src/builder/shared/constants.ts
+var SQL_SEPARATORS = Object.freeze({
+  FIELD_LIST: ", ",
+  CONDITION_AND: " AND ",
+  CONDITION_OR: " OR ",
+  ORDER_BY: ", "
+});
+var SQL_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "select",
+  "from",
+  "where",
+  "and",
+  "or",
+  "not",
+  "in",
+  "like",
+  "between",
+  "order",
+  "by",
+  "group",
+  "having",
+  "limit",
+  "offset",
+  "join",
+  "inner",
+  "left",
+  "right",
+  "outer",
+  "on",
+  "as",
+  "table",
+  "column",
+  "index",
+  "user",
+  "users",
+  "values",
+  "update",
+  "insert",
+  "delete",
+  "create",
+  "drop",
+  "alter",
+  "truncate",
+  "grant",
+  "revoke",
+  "exec",
+  "execute",
+  "union",
+  "intersect",
+  "except",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "null",
+  "true",
+  "false",
+  "is",
+  "exists",
+  "all",
+  "any",
+  "some"
+]);
+var SQL_KEYWORDS = SQL_RESERVED_WORDS;
+var DEFAULT_WHERE_CLAUSE = "1=1";
+var SPECIAL_FIELDS = Object.freeze({
+  ID: "id"
+});
+var SQL_TEMPLATES = Object.freeze({
+  PUBLIC_SCHEMA: "public",
+  WHERE: "WHERE",
+  SELECT: "SELECT",
+  FROM: "FROM",
+  ORDER_BY: "ORDER BY",
+  GROUP_BY: "GROUP BY",
+  HAVING: "HAVING",
+  LIMIT: "LIMIT",
+  OFFSET: "OFFSET",
+  COUNT_ALL: "COUNT(*)",
+  AS: "AS",
+  DISTINCT_ON: "DISTINCT ON",
+  IS_NULL: "IS NULL",
+  IS_NOT_NULL: "IS NOT NULL",
+  LIKE: "LIKE",
+  AND: "AND",
+  OR: "OR",
+  NOT: "NOT"
+});
+var SCHEMA_PREFIXES = Object.freeze({
+  INTERNAL: "@",
+  COMMENT: "//"
+});
+var Ops = Object.freeze({
+  EQUALS: "equals",
+  NOT: "not",
+  GT: "gt",
+  GTE: "gte",
+  LT: "lt",
+  LTE: "lte",
+  IN: "in",
+  NOT_IN: "notIn",
+  CONTAINS: "contains",
+  STARTS_WITH: "startsWith",
+  ENDS_WITH: "endsWith",
+  HAS: "has",
+  HAS_SOME: "hasSome",
+  HAS_EVERY: "hasEvery",
+  IS_EMPTY: "isEmpty",
+  PATH: "path",
+  STRING_CONTAINS: "string_contains",
+  STRING_STARTS_WITH: "string_starts_with",
+  STRING_ENDS_WITH: "string_ends_with"
+});
+var LogicalOps = Object.freeze({
+  AND: "AND",
+  OR: "OR",
+  NOT: "NOT"
+});
+var RelationFilters = Object.freeze({
+  SOME: "some",
+  EVERY: "every",
+  NONE: "none"
+});
+var Modes = Object.freeze({
+  INSENSITIVE: "insensitive",
+  DEFAULT: "default"
+});
+var Wildcards = Object.freeze({
+  [Ops.CONTAINS]: (v) => `%${v}%`,
+  [Ops.STARTS_WITH]: (v) => `${v}%`,
+  [Ops.ENDS_WITH]: (v) => `%${v}`
+});
+var REGEX_CACHE = {
+  VALID_IDENTIFIER: /^[a-z_][a-z0-9_]*$/
+};
+var LIMITS = Object.freeze({
+  MAX_QUERY_DEPTH: 50,
+  MAX_ARRAY_SIZE: 1e4,
+  MAX_STRING_LENGTH: 1e4
+});
+
 // src/sql-builder-dialect.ts
 var globalDialect = "postgres";
 function setGlobalDialect(dialect) {
@@ -195,7 +337,7 @@ function getArrayType(prismaType, dialect) {
     case "DateTime":
       return "timestamptz[]";
     default:
-      return "text[]";
+      return `"${baseType}"[]`;
   }
 }
 function jsonAgg(content, dialect) {
@@ -222,148 +364,6 @@ function prepareArrayParam(value, dialect) {
   return JSON.stringify(value);
 }
 
-// src/builder/shared/constants.ts
-var SQL_SEPARATORS = Object.freeze({
-  FIELD_LIST: ", ",
-  CONDITION_AND: " AND ",
-  CONDITION_OR: " OR ",
-  ORDER_BY: ", "
-});
-var SQL_RESERVED_WORDS = /* @__PURE__ */ new Set([
-  "select",
-  "from",
-  "where",
-  "and",
-  "or",
-  "not",
-  "in",
-  "like",
-  "between",
-  "order",
-  "by",
-  "group",
-  "having",
-  "limit",
-  "offset",
-  "join",
-  "inner",
-  "left",
-  "right",
-  "outer",
-  "on",
-  "as",
-  "table",
-  "column",
-  "index",
-  "user",
-  "users",
-  "values",
-  "update",
-  "insert",
-  "delete",
-  "create",
-  "drop",
-  "alter",
-  "truncate",
-  "grant",
-  "revoke",
-  "exec",
-  "execute",
-  "union",
-  "intersect",
-  "except",
-  "case",
-  "when",
-  "then",
-  "else",
-  "end",
-  "null",
-  "true",
-  "false",
-  "is",
-  "exists",
-  "all",
-  "any",
-  "some"
-]);
-var SQL_KEYWORDS = SQL_RESERVED_WORDS;
-var DEFAULT_WHERE_CLAUSE = "1=1";
-var SPECIAL_FIELDS = Object.freeze({
-  ID: "id"
-});
-var SQL_TEMPLATES = Object.freeze({
-  PUBLIC_SCHEMA: "public",
-  WHERE: "WHERE",
-  SELECT: "SELECT",
-  FROM: "FROM",
-  ORDER_BY: "ORDER BY",
-  GROUP_BY: "GROUP BY",
-  HAVING: "HAVING",
-  LIMIT: "LIMIT",
-  OFFSET: "OFFSET",
-  COUNT_ALL: "COUNT(*)",
-  AS: "AS",
-  DISTINCT_ON: "DISTINCT ON",
-  IS_NULL: "IS NULL",
-  IS_NOT_NULL: "IS NOT NULL",
-  LIKE: "LIKE",
-  AND: "AND",
-  OR: "OR",
-  NOT: "NOT"
-});
-var SCHEMA_PREFIXES = Object.freeze({
-  INTERNAL: "@",
-  COMMENT: "//"
-});
-var Ops = Object.freeze({
-  EQUALS: "equals",
-  NOT: "not",
-  GT: "gt",
-  GTE: "gte",
-  LT: "lt",
-  LTE: "lte",
-  IN: "in",
-  NOT_IN: "notIn",
-  CONTAINS: "contains",
-  STARTS_WITH: "startsWith",
-  ENDS_WITH: "endsWith",
-  HAS: "has",
-  HAS_SOME: "hasSome",
-  HAS_EVERY: "hasEvery",
-  IS_EMPTY: "isEmpty",
-  PATH: "path",
-  STRING_CONTAINS: "string_contains",
-  STRING_STARTS_WITH: "string_starts_with",
-  STRING_ENDS_WITH: "string_ends_with"
-});
-var LogicalOps = Object.freeze({
-  AND: "AND",
-  OR: "OR",
-  NOT: "NOT"
-});
-var RelationFilters = Object.freeze({
-  SOME: "some",
-  EVERY: "every",
-  NONE: "none"
-});
-var Modes = Object.freeze({
-  INSENSITIVE: "insensitive",
-  DEFAULT: "default"
-});
-var Wildcards = Object.freeze({
-  [Ops.CONTAINS]: (v) => `%${v}%`,
-  [Ops.STARTS_WITH]: (v) => `${v}%`,
-  [Ops.ENDS_WITH]: (v) => `%${v}`
-});
-var REGEX_CACHE = {
-  VALID_IDENTIFIER: /^[a-z_][a-z0-9_]*$/
-};
-var LIMITS = Object.freeze({
-  MAX_QUERY_DEPTH: 50,
-  MAX_ARRAY_SIZE: 1e4,
-  MAX_STRING_LENGTH: 1e4
-});
-
 // src/builder/shared/validators/type-guards.ts
 function isNotNullish(value) {
   return value !== null && value !== void 0;
@@ -449,6 +449,19 @@ function getRelationFieldSet(model) {
   RELATION_SET_CACHE.set(model, s);
   return s;
 }
+var COLUMN_MAP_CACHE = /* @__PURE__ */ new WeakMap();
+function getColumnMap(model) {
+  const cached = COLUMN_MAP_CACHE.get(model);
+  if (cached) return cached;
+  const map = /* @__PURE__ */ new Map();
+  for (const f of model.fields) {
+    if (!f.isRelation) {
+      map.set(f.name, f.dbName || f.name);
+    }
+  }
+  COLUMN_MAP_CACHE.set(model, map);
+  return map;
+}
 
 // src/builder/shared/validators/sql-validators.ts
 function isValidWhereClause(clause) {
@@ -836,27 +849,10 @@ function quote(id) {
   }
   return id;
 }
-function pickDbFieldName(field) {
-  const candidates = [
-    field == null ? void 0 : field.dbName,
-    field == null ? void 0 : field.columnName,
-    field == null ? void 0 : field.databaseName,
-    field == null ? void 0 : field.mappedName
-  ];
-  for (const c of candidates) {
-    if (typeof c === "string") {
-      const s = c.trim();
-      if (s.length > 0) return s;
-    }
-  }
-  return void 0;
-}
 function resolveColumnName(model, fieldName) {
-  var _a;
   if (!model) return fieldName;
-  const f = model.fields.find((x) => (x == null ? void 0 : x.name) === fieldName);
-  if (!f) return fieldName;
-  return (_a = pickDbFieldName(f)) != null ? _a : fieldName;
+  const columnMap = getColumnMap(model);
+  return columnMap.get(fieldName) || fieldName;
 }
 function quoteColumn(model, fieldName) {
   return quote(resolveColumnName(model, fieldName));
@@ -1014,1570 +1010,1570 @@ function joinCondition(field, parentModel, childModel, parentAlias, childAlias)
 function getModelByName(schemas, name) {
   return schemas.find((m) => m.name === name);
 }
-function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
-  const entries = Object.entries(val).filter(
-    ([k, v]) => k !== "mode" && v !== void 0
-  );
-  if (entries.length === 0) return "";
-  const clauses = [];
-  for (const [subOp, subVal] of entries) {
-    const sub = buildOp(expr, subOp, subVal, params, dialect);
-    if (sub && sub.trim().length > 0) clauses.push(`(${sub})`);
-  }
-  if (clauses.length === 0) return "";
-  if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
-  return `${SQL_TEMPLATES.NOT} (${clauses.join(separator)})`;
-}
-function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect) {
-  if (val === void 0) return "";
-  if (val === null) {
-    return handleNullValue(expr, op);
-  }
-  if (op === Ops.NOT && isPlainObject(val)) {
-    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
-  }
-  if (op === Ops.NOT) {
-    const placeholder = params.addAuto(val);
-    return `${expr} <> ${placeholder}`;
+function normalizeIntLike(name, v, opts = {}) {
+  var _a, _b;
+  if (!isNotNullish(v)) return void 0;
+  if (isDynamicParameter(v)) return v;
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
+    throw new Error(`${name} must be an integer`);
   }
-  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && isNotNullish(dialect)) {
-    const placeholder = params.addAuto(val);
-    return caseInsensitiveEquals(expr, placeholder);
+  const min = (_a = opts.min) != null ? _a : 0;
+  const allowZero = (_b = opts.allowZero) != null ? _b : true;
+  if (!allowZero && v === 0) {
+    throw new Error(`${name} must be > 0`);
   }
-  const STRING_LIKE_OPS = /* @__PURE__ */ new Set([
-    Ops.CONTAINS,
-    Ops.STARTS_WITH,
-    Ops.ENDS_WITH
-  ]);
-  if (STRING_LIKE_OPS.has(op)) {
-    if (!isNotNullish(dialect)) {
-      throw createError(`Like operators require a SQL dialect`, {
-        operator: op
-      });
-    }
-    return handleLikeOperator(expr, op, val, params, mode, dialect);
+  if (v < min) {
+    throw new Error(`${name} must be >= ${min}`);
   }
-  if (op === Ops.IN || op === Ops.NOT_IN) {
-    if (!isNotNullish(dialect)) {
-      throw createError(`IN operators require a SQL dialect`, { operator: op });
-    }
-    return handleInOperator(expr, op, val, params, dialect);
+  if (typeof opts.max === "number" && v > opts.max) {
+    throw new Error(`${name} must be <= ${opts.max}`);
   }
-  return handleComparisonOperator(expr, op, val, params);
-}
-function handleNullValue(expr, op) {
-  if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
-  if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
-  throw createError(`Operator '${op}' doesn't support null`, { operator: op });
-}
-function normalizeMode(v) {
-  if (v === Modes.INSENSITIVE) return Modes.INSENSITIVE;
-  if (v === Modes.DEFAULT) return Modes.DEFAULT;
-  return void 0;
+  return v;
 }
-function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
-  const innerMode = normalizeMode(val.mode);
-  const effectiveMode = innerMode != null ? innerMode : outerMode;
-  return buildNotComposite(
-    expr,
-    val,
-    params,
-    dialect,
-    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, effectiveMode, fieldType, d),
-    ` ${SQL_TEMPLATES.AND} `
-  );
+function scopeName(scope, dynamicName) {
+  const s = String(scope).trim();
+  const dn = String(dynamicName).trim();
+  if (s.length === 0) return dn;
+  return `${s}:${dn}`;
 }
-function buildDynamicLikePattern(op, placeholder, dialect) {
-  if (dialect === "postgres") {
-    switch (op) {
-      case Ops.CONTAINS:
-        return `('%' || ${placeholder} || '%')`;
-      case Ops.STARTS_WITH:
-        return `(${placeholder} || '%')`;
-      case Ops.ENDS_WITH:
-        return `('%' || ${placeholder})`;
-      default:
-        return placeholder;
-    }
-  }
-  switch (op) {
-    case Ops.CONTAINS:
-      return `('%' || ${placeholder} || '%')`;
-    case Ops.STARTS_WITH:
-      return `(${placeholder} || '%')`;
-    case Ops.ENDS_WITH:
-      return `('%' || ${placeholder})`;
-    default:
-      return placeholder;
+function addAutoScoped(params, value, scope) {
+  if (isDynamicParameter(value)) {
+    const dn = extractDynamicName(value);
+    return params.add(void 0, scopeName(scope, dn));
   }
+  return params.add(value);
 }
-function handleLikeOperator(expr, op, val, params, mode, dialect) {
-  if (val === void 0) return "";
-  if (isDynamicParameter(val)) {
-    const placeholder2 = params.addAuto(val);
-    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
-    if (mode === Modes.INSENSITIVE) {
-      return caseInsensitiveLike(expr, patternExpr, dialect);
-    }
-    return `${expr} ${SQL_TEMPLATES.LIKE} ${patternExpr}`;
+
+// src/builder/shared/order-by-utils.ts
+var flipNulls = (v) => {
+  const s = String(v).toLowerCase();
+  if (s === "first") return "last";
+  if (s === "last") return "first";
+  return v;
+};
+var flipSortString = (v) => {
+  if (typeof v !== "string") return v;
+  const s = v.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return v;
+};
+var getNextSort = (sortRaw) => {
+  if (typeof sortRaw !== "string") return sortRaw;
+  const s = sortRaw.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return sortRaw;
+};
+var flipObjectSort = (obj) => {
+  const sortRaw = obj.sort;
+  const out = __spreadProps(__spreadValues({}, obj), { sort: getNextSort(sortRaw) });
+  const nullsRaw = obj.nulls;
+  if (typeof nullsRaw === "string") {
+    out.nulls = flipNulls(nullsRaw);
   }
-  const placeholder = params.add(Wildcards[op](String(val)));
-  if (mode === Modes.INSENSITIVE) {
-    return caseInsensitiveLike(expr, placeholder, dialect);
+  return out;
+};
+var flipValue = (v) => {
+  if (typeof v === "string") return flipSortString(v);
+  if (isPlainObject(v)) return flipObjectSort(v);
+  return v;
+};
+var assertSingleFieldObject = (item) => {
+  if (!isPlainObject(item)) {
+    throw new Error("orderBy array entries must be objects");
   }
-  return `${expr} ${SQL_TEMPLATES.LIKE} ${placeholder}`;
-}
-function handleInOperator(expr, op, val, params, dialect) {
-  if (val === void 0) return "";
-  if (isDynamicParameter(val)) {
-    const placeholder2 = params.addAuto(val);
-    return op === Ops.IN ? inArray(expr, placeholder2, dialect) : notInArray(expr, placeholder2, dialect);
+  const entries = Object.entries(item);
+  if (entries.length !== 1) {
+    throw new Error("orderBy array entries must have exactly one field");
   }
-  if (!Array.isArray(val)) {
-    throw createError(`IN operators require array value`, {
-      operator: op,
-      value: val
-    });
+  return entries[0];
+};
+var flipOrderByArray = (orderBy) => {
+  return orderBy.map((item) => {
+    const [k, v] = assertSingleFieldObject(item);
+    return { [k]: flipValue(v) };
+  });
+};
+var flipOrderByObject = (orderBy) => {
+  const out = {};
+  for (const [k, v] of Object.entries(orderBy)) {
+    out[k] = flipValue(v);
   }
-  if (val.length === 0) {
-    return op === Ops.IN ? "0=1" : "1=1";
+  return out;
+};
+function reverseOrderByInput(orderBy) {
+  if (!isNotNullish(orderBy)) return orderBy;
+  if (Array.isArray(orderBy)) {
+    return flipOrderByArray(orderBy);
   }
-  const paramValue = prepareArrayParam(val, dialect);
-  const placeholder = params.add(paramValue);
-  return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
+  if (isPlainObject(orderBy)) {
+    return flipOrderByObject(orderBy);
+  }
+  throw new Error("orderBy must be an object or array of objects");
 }
-function handleComparisonOperator(expr, op, val, params) {
-  if (val === void 0) return "";
-  const COMPARISON_OPS2 = {
-    [Ops.EQUALS]: "=",
-    [Ops.GT]: ">",
-    [Ops.GTE]: ">=",
-    [Ops.LT]: "<",
-    [Ops.LTE]: "<="
-  };
-  const sqlOp = COMPARISON_OPS2[op];
-  if (!sqlOp) {
-    throw createError(`Unsupported scalar operator: ${op}`, { operator: op });
-  }
-  const placeholder = params.addAuto(val);
-  return `${expr} ${sqlOp} ${placeholder}`;
-}
-function buildArrayParam(val, params, dialect) {
-  if (isDynamicParameter(val)) {
-    return params.addAuto(val);
+var normalizePairs = (pairs, parseValue) => {
+  return pairs.map(([field, rawValue]) => {
+    const parsed = parseValue(rawValue, field);
+    return {
+      [field]: parsed.nulls !== void 0 ? { sort: parsed.direction, nulls: parsed.nulls } : parsed.direction
+    };
+  });
+};
+function normalizeOrderByInput(orderBy, parseValue) {
+  if (!isNotNullish(orderBy)) return [];
+  if (Array.isArray(orderBy)) {
+    const pairs = orderBy.map(assertSingleFieldObject);
+    return normalizePairs(pairs, parseValue);
   }
-  if (!Array.isArray(val)) {
-    throw createError(`Array operation requires array value`, { value: val });
+  if (isPlainObject(orderBy)) {
+    return normalizePairs(Object.entries(orderBy), parseValue);
   }
-  const paramValue = prepareArrayParam(val, dialect);
-  return params.add(paramValue);
+  throw new Error("orderBy must be an object or array of objects");
 }
-function buildArrayOperator(expr, op, val, params, fieldType, dialect) {
-  if (val === void 0) return "";
-  if (val === null) {
-    if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
-    if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
-  }
-  const cast = getArrayType(fieldType, dialect);
-  if (op === Ops.EQUALS) {
-    return handleArrayEquals(expr, val, params, cast, dialect);
-  }
-  if (op === Ops.NOT) {
-    return handleArrayNot(expr, val, params, cast, dialect);
-  }
-  switch (op) {
-    case Ops.HAS:
-      return handleArrayHas(expr, val, params, cast, dialect);
-    case Ops.HAS_SOME:
-      return handleArrayHasSome(expr, val, params, cast, dialect);
-    case Ops.HAS_EVERY:
-      return handleArrayHasEvery(expr, val, params, cast, dialect);
-    case Ops.IS_EMPTY:
-      return handleArrayIsEmpty(expr, val, dialect);
-    default:
-      throw createError(`Unknown array operator: ${op}`, { operator: op });
-  }
+
+// src/builder/pagination.ts
+var MAX_LIMIT_OFFSET = 2147483647;
+function parseDirectionRaw(raw, errorLabel) {
+  const s = String(raw).toLowerCase();
+  if (s === "asc" || s === "desc") return s;
+  throw new Error(`Invalid ${errorLabel}: ${raw}`);
 }
-function handleArrayEquals(expr, val, params, cast, dialect) {
-  if (val === void 0) return "";
-  if (isEmptyArray(val)) {
-    return arrayIsEmpty(expr, dialect);
+function parseNullsRaw(raw, errorLabel) {
+  if (!isNotNullish(raw)) return void 0;
+  const s = String(raw).toLowerCase();
+  if (s === "first" || s === "last") return s;
+  throw new Error(`Invalid ${errorLabel}: ${raw}`);
+}
+function requireOrderByObject(v, errorPrefix) {
+  if (!isPlainObject(v) || !("sort" in v)) {
+    throw new Error(`${errorPrefix} must be 'asc' | 'desc' or { sort, nulls? }`);
   }
-  const placeholder = buildArrayParam(val, params, dialect);
-  return arrayEquals(expr, placeholder, cast, dialect);
+  return v;
 }
-function handleArrayNot(expr, val, params, cast, dialect) {
-  if (val === void 0) return "";
-  let target = val;
-  if (isPlainObject(val)) {
-    const entries = Object.entries(val).filter(([, v]) => v !== void 0);
-    if (entries.length === 1 && entries[0][0] === Ops.EQUALS) {
-      target = entries[0][1];
-    } else {
-      throw createError(`Array NOT only supports { equals: ... } shape`, {
-        operator: Ops.NOT,
-        value: val
-      });
+function assertAllowedOrderByKeys(obj, fieldName) {
+  const allowed = /* @__PURE__ */ new Set(["sort", "nulls"]);
+  for (const k of Object.keys(obj)) {
+    if (!allowed.has(k)) {
+      throw new Error(
+        fieldName ? `Unsupported orderBy key '${k}' for field '${fieldName}'` : `Unsupported orderBy key '${k}'`
+      );
     }
   }
-  if (target === null) {
-    return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
-  }
-  if (isEmptyArray(target)) {
-    return arrayIsNotEmpty(expr, dialect);
-  }
-  const placeholder = buildArrayParam(target, params, dialect);
-  return `${SQL_TEMPLATES.NOT} (${arrayEquals(expr, placeholder, cast, dialect)})`;
 }
-function handleArrayHas(expr, val, params, cast, dialect) {
-  if (val === void 0) return "";
-  if (val === null) {
-    throw createError(`has requires scalar value`, {
-      operator: Ops.HAS,
-      value: val
-    });
-  }
-  if (!isDynamicParameter(val) && Array.isArray(val)) {
-    throw createError(`has requires scalar value (single element), not array`, {
-      operator: Ops.HAS,
-      value: val
-    });
-  }
-  if (isPlainObject(val)) {
-    throw createError(`has requires scalar value`, {
-      operator: Ops.HAS,
-      value: val
-    });
+function parseOrderByValue(v, fieldName) {
+  const errorPrefix = fieldName ? `orderBy for '${fieldName}'` : "orderBy value";
+  if (typeof v === "string") {
+    return { direction: parseDirectionRaw(v, `${errorPrefix} direction`) };
   }
-  const placeholder = params.addAuto(val);
-  return arrayContains(expr, placeholder, cast, dialect);
+  const obj = requireOrderByObject(v, errorPrefix);
+  const direction = parseDirectionRaw(obj.sort, `${errorPrefix}.sort`);
+  const nulls = parseNullsRaw(obj.nulls, `${errorPrefix}.nulls`);
+  assertAllowedOrderByKeys(obj, fieldName);
+  return { direction, nulls };
 }
-function handleArrayHasSome(expr, val, params, cast, dialect) {
-  if (val === void 0) return "";
-  if (isDynamicParameter(val)) {
-    const placeholder2 = params.addAuto(val);
-    return arrayOverlaps(expr, placeholder2, cast, dialect);
+function normalizeFiniteInteger(name, v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
+    throw new Error(`${name} must be an integer`);
   }
-  if (!Array.isArray(val)) {
-    throw createError(`hasSome requires array value`, {
-      operator: Ops.HAS_SOME,
-      value: val
-    });
+  return v;
+}
+function normalizeNonNegativeInt(name, v) {
+  if (isDynamicParameter(v)) return v;
+  const n = normalizeFiniteInteger(name, v);
+  if (n < 0) {
+    throw new Error(`${name} must be >= 0`);
   }
-  if (val.length > LIMITS.MAX_ARRAY_SIZE) {
-    throw createError(
-      `Array too large (${val.length} elements, max ${LIMITS.MAX_ARRAY_SIZE})`,
-      { operator: Ops.HAS_SOME, value: `[${val.length} items]` }
-    );
+  if (n > MAX_LIMIT_OFFSET) {
+    throw new Error(`${name} must be <= ${MAX_LIMIT_OFFSET}`);
   }
-  if (val.length === 0) return "0=1";
-  const paramValue = prepareArrayParam(val, dialect);
-  const placeholder = params.add(paramValue);
-  return arrayOverlaps(expr, placeholder, cast, dialect);
+  return n;
 }
-function handleArrayHasEvery(expr, val, params, cast, dialect) {
-  if (val === void 0) return "";
-  const placeholder = buildArrayParam(val, params, dialect);
-  return arrayContainsAll(expr, placeholder, cast, dialect);
+function hasNonNullishProp(v, key) {
+  return isPlainObject(v) && key in v && isNotNullish(v[key]);
 }
-function handleArrayIsEmpty(expr, val, dialect) {
-  if (typeof val !== "boolean") {
-    throw createError(`isEmpty requires boolean value`, {
-      operator: Ops.IS_EMPTY,
-      value: val
-    });
+function normalizeIntegerOrDynamic(name, v) {
+  if (isDynamicParameter(v)) return v;
+  return normalizeFiniteInteger(name, v);
+}
+function readSkipTake(relArgs) {
+  const hasSkip = hasNonNullishProp(relArgs, "skip");
+  const hasTake = hasNonNullishProp(relArgs, "take");
+  if (!hasSkip && !hasTake) {
+    return {
+      hasSkip: false,
+      hasTake: false,
+      skipVal: void 0,
+      takeVal: void 0
+    };
   }
-  return val === true ? arrayIsEmpty(expr, dialect) : arrayIsNotEmpty(expr, dialect);
+  const obj = relArgs;
+  const skipVal = hasSkip ? normalizeNonNegativeInt("skip", obj.skip) : void 0;
+  const takeVal = hasTake ? normalizeIntegerOrDynamic("take", obj.take) : void 0;
+  return { hasSkip, hasTake, skipVal, takeVal };
 }
-
-// src/builder/where/operators-json.ts
-var SAFE_JSON_PATH_SEGMENT = /^[a-zA-Z_]\w*$/;
-function validateJsonPathSegments(segments) {
-  for (const segment of segments) {
-    if (typeof segment !== "string") {
-      throw createError("JSON path segments must be strings", {
-        operator: Ops.PATH,
-        value: segment
-      });
+function buildOrderByFragment(entries, alias, dialect, model) {
+  if (entries.length === 0) return "";
+  const out = [];
+  for (const e of entries) {
+    const dir = e.direction.toUpperCase();
+    const c = col(alias, e.field, model);
+    if (dialect === "postgres") {
+      const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
+      out.push(`${c} ${dir}${nulls}`);
+      continue;
     }
-    if (!SAFE_JSON_PATH_SEGMENT.test(segment)) {
-      throw createError(
-        `Invalid JSON path segment: '${segment}'. Must be alphanumeric with underscores, starting with letter or underscore.`,
-        { operator: Ops.PATH, value: segment }
-      );
+    if (isNotNullish(e.nulls)) {
+      const isNullExpr = `(${c} IS NULL)`;
+      const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
+      out.push(`${isNullExpr} ${nullRankDir}`);
+      out.push(`${c} ${dir}`);
+      continue;
     }
+    out.push(`${c} ${dir}`);
   }
+  return out.join(SQL_SEPARATORS.ORDER_BY);
 }
-function buildJsonOperator(expr, op, val, params, dialect) {
-  if (val === void 0) return "";
-  if (op === Ops.PATH && isPlainObject(val) && "path" in val) {
-    return handleJsonPath(expr, val, params, dialect);
-  }
-  const jsonWildcards = {
-    [Ops.STRING_CONTAINS]: (v) => `%${v}%`,
-    [Ops.STRING_STARTS_WITH]: (v) => `${v}%`,
-    [Ops.STRING_ENDS_WITH]: (v) => `%${v}`
-  };
-  if (op in jsonWildcards) {
-    return handleJsonWildcard(expr, op, val, params, jsonWildcards, dialect);
+function defaultNullsFor(dialect, direction) {
+  if (dialect === "postgres") {
+    return direction === "asc" ? "last" : "first";
   }
-  throw createError(`Unsupported JSON operator: ${op}`, { operator: op });
+  return direction === "asc" ? "first" : "last";
 }
-function handleJsonPath(expr, val, params, dialect) {
-  const v = val;
-  if (!Array.isArray(v.path)) {
-    throw createError("JSON path must be an array", { operator: Ops.PATH });
-  }
-  if (v.path.length === 0) {
-    throw createError("JSON path cannot be empty", { operator: Ops.PATH });
-  }
-  validateJsonPathSegments(v.path);
-  const pathExpr = dialect === "sqlite" ? params.add(`$.${v.path.join(".")}`) : params.add(v.path);
-  const rawOps = [
-    ["=", v.equals],
-    [">", v.gt],
-    [">=", v.gte],
-    ["<", v.lt],
-    ["<=", v.lte]
-  ];
-  const ops = rawOps.filter(
-    ([, value]) => value !== void 0
-  );
-  if (ops.length === 0) {
-    throw createError("JSON path query missing comparison operator", {
-      operator: Ops.PATH
-    });
+function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
+  const existing = /* @__PURE__ */ new Map();
+  for (const e of orderEntries) existing.set(e.field, e);
+  const out = [...orderEntries];
+  for (const [field] of cursorEntries) {
+    if (!existing.has(field)) {
+      out.push({ field, direction: "asc" });
+      existing.set(field, out[out.length - 1]);
+    }
   }
+  return out;
+}
+function buildCursorFilterParts(cursor, cursorAlias, params, model) {
+  const entries = Object.entries(cursor);
+  if (entries.length === 0) {
+    throw new Error("cursor must have at least one field");
+  }
+  const placeholdersByField = /* @__PURE__ */ new Map();
   const parts = [];
-  for (const [sqlOp, value] of ops) {
+  for (const [field, value] of entries) {
+    const c = `${cursorAlias}.${quote(field)}`;
     if (value === null) {
-      const base2 = jsonExtractText(expr, pathExpr, dialect);
-      parts.push(`${base2} ${SQL_TEMPLATES.IS_NULL}`);
+      parts.push(`${c} IS NULL`);
       continue;
     }
-    const valPh = params.add(value);
-    const base = typeof value === "number" ? jsonExtractNumeric(expr, pathExpr, dialect) : jsonExtractText(expr, pathExpr, dialect);
-    parts.push(`${base} ${sqlOp} ${valPh}`);
-  }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
-}
-function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
-  if (!isNotNullish(val)) {
-    throw createError(`JSON string operator requires non-null value`, {
-      operator: op,
-      value: val
-    });
-  }
-  if (isPlainObject(val) || Array.isArray(val)) {
-    throw createError(`JSON string operator requires scalar value`, {
-      operator: op,
-      value: val
-    });
-  }
-  const strVal = String(val);
-  if (strVal.length > LIMITS.MAX_STRING_LENGTH) {
-    throw createError(
-      `String too long (${strVal.length} chars, max ${LIMITS.MAX_STRING_LENGTH})`,
-      { operator: op }
-    );
+    const ph = addAutoScoped(params, value, `cursor.filter.${field}`);
+    placeholdersByField.set(field, ph);
+    parts.push(`${c} = ${ph}`);
   }
-  const placeholder = params.add(wildcards[op](strVal));
-  const jsonText = jsonToText(expr, dialect);
-  return caseInsensitiveLike(jsonText, placeholder, dialect);
+  return {
+    whereSql: parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`,
+    placeholdersByField
+  };
 }
-
-// src/builder/where/relations.ts
-var NO_JOINS = Object.freeze([]);
-function isListRelation(fieldType) {
-  return typeof fieldType === "string" && fieldType.endsWith("[]");
+function cursorValueExpr(tableName, cursorAlias, cursorWhereSql, field, model) {
+  const colName = quote(field);
+  return `(SELECT ${cursorAlias}.${colName} ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
 }
-function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join, wantNull) {
-  const isLocal = field.isForeignKeyLocal === true;
-  const fkFields = normalizeKeyList(field.foreignKey);
-  if (isLocal) {
-    if (fkFields.length === 0) {
-      throw createError(`Relation '${field.name}' is missing foreignKey`, {
-        field: field.name
-      });
-    }
-    const parts = fkFields.map((fk) => {
-      const safe = fk.replace(/"/g, '""');
-      const expr = `${parentAlias}."${safe}"`;
-      return wantNull ? `${expr} ${SQL_TEMPLATES.IS_NULL}` : `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
-    });
-    if (parts.length === 1) return parts[0];
-    return wantNull ? `(${parts.join(" OR ")})` : `(${parts.join(" AND ")})`;
-  }
-  const existsSql = `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias} ${SQL_TEMPLATES.WHERE} ${join})`;
-  return wantNull ? `${SQL_TEMPLATES.NOT} ${existsSql}` : existsSql;
+function buildCursorRowExistsExpr(tableName, cursorAlias, cursorWhereSql) {
+  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
 }
-function buildToOneExistsMatch(relTable, relAlias, join, sub) {
-  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
-  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+function buildCursorEqualityExpr(columnExpr, valueExpr) {
+  return `((${valueExpr} IS NULL AND ${columnExpr} IS NULL) OR (${valueExpr} IS NOT NULL AND ${columnExpr} = ${valueExpr}))`;
 }
-function buildToOneNotExistsMatch(relTable, relAlias, join, sub) {
-  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
-  return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${sub.clause})`;
+function buildCursorInequalityExpr(columnExpr, direction, nulls, valueExpr) {
+  const op = direction === "asc" ? ">" : "<";
+  if (nulls === "first") {
+    return `(CASE WHEN ${valueExpr} IS NULL THEN (${columnExpr} IS NOT NULL) ELSE (${columnExpr} ${op} ${valueExpr}) END)`;
+  }
+  return `(CASE WHEN ${valueExpr} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${valueExpr}) OR (${columnExpr} IS NULL)) END)`;
 }
-function buildListRelationFilters(args) {
-  const {
-    fieldName,
-    value,
-    ctx,
-    whereBuilder,
-    relModel,
-    relTable,
-    relAlias,
-    join
-  } = args;
-  const noneValue = value[RelationFilters.NONE];
-  if (noneValue !== void 0 && noneValue !== null) {
-    const sub = whereBuilder.build(noneValue, __spreadProps(__spreadValues({}, ctx), {
-      alias: relAlias,
-      model: relModel,
-      path: [...ctx.path, fieldName, RelationFilters.NONE],
-      isSubquery: true,
-      depth: ctx.depth + 1
-    }));
-    const isEmptyFilter = isPlainObject(noneValue) && Object.keys(noneValue).length === 0;
-    const canOptimize = !ctx.isSubquery && isEmptyFilter && sub.clause === DEFAULT_WHERE_CLAUSE && sub.joins.length === 0;
-    if (canOptimize) {
-      const checkField = relModel.fields.find(
-        (f) => !f.isRelation && f.isRequired && f.name !== "id"
-      ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
-      if (checkField) {
-        const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join}`;
-        const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
-        return Object.freeze({
-          clause: whereClause,
-          joins: [leftJoinSql]
-        });
-      }
+function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params, model) {
+  const parts = [];
+  for (const [field, value] of Object.entries(cursor)) {
+    const c = col(outerAlias, field, model);
+    if (value === null) {
+      parts.push(`${c} IS NULL`);
+      continue;
+    }
+    const existing = placeholdersByField.get(field);
+    if (typeof existing === "string" && existing.length > 0) {
+      parts.push(`${c} = ${existing}`);
+      continue;
     }
+    const ph = addAutoScoped(params, value, `cursor.outerMatch.${field}`);
+    parts.push(`${c} = ${ph}`);
   }
-  const filters = [
-    {
-      key: RelationFilters.SOME,
-      wrap: (c, j) => `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${c})`
-    },
-    {
-      key: RelationFilters.EVERY,
-      wrap: (c, j) => `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${SQL_TEMPLATES.NOT} (${c}))`
-    },
-    {
-      key: RelationFilters.NONE,
-      wrap: (c, j) => {
-        const condition = c === DEFAULT_WHERE_CLAUSE ? "" : ` ${SQL_TEMPLATES.AND} ${c}`;
-        return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join}${condition})`;
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function buildOrderEntries(orderBy) {
+  const normalized = normalizeOrderByInput(orderBy, parseOrderByValue);
+  const entries = [];
+  for (const item of normalized) {
+    for (const [field, value] of Object.entries(item)) {
+      if (typeof value === "string") {
+        entries.push({ field, direction: value });
+      } else {
+        entries.push({
+          field,
+          direction: value.sort,
+          nulls: value.nulls
+        });
       }
     }
-  ];
-  const clauses = [];
-  for (const { key, wrap } of filters) {
-    const raw = value[key];
-    if (raw === void 0 || raw === null) continue;
-    const sub = whereBuilder.build(raw, __spreadProps(__spreadValues({}, ctx), {
-      alias: relAlias,
-      model: relModel,
-      path: [...ctx.path, fieldName, key],
-      isSubquery: true,
-      depth: ctx.depth + 1
-    }));
-    const j = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
-    clauses.push(wrap(sub.clause, j));
-  }
-  if (clauses.length === 0) {
-    throw createError(
-      `List relation '${fieldName}' requires one of { some, every, none }`,
-      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
-    );
   }
-  return Object.freeze({
-    clause: clauses.join(SQL_SEPARATORS.CONDITION_AND),
-    joins: NO_JOINS
-  });
+  return entries;
 }
-function buildToOneRelationFilters(args) {
-  const {
-    fieldName,
-    value,
-    ctx,
-    whereBuilder,
-    field,
-    relModel,
-    relTable,
-    relAlias,
-    join
-  } = args;
-  const hasSomeEveryNone = isNotNullish(value[RelationFilters.SOME]) || isNotNullish(value[RelationFilters.EVERY]) || isNotNullish(value[RelationFilters.NONE]);
-  if (hasSomeEveryNone) {
-    throw createError(
-      `To-one relation '${fieldName}' does not support { some, every, none }; use { is, isNot }`,
-      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
-    );
-  }
-  const hasIs = Object.prototype.hasOwnProperty.call(value, "is");
-  const hasIsNot = Object.prototype.hasOwnProperty.call(value, "isNot");
-  let filterKey;
-  let filterVal;
-  if (hasIs) {
-    filterKey = "is";
-    filterVal = value.is;
-  } else if (hasIsNot) {
-    filterKey = "isNot";
-    filterVal = value.isNot;
-  } else {
-    filterKey = "is";
-    filterVal = value;
+function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
+  var _a;
+  const d = dialect != null ? dialect : getGlobalDialect();
+  const cursorEntries = Object.entries(cursor);
+  if (cursorEntries.length === 0) {
+    throw new Error("cursor must have at least one field");
   }
-  if (filterVal === void 0) {
-    return Object.freeze({
-      clause: DEFAULT_WHERE_CLAUSE,
-      joins: NO_JOINS
+  const cursorAlias = "__tp_cursor_src";
+  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, cursorAlias, params);
+  let orderEntries = buildOrderEntries(orderBy);
+  if (orderEntries.length === 0) {
+    orderEntries = cursorEntries.map(([field]) => ({
+      field,
+      direction: "asc"
+    }));
+  } else {
+    orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
+  }
+  const existsExpr = buildCursorRowExistsExpr(
+    tableName,
+    cursorAlias,
+    cursorWhereSql
+  );
+  const outerCursorMatch = buildOuterCursorMatch(
+    cursor,
+    alias,
+    placeholdersByField,
+    params,
+    model
+  );
+  const orClauses = [];
+  for (let level = 0; level < orderEntries.length; level++) {
+    const andParts = [];
+    for (let i = 0; i < level; i++) {
+      const e2 = orderEntries[i];
+      const c2 = col(alias, e2.field, model);
+      const v2 = cursorValueExpr(
+        tableName,
+        cursorAlias,
+        cursorWhereSql,
+        e2.field);
+      andParts.push(buildCursorEqualityExpr(c2, v2));
+    }
+    const e = orderEntries[level];
+    const c = col(alias, e.field, model);
+    const v = cursorValueExpr(
+      tableName,
+      cursorAlias,
+      cursorWhereSql,
+      e.field);
+    const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
+    andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, v));
+    orClauses.push(`(${andParts.join(SQL_SEPARATORS.CONDITION_AND)})`);
+  }
+  const exclusive = orClauses.join(SQL_SEPARATORS.CONDITION_OR);
+  return `(${existsExpr} ${SQL_SEPARATORS.CONDITION_AND} ((${exclusive})${SQL_SEPARATORS.CONDITION_OR}(${outerCursorMatch})))`;
+}
+function buildOrderBy(orderBy, alias, dialect, model) {
+  const entries = buildOrderEntries(orderBy);
+  if (entries.length === 0) return "";
+  const d = dialect != null ? dialect : getGlobalDialect();
+  return buildOrderByFragment(entries, alias, d, model);
+}
+function buildOrderByClause(args, alias, dialect, model) {
+  if (!isNotNullish(args.orderBy)) return "";
+  const result = buildOrderBy(args.orderBy, alias, dialect, model);
+  if (!isNonEmptyString(result)) {
+    throw new Error(
+      "buildOrderByClause: orderBy specified but produced empty result"
+    );
+  }
+  return result;
+}
+function normalizeTakeLike(v) {
+  const n = normalizeIntLike("take", v, {
+    min: Number.MIN_SAFE_INTEGER,
+    max: MAX_LIMIT_OFFSET,
+    allowZero: true
+  });
+  if (typeof n === "number") {
+    if (n === 0) return 0;
+  }
+  return n;
+}
+function normalizeSkipLike(v) {
+  return normalizeIntLike("skip", v, {
+    min: 0,
+    max: MAX_LIMIT_OFFSET,
+    allowZero: true
+  });
+}
+function getPaginationParams(method, args) {
+  if (method === "findMany") {
+    return {
+      take: normalizeTakeLike(args.take),
+      skip: normalizeSkipLike(args.skip),
+      cursor: args.cursor
+    };
+  }
+  if (method === "findFirst") {
+    const skip = normalizeSkipLike(args.skip);
+    return { take: 1, skip: skip != null ? skip : 0 };
+  }
+  if (method === "findUnique") {
+    return { take: 1, skip: 0 };
+  }
+  return {};
+}
+function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
+  const entries = Object.entries(val).filter(
+    ([k, v]) => k !== "mode" && v !== void 0
+  );
+  if (entries.length === 0) return "";
+  const clauses = [];
+  for (const [subOp, subVal] of entries) {
+    const sub = buildOp(expr, subOp, subVal, params, dialect);
+    if (sub && sub.trim().length > 0) clauses.push(`(${sub})`);
+  }
+  if (clauses.length === 0) return "";
+  if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
+  return `${SQL_TEMPLATES.NOT} (${clauses.join(separator)})`;
+}
+function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    return handleNullValue(expr, op);
+  }
+  if (op === Ops.NOT && isPlainObject(val)) {
+    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
+  }
+  if (op === Ops.NOT) {
+    const placeholder = params.addAuto(val);
+    return `${expr} <> ${placeholder}`;
+  }
+  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && isNotNullish(dialect)) {
+    const placeholder = params.addAuto(val);
+    return caseInsensitiveEquals(expr, placeholder);
+  }
+  const STRING_LIKE_OPS = /* @__PURE__ */ new Set([
+    Ops.CONTAINS,
+    Ops.STARTS_WITH,
+    Ops.ENDS_WITH
+  ]);
+  if (STRING_LIKE_OPS.has(op)) {
+    if (!isNotNullish(dialect)) {
+      throw createError(`Like operators require a SQL dialect`, {
+        operator: op
+      });
+    }
+    return handleLikeOperator(expr, op, val, params, mode, dialect);
+  }
+  if (op === Ops.IN || op === Ops.NOT_IN) {
+    if (!isNotNullish(dialect)) {
+      throw createError(`IN operators require a SQL dialect`, { operator: op });
+    }
+    return handleInOperator(expr, op, val, params, dialect);
+  }
+  return handleComparisonOperator(expr, op, val, params);
+}
+function handleNullValue(expr, op) {
+  if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+  if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  throw createError(`Operator '${op}' doesn't support null`, { operator: op });
+}
+function normalizeMode(v) {
+  if (v === Modes.INSENSITIVE) return Modes.INSENSITIVE;
+  if (v === Modes.DEFAULT) return Modes.DEFAULT;
+  return void 0;
+}
+function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
+  const innerMode = normalizeMode(val.mode);
+  const effectiveMode = innerMode != null ? innerMode : outerMode;
+  return buildNotComposite(
+    expr,
+    val,
+    params,
+    dialect,
+    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, effectiveMode, fieldType, d),
+    ` ${SQL_TEMPLATES.AND} `
+  );
+}
+function buildDynamicLikePattern(op, placeholder, dialect) {
+  if (dialect === "postgres") {
+    switch (op) {
+      case Ops.CONTAINS:
+        return `('%' || ${placeholder} || '%')`;
+      case Ops.STARTS_WITH:
+        return `(${placeholder} || '%')`;
+      case Ops.ENDS_WITH:
+        return `('%' || ${placeholder})`;
+      default:
+        return placeholder;
+    }
+  }
+  switch (op) {
+    case Ops.CONTAINS:
+      return `('%' || ${placeholder} || '%')`;
+    case Ops.STARTS_WITH:
+      return `(${placeholder} || '%')`;
+    case Ops.ENDS_WITH:
+      return `('%' || ${placeholder})`;
+    default:
+      return placeholder;
+  }
+}
+function handleLikeOperator(expr, op, val, params, mode, dialect) {
+  if (val === void 0) return "";
+  if (isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
+    if (mode === Modes.INSENSITIVE) {
+      return caseInsensitiveLike(expr, patternExpr, dialect);
+    }
+    return `${expr} ${SQL_TEMPLATES.LIKE} ${patternExpr}`;
+  }
+  const placeholder = params.add(Wildcards[op](String(val)));
+  if (mode === Modes.INSENSITIVE) {
+    return caseInsensitiveLike(expr, placeholder, dialect);
+  }
+  return `${expr} ${SQL_TEMPLATES.LIKE} ${placeholder}`;
+}
+function handleInOperator(expr, op, val, params, dialect) {
+  if (val === void 0) return "";
+  if (isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    return op === Ops.IN ? inArray(expr, placeholder2, dialect) : notInArray(expr, placeholder2, dialect);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`IN operators require array value`, {
+      operator: op,
+      value: val
     });
   }
-  if (filterVal === null) {
-    const wantNull = filterKey === "is";
-    const clause2 = buildToOneNullCheck(
-      field,
-      ctx.alias,
-      relTable,
-      relAlias,
-      join,
-      wantNull
-    );
-    return Object.freeze({
-      clause: clause2,
-      joins: NO_JOINS
+  if (val.length === 0) {
+    return op === Ops.IN ? "0=1" : "1=1";
+  }
+  const paramValue = prepareArrayParam(val, dialect);
+  const placeholder = params.add(paramValue);
+  return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
+}
+function handleComparisonOperator(expr, op, val, params) {
+  if (val === void 0) return "";
+  const COMPARISON_OPS2 = {
+    [Ops.EQUALS]: "=",
+    [Ops.GT]: ">",
+    [Ops.GTE]: ">=",
+    [Ops.LT]: "<",
+    [Ops.LTE]: "<="
+  };
+  const sqlOp = COMPARISON_OPS2[op];
+  if (!sqlOp) {
+    throw createError(`Unsupported scalar operator: ${op}`, { operator: op });
+  }
+  const placeholder = params.addAuto(val);
+  return `${expr} ${sqlOp} ${placeholder}`;
+}
+function buildArrayParam(val, params, dialect) {
+  if (isDynamicParameter(val)) {
+    return params.addAuto(val);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`Array operation requires array value`, { value: val });
+  }
+  const paramValue = prepareArrayParam(val, dialect);
+  return params.add(paramValue);
+}
+function buildArrayOperator(expr, op, val, params, fieldType, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+    if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  }
+  const cast = getArrayType(fieldType, dialect);
+  if (op === Ops.EQUALS) {
+    return handleArrayEquals(expr, val, params, cast, dialect);
+  }
+  if (op === Ops.NOT) {
+    return handleArrayNot(expr, val, params, cast, dialect);
+  }
+  switch (op) {
+    case Ops.HAS:
+      return handleArrayHas(expr, val, params, cast, dialect);
+    case Ops.HAS_SOME:
+      return handleArrayHasSome(expr, val, params, cast, dialect);
+    case Ops.HAS_EVERY:
+      return handleArrayHasEvery(expr, val, params, cast, dialect);
+    case Ops.IS_EMPTY:
+      return handleArrayIsEmpty(expr, val, dialect);
+    default:
+      throw createError(`Unknown array operator: ${op}`, { operator: op });
+  }
+}
+function handleArrayEquals(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (isEmptyArray(val)) {
+    return arrayIsEmpty(expr, dialect);
+  }
+  const placeholder = buildArrayParam(val, params, dialect);
+  return arrayEquals(expr, placeholder, cast, dialect);
+}
+function handleArrayNot(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  let target = val;
+  if (isPlainObject(val)) {
+    const entries = Object.entries(val).filter(([, v]) => v !== void 0);
+    if (entries.length === 1 && entries[0][0] === Ops.EQUALS) {
+      target = entries[0][1];
+    } else {
+      throw createError(`Array NOT only supports { equals: ... } shape`, {
+        operator: Ops.NOT,
+        value: val
+      });
+    }
+  }
+  if (target === null) {
+    return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  }
+  if (isEmptyArray(target)) {
+    return arrayIsNotEmpty(expr, dialect);
+  }
+  const placeholder = buildArrayParam(target, params, dialect);
+  return `${SQL_TEMPLATES.NOT} (${arrayEquals(expr, placeholder, cast, dialect)})`;
+}
+function handleArrayHas(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (val === null) {
+    throw createError(`has requires scalar value`, {
+      operator: Ops.HAS,
+      value: val
     });
   }
-  if (!isPlainObject(filterVal)) {
-    throw createError(
-      `Relation '${fieldName}' filter must be an object or null`,
-      {
-        field: fieldName,
-        path: ctx.path,
-        modelName: ctx.model.name,
-        value: filterVal
-      }
-    );
+  if (!isDynamicParameter(val) && Array.isArray(val)) {
+    throw createError(`has requires scalar value (single element), not array`, {
+      operator: Ops.HAS,
+      value: val
+    });
   }
-  const sub = whereBuilder.build(filterVal, __spreadProps(__spreadValues({}, ctx), {
-    alias: relAlias,
-    model: relModel,
-    path: [...ctx.path, fieldName, filterKey],
-    isSubquery: true,
-    depth: ctx.depth + 1
-  }));
-  const clause = filterKey === "is" ? buildToOneExistsMatch(relTable, relAlias, join, sub) : buildToOneNotExistsMatch(relTable, relAlias, join, sub);
-  return Object.freeze({
-    clause,
-    joins: NO_JOINS
-  });
-}
-function ensureRelationFilterObject(fieldName, value, ctx) {
-  if (!isPlainObject(value)) {
-    throw createError(`Relation filter '${fieldName}' must be an object`, {
-      path: [...ctx.path, fieldName],
-      field: fieldName,
-      modelName: ctx.model.name,
-      value
+  if (isPlainObject(val)) {
+    throw createError(`has requires scalar value`, {
+      operator: Ops.HAS,
+      value: val
     });
   }
+  const placeholder = params.addAuto(val);
+  return arrayContains(expr, placeholder, cast, dialect);
 }
-function buildRelation(fieldName, value, ctx, whereBuilder) {
-  const field = ctx.model.fields.find((f) => f.name === fieldName);
-  if (!isValidRelationField(field)) {
-    throw createError(`Invalid relation '${fieldName}'`, {
-      field: fieldName,
-      path: ctx.path,
-      modelName: ctx.model.name
+function handleArrayHasSome(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  if (isDynamicParameter(val)) {
+    const placeholder2 = params.addAuto(val);
+    return arrayOverlaps(expr, placeholder2, cast, dialect);
+  }
+  if (!Array.isArray(val)) {
+    throw createError(`hasSome requires array value`, {
+      operator: Ops.HAS_SOME,
+      value: val
     });
   }
-  const relModel = ctx.schemaModels.find((m) => m.name === field.relatedModel);
-  if (!isNotNullish(relModel)) {
+  if (val.length > LIMITS.MAX_ARRAY_SIZE) {
     throw createError(
-      `Related model '${field.relatedModel}' not found in schema. Available models: ${ctx.schemaModels.map((m) => m.name).join(", ")}`,
-      {
-        field: fieldName,
-        path: ctx.path,
-        modelName: ctx.model.name
-      }
+      `Array too large (${val.length} elements, max ${LIMITS.MAX_ARRAY_SIZE})`,
+      { operator: Ops.HAS_SOME, value: `[${val.length} items]` }
     );
   }
-  const relTable = buildTableReference(
-    SQL_TEMPLATES.PUBLIC_SCHEMA,
-    relModel.tableName,
-    ctx.dialect
-  );
-  const relAlias = ctx.aliasGen.next(fieldName);
-  const join = joinCondition(field, ctx.model, relModel, ctx.alias, relAlias);
-  const args = {
-    fieldName,
-    value,
-    ctx,
-    whereBuilder,
-    field,
-    relModel,
-    relTable,
-    relAlias,
-    join
-  };
-  if (isListRelation(field.type)) return buildListRelationFilters(args);
-  return buildToOneRelationFilters(args);
+  if (val.length === 0) return "0=1";
+  const paramValue = prepareArrayParam(val, dialect);
+  const placeholder = params.add(paramValue);
+  return arrayOverlaps(expr, placeholder, cast, dialect);
 }
-function buildTopLevelRelation(fieldName, value, ctx, whereBuilder) {
-  ensureRelationFilterObject(fieldName, value, ctx);
-  return buildRelation(fieldName, value, ctx, whereBuilder);
+function handleArrayHasEvery(expr, val, params, cast, dialect) {
+  if (val === void 0) return "";
+  const placeholder = buildArrayParam(val, params, dialect);
+  return arrayContainsAll(expr, placeholder, cast, dialect);
 }
-function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
-  return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
+function handleArrayIsEmpty(expr, val, dialect) {
+  if (typeof val !== "boolean") {
+    throw createError(`isEmpty requires boolean value`, {
+      operator: Ops.IS_EMPTY,
+      value: val
+    });
+  }
+  return val === true ? arrayIsEmpty(expr, dialect) : arrayIsNotEmpty(expr, dialect);
 }
 
-// src/builder/shared/validators/field-validators.ts
-function assertFieldExists(name, model, path) {
-  const field = model.fields.find((f) => f.name === name);
-  if (!isNotNullish(field)) {
-    throw createError(`Field '${name}' does not exist on '${model.name}'`, {
-      field: name,
-      path,
-      modelName: model.name,
-      availableFields: model.fields.map((f) => f.name)
+// src/builder/where/operators-json.ts
+var SAFE_JSON_PATH_SEGMENT = /^[a-zA-Z_]\w*$/;
+function validateJsonPathSegments(segments) {
+  for (const segment of segments) {
+    if (typeof segment !== "string") {
+      throw createError("JSON path segments must be strings", {
+        operator: Ops.PATH,
+        value: segment
+      });
+    }
+    if (!SAFE_JSON_PATH_SEGMENT.test(segment)) {
+      throw createError(
+        `Invalid JSON path segment: '${segment}'. Must be alphanumeric with underscores, starting with letter or underscore.`,
+        { operator: Ops.PATH, value: segment }
+      );
+    }
+  }
+}
+function buildJsonOperator(expr, op, val, params, dialect) {
+  if (val === void 0) return "";
+  if (op === Ops.PATH && isPlainObject(val) && "path" in val) {
+    return handleJsonPath(expr, val, params, dialect);
+  }
+  const jsonWildcards = {
+    [Ops.STRING_CONTAINS]: (v) => `%${v}%`,
+    [Ops.STRING_STARTS_WITH]: (v) => `${v}%`,
+    [Ops.STRING_ENDS_WITH]: (v) => `%${v}`
+  };
+  if (op in jsonWildcards) {
+    return handleJsonWildcard(expr, op, val, params, jsonWildcards, dialect);
+  }
+  throw createError(`Unsupported JSON operator: ${op}`, { operator: op });
+}
+function handleJsonPath(expr, val, params, dialect) {
+  const v = val;
+  if (!Array.isArray(v.path)) {
+    throw createError("JSON path must be an array", { operator: Ops.PATH });
+  }
+  if (v.path.length === 0) {
+    throw createError("JSON path cannot be empty", { operator: Ops.PATH });
+  }
+  validateJsonPathSegments(v.path);
+  const pathExpr = dialect === "sqlite" ? params.add(`$.${v.path.join(".")}`) : params.add(v.path);
+  const rawOps = [
+    ["=", v.equals],
+    [">", v.gt],
+    [">=", v.gte],
+    ["<", v.lt],
+    ["<=", v.lte]
+  ];
+  const ops = rawOps.filter(
+    ([, value]) => value !== void 0
+  );
+  if (ops.length === 0) {
+    throw createError("JSON path query missing comparison operator", {
+      operator: Ops.PATH
     });
   }
-  return field;
+  const parts = [];
+  for (const [sqlOp, value] of ops) {
+    if (value === null) {
+      const base2 = jsonExtractText(expr, pathExpr, dialect);
+      parts.push(`${base2} ${SQL_TEMPLATES.IS_NULL}`);
+      continue;
+    }
+    const valPh = params.add(value);
+    const base = typeof value === "number" ? jsonExtractNumeric(expr, pathExpr, dialect) : jsonExtractText(expr, pathExpr, dialect);
+    parts.push(`${base} ${sqlOp} ${valPh}`);
+  }
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
 }
-function assertValidOperator(fieldName, op, fieldType, path, modelName) {
-  if (!isNotNullish(fieldType)) return;
-  const ARRAY_OPS = /* @__PURE__ */ new Set([
-    Ops.HAS,
-    Ops.HAS_SOME,
-    Ops.HAS_EVERY,
-    Ops.IS_EMPTY
-  ]);
-  const JSON_OPS = /* @__PURE__ */ new Set([
-    Ops.PATH,
-    Ops.STRING_CONTAINS,
-    Ops.STRING_STARTS_WITH,
-    Ops.STRING_ENDS_WITH
-  ]);
-  const isArrayOp = ARRAY_OPS.has(op);
-  const isFieldArray = isArrayType(fieldType);
-  const arrayOpMismatch = isArrayOp && !isFieldArray;
-  if (arrayOpMismatch) {
-    throw createError(`'${op}' requires array field, got '${fieldType}'`, {
+function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
+  if (!isNotNullish(val)) {
+    throw createError(`JSON string operator requires non-null value`, {
       operator: op,
-      field: fieldName,
-      path,
-      modelName
+      value: val
     });
   }
-  const isJsonOp = JSON_OPS.has(op);
-  const isFieldJson = isJsonType(fieldType);
-  const jsonOpMismatch = isJsonOp && !isFieldJson;
-  if (jsonOpMismatch) {
-    throw createError(`'${op}' requires JSON field, got '${fieldType}'`, {
+  if (isPlainObject(val) || Array.isArray(val)) {
+    throw createError(`JSON string operator requires scalar value`, {
       operator: op,
-      field: fieldName,
-      path,
-      modelName
+      value: val
     });
   }
+  const strVal = String(val);
+  if (strVal.length > LIMITS.MAX_STRING_LENGTH) {
+    throw createError(
+      `String too long (${strVal.length} chars, max ${LIMITS.MAX_STRING_LENGTH})`,
+      { operator: op }
+    );
+  }
+  const placeholder = params.add(wildcards[op](strVal));
+  const jsonText = jsonToText(expr, dialect);
+  return caseInsensitiveLike(jsonText, placeholder, dialect);
 }
 
-// src/builder/where/builder.ts
-var WhereBuilder = class {
-  build(where, ctx) {
-    if (!isPlainObject(where)) {
-      throw createError("where must be an object", {
-        path: ctx.path,
-        modelName: ctx.model.name
-      });
-    }
-    return buildWhereInternal(where, ctx, this);
-  }
-};
-var MAX_QUERY_DEPTH = 50;
-var EMPTY_JOINS = Object.freeze([]);
-var whereBuilderInstance = new WhereBuilder();
-function freezeResult(clause, joins = EMPTY_JOINS) {
-  return Object.freeze({ clause, joins });
+// src/builder/where/relations.ts
+var NO_JOINS = Object.freeze([]);
+function isListRelation(fieldType) {
+  return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
-function dedupePreserveOrder(items) {
-  if (items.length <= 1) return Object.freeze([...items]);
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const s of items) {
-    if (!seen.has(s)) {
-      seen.add(s);
-      out.push(s);
+function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join, wantNull) {
+  const isLocal = field.isForeignKeyLocal === true;
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (isLocal) {
+    if (fkFields.length === 0) {
+      throw createError(`Relation '${field.name}' is missing foreignKey`, {
+        field: field.name
+      });
     }
+    const parts = fkFields.map((fk) => {
+      const safe = fk.replace(/"/g, '""');
+      const expr = `${parentAlias}."${safe}"`;
+      return wantNull ? `${expr} ${SQL_TEMPLATES.IS_NULL}` : `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+    });
+    if (parts.length === 1) return parts[0];
+    return wantNull ? `(${parts.join(" OR ")})` : `(${parts.join(" AND ")})`;
   }
-  return Object.freeze(out);
-}
-function appendResult(result, clauses, allJoins) {
-  if (isValidWhereClause(result.clause)) clauses.push(result.clause);
-  if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
+  const existsSql = `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias} ${SQL_TEMPLATES.WHERE} ${join})`;
+  return wantNull ? `${SQL_TEMPLATES.NOT} ${existsSql}` : existsSql;
 }
-function asLogicalOperator(key) {
-  if (key === LogicalOps.AND) return "AND";
-  if (key === LogicalOps.OR) return "OR";
-  if (key === LogicalOps.NOT) return "NOT";
-  return null;
+function buildToOneExistsMatch(relTable, relAlias, join, sub) {
+  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
-function nextContext(ctx) {
-  return __spreadProps(__spreadValues({}, ctx), { depth: ctx.depth + 1 });
+function buildToOneNotExistsMatch(relTable, relAlias, join, sub) {
+  const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+  return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
-function buildRelationFilter(fieldName, value, ctx, builder) {
-  const ctx2 = nextContext(ctx);
-  if (ctx.isSubquery) {
-    return buildNestedRelation(fieldName, value, ctx2, builder);
+function buildListRelationFilters(args) {
+  const {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    relModel,
+    relTable,
+    relAlias,
+    join
+  } = args;
+  const noneValue = value[RelationFilters.NONE];
+  if (noneValue !== void 0 && noneValue !== null) {
+    const sub = whereBuilder.build(noneValue, __spreadProps(__spreadValues({}, ctx), {
+      alias: relAlias,
+      model: relModel,
+      path: [...ctx.path, fieldName, RelationFilters.NONE],
+      isSubquery: true,
+      depth: ctx.depth + 1
+    }));
+    const isEmptyFilter = isPlainObject(noneValue) && Object.keys(noneValue).length === 0;
+    const canOptimize = !ctx.isSubquery && isEmptyFilter && sub.clause === DEFAULT_WHERE_CLAUSE && sub.joins.length === 0;
+    if (canOptimize) {
+      const checkField = relModel.fields.find(
+        (f) => !f.isRelation && f.isRequired && f.name !== "id"
+      ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
+      if (checkField) {
+        const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join}`;
+        const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
+        return Object.freeze({
+          clause: whereClause,
+          joins: [leftJoinSql]
+        });
+      }
+    }
   }
-  return buildTopLevelRelation(fieldName, value, ctx2, builder);
-}
-function buildWhereEntry(key, value, ctx, builder) {
-  const op = asLogicalOperator(key);
-  if (op) return buildLogical(op, value, ctx, builder);
-  if (isRelationField(key, ctx.model)) {
-    if (!isPlainObject(value)) {
-      throw createError(`Relation filter '${key}' must be an object`, {
-        path: [...ctx.path, key],
-        field: key,
-        modelName: ctx.model.name,
-        value
-      });
+  const filters = [
+    {
+      key: RelationFilters.SOME,
+      wrap: (c, j) => `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${c})`
+    },
+    {
+      key: RelationFilters.EVERY,
+      wrap: (c, j) => `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${SQL_TEMPLATES.NOT} (${c}))`
+    },
+    {
+      key: RelationFilters.NONE,
+      wrap: (c, j) => {
+        const condition = c === DEFAULT_WHERE_CLAUSE ? "" : ` ${SQL_TEMPLATES.AND} ${c}`;
+        return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${j} ${SQL_TEMPLATES.WHERE} ${join}${condition})`;
+      }
     }
-    return buildRelationFilter(key, value, ctx, builder);
+  ];
+  const clauses = [];
+  for (const { key, wrap } of filters) {
+    const raw = value[key];
+    if (raw === void 0 || raw === null) continue;
+    const sub = whereBuilder.build(raw, __spreadProps(__spreadValues({}, ctx), {
+      alias: relAlias,
+      model: relModel,
+      path: [...ctx.path, fieldName, key],
+      isSubquery: true,
+      depth: ctx.depth + 1
+    }));
+    const j = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
+    clauses.push(wrap(sub.clause, j));
   }
-  return buildScalarField(key, value, ctx);
-}
-function buildWhereInternal(where, ctx, builder) {
-  if (ctx.depth > MAX_QUERY_DEPTH) {
+  if (clauses.length === 0) {
     throw createError(
-      `Query nesting too deep (max ${MAX_QUERY_DEPTH} levels). This usually indicates a circular reference.`,
-      { path: ctx.path, modelName: ctx.model.name }
+      `List relation '${fieldName}' requires one of { some, every, none }`,
+      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
     );
   }
-  if (isEmptyWhere(where)) {
-    return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
-  }
-  const allJoins = [];
-  const clauses = [];
-  for (const [key, value] of Object.entries(where)) {
-    if (value === void 0) continue;
-    const result = buildWhereEntry(key, value, ctx, builder);
-    appendResult(result, clauses, allJoins);
-  }
-  const finalClause = clauses.length > 0 ? clauses.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
-  return freezeResult(finalClause, dedupePreserveOrder(allJoins));
+  return Object.freeze({
+    clause: clauses.join(SQL_SEPARATORS.CONDITION_AND),
+    joins: NO_JOINS
+  });
 }
-function normalizeLogicalValue(operator, value, ctx) {
-  if (Array.isArray(value)) {
-    const out = [];
-    for (let i = 0; i < value.length; i++) {
-      const v = value[i];
-      if (v === void 0) continue;
-      if (!isPlainObject(v)) {
-        throw createError(`${operator} entries must be objects`, {
-          path: [...ctx.path, operator, String(i)],
-          modelName: ctx.model.name,
-          value: v
-        });
-      }
-      out.push(v);
-    }
-    return out;
+function buildToOneRelationFilters(args) {
+  const {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    field,
+    relModel,
+    relTable,
+    relAlias,
+    join
+  } = args;
+  const hasSomeEveryNone = isNotNullish(value[RelationFilters.SOME]) || isNotNullish(value[RelationFilters.EVERY]) || isNotNullish(value[RelationFilters.NONE]);
+  if (hasSomeEveryNone) {
+    throw createError(
+      `To-one relation '${fieldName}' does not support { some, every, none }; use { is, isNot }`,
+      { field: fieldName, path: ctx.path, modelName: ctx.model.name }
+    );
   }
-  if (isPlainObject(value)) {
-    return [value];
+  const hasIs = Object.prototype.hasOwnProperty.call(value, "is");
+  const hasIsNot = Object.prototype.hasOwnProperty.call(value, "isNot");
+  let filterKey;
+  let filterVal;
+  if (hasIs) {
+    filterKey = "is";
+    filterVal = value.is;
+  } else if (hasIsNot) {
+    filterKey = "isNot";
+    filterVal = value.isNot;
+  } else {
+    filterKey = "is";
+    filterVal = value;
   }
-  throw createError(`${operator} must be an object or array of objects`, {
-    path: [...ctx.path, operator],
-    modelName: ctx.model.name,
-    value
-  });
-}
-function collectLogicalParts(operator, conditions, ctx, builder) {
-  const allJoins = [];
-  const clauses = [];
-  for (let i = 0; i < conditions.length; i++) {
-    const result = builder.build(conditions[i], __spreadProps(__spreadValues({}, ctx), {
-      path: [...ctx.path, operator, String(i)],
-      depth: ctx.depth + 1
-    }));
-    if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
-    if (result.clause && result.clause !== DEFAULT_WHERE_CLAUSE) {
-      clauses.push(`(${result.clause})`);
-    }
+  if (filterVal === void 0) {
+    return Object.freeze({
+      clause: DEFAULT_WHERE_CLAUSE,
+      joins: NO_JOINS
+    });
+  }
+  if (filterVal === null) {
+    const wantNull = filterKey === "is";
+    const clause2 = buildToOneNullCheck(
+      field,
+      ctx.alias,
+      relTable,
+      relAlias,
+      join,
+      wantNull
+    );
+    return Object.freeze({
+      clause: clause2,
+      joins: NO_JOINS
+    });
   }
-  return {
-    joins: dedupePreserveOrder(allJoins),
-    clauses: Object.freeze(clauses)
-  };
-}
-function buildLogicalClause(operator, clauses) {
-  if (clauses.length === 0) return DEFAULT_WHERE_CLAUSE;
-  if (operator === "NOT") {
-    if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
-    return `${SQL_TEMPLATES.NOT} (${clauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
+  if (!isPlainObject(filterVal)) {
+    throw createError(
+      `Relation '${fieldName}' filter must be an object or null`,
+      {
+        field: fieldName,
+        path: ctx.path,
+        modelName: ctx.model.name,
+        value: filterVal
+      }
+    );
   }
-  return clauses.join(` ${operator} `);
+  const sub = whereBuilder.build(filterVal, __spreadProps(__spreadValues({}, ctx), {
+    alias: relAlias,
+    model: relModel,
+    path: [...ctx.path, fieldName, filterKey],
+    isSubquery: true,
+    depth: ctx.depth + 1
+  }));
+  const clause = filterKey === "is" ? buildToOneExistsMatch(relTable, relAlias, join, sub) : buildToOneNotExistsMatch(relTable, relAlias, join, sub);
+  return Object.freeze({
+    clause,
+    joins: NO_JOINS
+  });
 }
-function buildLogical(operator, value, ctx, builder) {
-  const conditions = normalizeLogicalValue(operator, value, ctx);
-  if (conditions.length === 0) {
-    const clause2 = operator === "OR" ? "0=1" : DEFAULT_WHERE_CLAUSE;
-    return freezeResult(clause2, EMPTY_JOINS);
+function ensureRelationFilterObject(fieldName, value, ctx) {
+  if (!isPlainObject(value)) {
+    throw createError(`Relation filter '${fieldName}' must be an object`, {
+      path: [...ctx.path, fieldName],
+      field: fieldName,
+      modelName: ctx.model.name,
+      value
+    });
   }
-  const { joins, clauses } = collectLogicalParts(
-    operator,
-    conditions,
-    ctx,
-    builder
-  );
-  const clause = buildLogicalClause(operator, clauses);
-  return freezeResult(clause, joins);
 }
-function buildScalarField(fieldName, value, ctx) {
-  const field = assertFieldExists(fieldName, ctx.model, ctx.path);
-  const expr = col(ctx.alias, fieldName);
-  if (value === null) {
-    return freezeResult(`${expr} ${SQL_TEMPLATES.IS_NULL}`, EMPTY_JOINS);
+function buildRelation(fieldName, value, ctx, whereBuilder) {
+  const field = ctx.model.fields.find((f) => f.name === fieldName);
+  if (!isValidRelationField(field)) {
+    throw createError(`Invalid relation '${fieldName}'`, {
+      field: fieldName,
+      path: ctx.path,
+      modelName: ctx.model.name
+    });
   }
-  if (isPlainObject(value)) {
-    const mode = value.mode;
-    const ops = Object.entries(value).filter(
-      ([k, v]) => k !== "mode" && v !== void 0
+  const relModel = ctx.schemaModels.find((m) => m.name === field.relatedModel);
+  if (!isNotNullish(relModel)) {
+    throw createError(
+      `Related model '${field.relatedModel}' not found in schema. Available models: ${ctx.schemaModels.map((m) => m.name).join(", ")}`,
+      {
+        field: fieldName,
+        path: ctx.path,
+        modelName: ctx.model.name
+      }
     );
-    if (ops.length === 0) {
-      return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
-    }
-    const parts = [];
-    for (const [op, val] of ops) {
-      assertValidOperator(fieldName, op, field.type, ctx.path, ctx.model.name);
-      const clause3 = buildOperator(expr, op, val, ctx, mode, field.type);
-      if (isValidWhereClause(clause3)) parts.push(clause3);
-    }
-    const clause2 = parts.length > 0 ? parts.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
-    return freezeResult(clause2, EMPTY_JOINS);
-  }
-  const clause = buildOperator(
-    expr,
-    Ops.EQUALS,
-    value,
-    ctx,
-    void 0,
-    field.type
-  );
-  return freezeResult(clause || DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
-}
-function buildOperator(expr, op, val, ctx, mode, fieldType) {
-  if (fieldType && isArrayType(fieldType)) {
-    return buildArrayOperator(expr, op, val, ctx.params, fieldType, ctx.dialect);
-  }
-  if (fieldType && isJsonType(fieldType)) {
-    const JSON_OPS = /* @__PURE__ */ new Set([
-      Ops.PATH,
-      Ops.STRING_CONTAINS,
-      Ops.STRING_STARTS_WITH,
-      Ops.STRING_ENDS_WITH
-    ]);
-    if (JSON_OPS.has(op)) {
-      return buildJsonOperator(expr, op, val, ctx.params, ctx.dialect);
-    }
   }
-  return buildScalarOperator(
-    expr,
-    op,
-    val,
-    ctx.params,
-    mode,
-    fieldType,
+  const relTable = buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    relModel.tableName,
     ctx.dialect
   );
-}
-
-// src/builder/shared/alias-generator.ts
-function toSafeSqlIdentifier(input) {
-  const raw = String(input);
-  const cleaned = raw.replace(/\W/g, "_");
-  const startsOk = /^[a-zA-Z_]/.test(cleaned);
-  const base = startsOk ? cleaned : `_${cleaned}`;
-  const fallback = base.length > 0 ? base : "_t";
-  const lowered = fallback.toLowerCase();
-  return SQL_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
-}
-function createAliasGenerator(maxAliases = 1e4) {
-  let counter = 0;
-  const usedAliases = /* @__PURE__ */ new Set();
-  return {
-    next(baseName) {
-      if (usedAliases.size >= maxAliases) {
-        throw new Error(
-          `Alias generator exceeded maximum of ${maxAliases} aliases. This indicates a query complexity issue or potential infinite loop.`
-        );
-      }
-      const base = toSafeSqlIdentifier(baseName);
-      const suffix = `_${counter}`;
-      const maxLen = 63;
-      const baseMax = Math.max(1, maxLen - suffix.length);
-      const trimmedBase = base.length > baseMax ? base.slice(0, baseMax) : base;
-      const alias = `${trimmedBase}${suffix}`;
-      counter += 1;
-      if (usedAliases.has(alias)) {
-        throw new Error(
-          `CRITICAL: Duplicate alias '${alias}' at counter=${counter}. This indicates a bug in alias generation logic.`
-        );
-      }
-      usedAliases.add(alias);
-      return alias;
-    }
+  const relAlias = ctx.aliasGen.next(fieldName);
+  const join = joinCondition(field, ctx.model, relModel, ctx.alias, relAlias);
+  const args = {
+    fieldName,
+    value,
+    ctx,
+    whereBuilder,
+    field,
+    relModel,
+    relTable,
+    relAlias,
+    join
   };
+  if (isListRelation(field.type)) return buildListRelationFilters(args);
+  return buildToOneRelationFilters(args);
 }
-var MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
-function assertSameLength(params, mappings) {
-  if (params.length !== mappings.length) {
-    throw new Error(
-      `CRITICAL: State corruption - params=${params.length}, mappings=${mappings.length}`
-    );
-  }
+function buildTopLevelRelation(fieldName, value, ctx, whereBuilder) {
+  ensureRelationFilterObject(fieldName, value, ctx);
+  return buildRelation(fieldName, value, ctx, whereBuilder);
 }
-function assertValidNextIndex(index) {
-  if (!Number.isInteger(index) || index < 1) {
-    throw new Error(`CRITICAL: Index must be integer >= 1, got ${index}`);
-  }
+function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
+  return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
 }
-function assertNextIndexMatches(mappingsLength, nextIndex) {
-  const expected = mappingsLength + 1;
-  if (nextIndex !== expected) {
-    throw new Error(
-      `CRITICAL: Next index mismatch - expected ${expected}, got ${nextIndex}`
-    );
+
+// src/builder/shared/validators/field-validators.ts
+function assertFieldExists(name, model, path) {
+  const field = model.fields.find((f) => f.name === name);
+  if (!isNotNullish(field)) {
+    throw createError(`Field '${name}' does not exist on '${model.name}'`, {
+      field: name,
+      path,
+      modelName: model.name,
+      availableFields: model.fields.map((f) => f.name)
+    });
   }
+  return field;
 }
-function assertSequentialIndex(actual, expected) {
-  if (actual !== expected) {
-    throw new Error(
-      `CRITICAL: Indices must be sequential from 1..N. Expected ${expected}, got ${actual}`
-    );
+function assertValidOperator(fieldName, op, fieldType, path, modelName) {
+  if (!isNotNullish(fieldType)) return;
+  const ARRAY_OPS = /* @__PURE__ */ new Set([
+    Ops.HAS,
+    Ops.HAS_SOME,
+    Ops.HAS_EVERY,
+    Ops.IS_EMPTY
+  ]);
+  const JSON_OPS = /* @__PURE__ */ new Set([
+    Ops.PATH,
+    Ops.STRING_CONTAINS,
+    Ops.STRING_STARTS_WITH,
+    Ops.STRING_ENDS_WITH
+  ]);
+  const isArrayOp = ARRAY_OPS.has(op);
+  const isFieldArray = isArrayType(fieldType);
+  const arrayOpMismatch = isArrayOp && !isFieldArray;
+  if (arrayOpMismatch) {
+    throw createError(`'${op}' requires array field, got '${fieldType}'`, {
+      operator: op,
+      field: fieldName,
+      path,
+      modelName
+    });
   }
-}
-function assertExactlyOneOfDynamicOrValue(m) {
-  const hasDynamic = typeof m.dynamicName === "string";
-  const hasStatic = m.value !== void 0;
-  if (hasDynamic === hasStatic) {
-    throw new Error(
-      `CRITICAL: ParamMap ${m.index} must have exactly one of dynamicName or value`
-    );
+  const isJsonOp = JSON_OPS.has(op);
+  const isFieldJson = isJsonType(fieldType);
+  const jsonOpMismatch = isJsonOp && !isFieldJson;
+  if (jsonOpMismatch) {
+    throw createError(`'${op}' requires JSON field, got '${fieldType}'`, {
+      operator: op,
+      field: fieldName,
+      path,
+      modelName
+    });
   }
 }
-function normalizeDynamicNameOrThrow(dynamicName, index) {
-  const dn = dynamicName.trim();
-  if (dn.length === 0) {
-    throw new Error(`CRITICAL: dynamicName cannot be empty (index=${index})`);
+
+// src/builder/where/builder.ts
+var WhereBuilder = class {
+  build(where, ctx) {
+    if (!isPlainObject(where)) {
+      throw createError("where must be an object", {
+        path: ctx.path,
+        modelName: ctx.model.name
+      });
+    }
+    return buildWhereInternal(where, ctx, this);
   }
-  return dn;
+};
+var MAX_QUERY_DEPTH = 50;
+var EMPTY_JOINS = Object.freeze([]);
+var whereBuilderInstance = new WhereBuilder();
+function freezeResult(clause, joins = EMPTY_JOINS) {
+  return Object.freeze({ clause, joins });
 }
-function assertUniqueDynamicName(dn, seen) {
-  if (seen.has(dn)) {
-    throw new Error(`CRITICAL: Duplicate dynamic param name in mappings: ${dn}`);
+function dedupePreserveOrder(items) {
+  if (items.length <= 1) return Object.freeze([...items]);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of items) {
+    if (!seen.has(s)) {
+      seen.add(s);
+      out.push(s);
+    }
   }
-  seen.add(dn);
+  return Object.freeze(out);
 }
-function validateMappingEntry(m, expectedIndex, seenDynamic) {
-  assertSequentialIndex(m.index, expectedIndex);
-  assertExactlyOneOfDynamicOrValue(m);
-  if (typeof m.dynamicName === "string") {
-    const dn = normalizeDynamicNameOrThrow(m.dynamicName, m.index);
-    assertUniqueDynamicName(dn, seenDynamic);
-  }
+function appendResult(result, clauses, allJoins) {
+  if (isValidWhereClause(result.clause)) clauses.push(result.clause);
+  if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
 }
-function validateMappings(mappings) {
-  const seenDynamic = /* @__PURE__ */ new Set();
-  for (let i = 0; i < mappings.length; i++) {
-    validateMappingEntry(mappings[i], i + 1, seenDynamic);
-  }
+function asLogicalOperator(key) {
+  if (key === LogicalOps.AND) return "AND";
+  if (key === LogicalOps.OR) return "OR";
+  if (key === LogicalOps.NOT) return "NOT";
+  return null;
 }
-function validateState(params, mappings, index) {
-  assertSameLength(params, mappings);
-  assertValidNextIndex(index);
-  if (mappings.length === 0) return;
-  validateMappings(mappings);
-  assertNextIndexMatches(mappings.length, index);
+function nextContext(ctx) {
+  return __spreadProps(__spreadValues({}, ctx), { depth: ctx.depth + 1 });
 }
-function normalizeValue(value) {
-  if (value instanceof Date) {
-    return value.toISOString();
+function buildRelationFilter(fieldName, value, ctx, builder) {
+  const ctx2 = nextContext(ctx);
+  if (ctx.isSubquery) {
+    return buildNestedRelation(fieldName, value, ctx2, builder);
   }
-  return value;
+  return buildTopLevelRelation(fieldName, value, ctx2, builder);
 }
-function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
-  let index = startIndex;
-  const params = [...initialParams];
-  const mappings = [...initialMappings];
-  const dynamicNameToIndex = /* @__PURE__ */ new Map();
-  for (const m of initialMappings) {
-    if (typeof m.dynamicName === "string") {
-      dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
-    }
-  }
-  function assertCanAdd() {
-    if (index > MAX_PARAM_INDEX) {
-      throw new Error(
-        `CRITICAL: Cannot add param - would overflow MAX_SAFE_INTEGER. Current index: ${index}`
-      );
-    }
-  }
-  function normalizeDynamicName(dynamicName) {
-    const dn = dynamicName.trim();
-    if (dn.length === 0) {
-      throw new Error("CRITICAL: dynamicName cannot be empty");
-    }
-    return dn;
-  }
-  function format(position) {
-    return `$${position}`;
-  }
-  function addDynamic(dynamicName) {
-    const dn = normalizeDynamicName(dynamicName);
-    const existing = dynamicNameToIndex.get(dn);
-    if (existing !== void 0) {
-      return format(existing);
-    }
-    const position = index;
-    dynamicNameToIndex.set(dn, position);
-    params.push(void 0);
-    mappings.push({ index: position, dynamicName: dn });
-    index++;
-    return format(position);
-  }
-  function addStatic(value) {
-    const position = index;
-    const normalizedValue = normalizeValue(value);
-    params.push(normalizedValue);
-    mappings.push({ index: position, value: normalizedValue });
-    index++;
-    return format(position);
-  }
-  function add(value, dynamicName) {
-    assertCanAdd();
-    return dynamicName === void 0 ? addStatic(value) : addDynamic(dynamicName);
-  }
-  function addAuto(value) {
-    if (isDynamicParameter(value)) {
-      const dynamicName = extractDynamicName(value);
-      return add(void 0, dynamicName);
+function buildWhereEntry(key, value, ctx, builder) {
+  const op = asLogicalOperator(key);
+  if (op) return buildLogical(op, value, ctx, builder);
+  if (isRelationField(key, ctx.model)) {
+    if (!isPlainObject(value)) {
+      throw createError(`Relation filter '${key}' must be an object`, {
+        path: [...ctx.path, key],
+        field: key,
+        modelName: ctx.model.name,
+        value
+      });
     }
-    return add(value);
-  }
-  function snapshot() {
-    return Object.freeze({
-      index,
-      params: Object.freeze([...params]),
-      mappings: Object.freeze([...mappings])
-    });
+    return buildRelationFilter(key, value, ctx, builder);
   }
-  return {
-    add,
-    addAuto,
-    snapshot,
-    get index() {
-      return index;
-    }
-  };
+  return buildScalarField(key, value, ctx);
 }
-function createParamStore(startIndex = 1) {
-  if (!Number.isInteger(startIndex) || startIndex < 1) {
-    throw new Error(`Start index must be integer >= 1, got ${startIndex}`);
-  }
-  if (startIndex > MAX_PARAM_INDEX) {
-    throw new Error(
-      `Start index too high (${startIndex}), risk of overflow at MAX_SAFE_INTEGER`
+function buildWhereInternal(where, ctx, builder) {
+  if (ctx.depth > MAX_QUERY_DEPTH) {
+    throw createError(
+      `Query nesting too deep (max ${MAX_QUERY_DEPTH} levels). This usually indicates a circular reference.`,
+      { path: ctx.path, modelName: ctx.model.name }
     );
   }
-  return createStoreInternal(startIndex);
-}
-function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
-  validateState([...existingParams], [...existingMappings], nextIndex);
-  return createStoreInternal(
-    nextIndex,
-    [...existingParams],
-    [...existingMappings]
-  );
-}
-
-// src/builder/shared/state.ts
-function toPublicResult(clause, joins, params) {
-  const snapshot = params.snapshot();
-  return Object.freeze({
-    clause: clause || DEFAULT_WHERE_CLAUSE,
-    joins: Object.freeze([...joins]),
-    params: snapshot.params,
-    paramMappings: snapshot.mappings,
-    nextParamIndex: snapshot.index
-  });
+  if (isEmptyWhere(where)) {
+    return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
+  }
+  const allJoins = [];
+  const clauses = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    const result = buildWhereEntry(key, value, ctx, builder);
+    appendResult(result, clauses, allJoins);
+  }
+  const finalClause = clauses.length > 0 ? clauses.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
+  return freezeResult(finalClause, dedupePreserveOrder(allJoins));
 }
-
-// src/builder/where.ts
-function buildWhereClause(where, options) {
-  var _a, _b, _c, _d, _e;
-  const dialect = options.dialect || getGlobalDialect();
-  const params = (_a = options.params) != null ? _a : createParamStore();
-  const ctx = {
-    alias: options.alias,
-    model: options.model,
-    schemaModels: (_b = options.schemaModels) != null ? _b : [],
-    path: (_c = options.path) != null ? _c : [],
-    isSubquery: (_d = options.isSubquery) != null ? _d : false,
-    aliasGen: (_e = options.aliasGen) != null ? _e : createAliasGenerator(),
-    dialect,
-    params,
-    depth: 0
-  };
-  const result = whereBuilderInstance.build(where, ctx);
-  const publicResult = toPublicResult(result.clause, result.joins, params);
-  if (!options.isSubquery) {
-    const nums = [...publicResult.clause.matchAll(/\$(\d+)/g)].map(
-      (m) => parseInt(m[1], 10)
-    );
-    if (nums.length > 0) {
-      const min = Math.min(...nums);
-      if (min === 1) {
-        validateParamConsistency(publicResult.clause, publicResult.params);
-      } else {
-        validateParamConsistencyFragment(
-          publicResult.clause,
-          publicResult.params
-        );
+function normalizeLogicalValue(operator, value, ctx) {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (let i = 0; i < value.length; i++) {
+      const v = value[i];
+      if (v === void 0) continue;
+      if (!isPlainObject(v)) {
+        throw createError(`${operator} entries must be objects`, {
+          path: [...ctx.path, operator, String(i)],
+          modelName: ctx.model.name,
+          value: v
+        });
       }
+      out.push(v);
     }
+    return out;
   }
-  return publicResult;
-}
-function normalizeIntLike(name, v, opts = {}) {
-  var _a, _b;
-  if (!isNotNullish(v)) return void 0;
-  if (isDynamicParameter(v)) return v;
-  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
-    throw new Error(`${name} must be an integer`);
-  }
-  const min = (_a = opts.min) != null ? _a : 0;
-  const allowZero = (_b = opts.allowZero) != null ? _b : true;
-  if (!allowZero && v === 0) {
-    throw new Error(`${name} must be > 0`);
-  }
-  if (v < min) {
-    throw new Error(`${name} must be >= ${min}`);
-  }
-  if (typeof opts.max === "number" && v > opts.max) {
-    throw new Error(`${name} must be <= ${opts.max}`);
+  if (isPlainObject(value)) {
+    return [value];
   }
-  return v;
-}
-function scopeName(scope, dynamicName) {
-  const s = String(scope).trim();
-  const dn = String(dynamicName).trim();
-  if (s.length === 0) return dn;
-  return `${s}:${dn}`;
+  throw createError(`${operator} must be an object or array of objects`, {
+    path: [...ctx.path, operator],
+    modelName: ctx.model.name,
+    value
+  });
 }
-function addAutoScoped(params, value, scope) {
-  if (isDynamicParameter(value)) {
-    const dn = extractDynamicName(value);
-    return params.add(void 0, scopeName(scope, dn));
+function collectLogicalParts(operator, conditions, ctx, builder) {
+  const allJoins = [];
+  const clauses = [];
+  for (let i = 0; i < conditions.length; i++) {
+    const result = builder.build(conditions[i], __spreadProps(__spreadValues({}, ctx), {
+      path: [...ctx.path, operator, String(i)],
+      depth: ctx.depth + 1
+    }));
+    if (isNonEmptyArray(result.joins)) allJoins.push(...result.joins);
+    if (result.clause && result.clause !== DEFAULT_WHERE_CLAUSE) {
+      clauses.push(`(${result.clause})`);
+    }
   }
-  return params.add(value);
+  return {
+    joins: dedupePreserveOrder(allJoins),
+    clauses: Object.freeze(clauses)
+  };
 }
-
-// src/builder/shared/order-by-utils.ts
-var flipNulls = (v) => {
-  const s = String(v).toLowerCase();
-  if (s === "first") return "last";
-  if (s === "last") return "first";
-  return v;
-};
-var flipSortString = (v) => {
-  if (typeof v !== "string") return v;
-  const s = v.toLowerCase();
-  if (s === "asc") return "desc";
-  if (s === "desc") return "asc";
-  return v;
-};
-var getNextSort = (sortRaw) => {
-  if (typeof sortRaw !== "string") return sortRaw;
-  const s = sortRaw.toLowerCase();
-  if (s === "asc") return "desc";
-  if (s === "desc") return "asc";
-  return sortRaw;
-};
-var flipObjectSort = (obj) => {
-  const sortRaw = obj.sort;
-  const out = __spreadProps(__spreadValues({}, obj), { sort: getNextSort(sortRaw) });
-  const nullsRaw = obj.nulls;
-  if (typeof nullsRaw === "string") {
-    out.nulls = flipNulls(nullsRaw);
-  }
-  return out;
-};
-var flipValue = (v) => {
-  if (typeof v === "string") return flipSortString(v);
-  if (isPlainObject(v)) return flipObjectSort(v);
-  return v;
-};
-var assertSingleFieldObject = (item) => {
-  if (!isPlainObject(item)) {
-    throw new Error("orderBy array entries must be objects");
-  }
-  const entries = Object.entries(item);
-  if (entries.length !== 1) {
-    throw new Error("orderBy array entries must have exactly one field");
+function buildLogicalClause(operator, clauses) {
+  if (clauses.length === 0) return DEFAULT_WHERE_CLAUSE;
+  if (operator === "NOT") {
+    if (clauses.length === 1) return `${SQL_TEMPLATES.NOT} ${clauses[0]}`;
+    return `${SQL_TEMPLATES.NOT} (${clauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
   }
-  return entries[0];
-};
-var flipOrderByArray = (orderBy) => {
-  return orderBy.map((item) => {
-    const [k, v] = assertSingleFieldObject(item);
-    return { [k]: flipValue(v) };
-  });
-};
-var flipOrderByObject = (orderBy) => {
-  const out = {};
-  for (const [k, v] of Object.entries(orderBy)) {
-    out[k] = flipValue(v);
+  return clauses.join(` ${operator} `);
+}
+function buildLogical(operator, value, ctx, builder) {
+  const conditions = normalizeLogicalValue(operator, value, ctx);
+  if (conditions.length === 0) {
+    const clause2 = operator === "OR" ? "0=1" : DEFAULT_WHERE_CLAUSE;
+    return freezeResult(clause2, EMPTY_JOINS);
   }
-  return out;
-};
-function reverseOrderByInput(orderBy) {
-  if (!isNotNullish(orderBy)) return orderBy;
-  if (Array.isArray(orderBy)) {
-    return flipOrderByArray(orderBy);
+  const { joins, clauses } = collectLogicalParts(
+    operator,
+    conditions,
+    ctx,
+    builder
+  );
+  const clause = buildLogicalClause(operator, clauses);
+  return freezeResult(clause, joins);
+}
+function buildScalarField(fieldName, value, ctx) {
+  const field = assertFieldExists(fieldName, ctx.model, ctx.path);
+  const expr = col(ctx.alias, fieldName, ctx.model);
+  if (value === null) {
+    return freezeResult(`${expr} ${SQL_TEMPLATES.IS_NULL}`, EMPTY_JOINS);
   }
-  if (isPlainObject(orderBy)) {
-    return flipOrderByObject(orderBy);
+  if (isPlainObject(value)) {
+    const mode = value.mode;
+    const ops = Object.entries(value).filter(
+      ([k, v]) => k !== "mode" && v !== void 0
+    );
+    if (ops.length === 0) {
+      return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
+    }
+    const parts = [];
+    for (const [op, val] of ops) {
+      assertValidOperator(fieldName, op, field.type, ctx.path, ctx.model.name);
+      const clause3 = buildOperator(expr, op, val, ctx, mode, field.type);
+      if (isValidWhereClause(clause3)) parts.push(clause3);
+    }
+    const clause2 = parts.length > 0 ? parts.join(SQL_SEPARATORS.CONDITION_AND) : DEFAULT_WHERE_CLAUSE;
+    return freezeResult(clause2, EMPTY_JOINS);
   }
-  throw new Error("orderBy must be an object or array of objects");
+  const clause = buildOperator(
+    expr,
+    Ops.EQUALS,
+    value,
+    ctx,
+    void 0,
+    field.type
+  );
+  return freezeResult(clause || DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
 }
-var normalizePairs = (pairs, parseValue) => {
-  return pairs.map(([field, rawValue]) => {
-    const parsed = parseValue(rawValue, field);
-    return {
-      [field]: parsed.nulls !== void 0 ? { sort: parsed.direction, nulls: parsed.nulls } : parsed.direction
-    };
-  });
-};
-function normalizeOrderByInput(orderBy, parseValue) {
-  if (!isNotNullish(orderBy)) return [];
-  if (Array.isArray(orderBy)) {
-    const pairs = orderBy.map(assertSingleFieldObject);
-    return normalizePairs(pairs, parseValue);
+function buildOperator(expr, op, val, ctx, mode, fieldType) {
+  if (fieldType && isArrayType(fieldType)) {
+    return buildArrayOperator(expr, op, val, ctx.params, fieldType, ctx.dialect);
   }
-  if (isPlainObject(orderBy)) {
-    return normalizePairs(Object.entries(orderBy), parseValue);
+  if (fieldType && isJsonType(fieldType)) {
+    const JSON_OPS = /* @__PURE__ */ new Set([
+      Ops.PATH,
+      Ops.STRING_CONTAINS,
+      Ops.STRING_STARTS_WITH,
+      Ops.STRING_ENDS_WITH
+    ]);
+    if (JSON_OPS.has(op)) {
+      return buildJsonOperator(expr, op, val, ctx.params, ctx.dialect);
+    }
   }
-  throw new Error("orderBy must be an object or array of objects");
+  return buildScalarOperator(
+    expr,
+    op,
+    val,
+    ctx.params,
+    mode,
+    fieldType,
+    ctx.dialect
+  );
 }
 
-// src/builder/pagination.ts
-var MAX_LIMIT_OFFSET = 2147483647;
-function parseDirectionRaw(raw, errorLabel) {
-  const s = String(raw).toLowerCase();
-  if (s === "asc" || s === "desc") return s;
-  throw new Error(`Invalid ${errorLabel}: ${raw}`);
-}
-function parseNullsRaw(raw, errorLabel) {
-  if (!isNotNullish(raw)) return void 0;
-  const s = String(raw).toLowerCase();
-  if (s === "first" || s === "last") return s;
-  throw new Error(`Invalid ${errorLabel}: ${raw}`);
-}
-function requireOrderByObject(v, errorPrefix) {
-  if (!isPlainObject(v) || !("sort" in v)) {
-    throw new Error(`${errorPrefix} must be 'asc' | 'desc' or { sort, nulls? }`);
-  }
-  return v;
+// src/builder/shared/alias-generator.ts
+function toSafeSqlIdentifier(input) {
+  const raw = String(input);
+  const cleaned = raw.replace(/\W/g, "_");
+  const startsOk = /^[a-zA-Z_]/.test(cleaned);
+  const base = startsOk ? cleaned : `_${cleaned}`;
+  const fallback = base.length > 0 ? base : "_t";
+  const lowered = fallback.toLowerCase();
+  return SQL_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
 }
-function assertAllowedOrderByKeys(obj, fieldName) {
-  const allowed = /* @__PURE__ */ new Set(["sort", "nulls"]);
-  for (const k of Object.keys(obj)) {
-    if (!allowed.has(k)) {
-      throw new Error(
-        fieldName ? `Unsupported orderBy key '${k}' for field '${fieldName}'` : `Unsupported orderBy key '${k}'`
-      );
+function createAliasGenerator(maxAliases = 1e4) {
+  let counter = 0;
+  const usedAliases = /* @__PURE__ */ new Set();
+  return {
+    next(baseName) {
+      if (usedAliases.size >= maxAliases) {
+        throw new Error(
+          `Alias generator exceeded maximum of ${maxAliases} aliases. This indicates a query complexity issue or potential infinite loop.`
+        );
+      }
+      const base = toSafeSqlIdentifier(baseName);
+      const suffix = `_${counter}`;
+      const maxLen = 63;
+      const baseMax = Math.max(1, maxLen - suffix.length);
+      const trimmedBase = base.length > baseMax ? base.slice(0, baseMax) : base;
+      const alias = `${trimmedBase}${suffix}`;
+      counter += 1;
+      if (usedAliases.has(alias)) {
+        throw new Error(
+          `CRITICAL: Duplicate alias '${alias}' at counter=${counter}. This indicates a bug in alias generation logic.`
+        );
+      }
+      usedAliases.add(alias);
+      return alias;
     }
-  }
+  };
 }
-function parseOrderByValue(v, fieldName) {
-  const errorPrefix = fieldName ? `orderBy for '${fieldName}'` : "orderBy value";
-  if (typeof v === "string") {
-    return { direction: parseDirectionRaw(v, `${errorPrefix} direction`) };
+var MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
+function assertSameLength(params, mappings) {
+  if (params.length !== mappings.length) {
+    throw new Error(
+      `CRITICAL: State corruption - params=${params.length}, mappings=${mappings.length}`
+    );
   }
-  const obj = requireOrderByObject(v, errorPrefix);
-  const direction = parseDirectionRaw(obj.sort, `${errorPrefix}.sort`);
-  const nulls = parseNullsRaw(obj.nulls, `${errorPrefix}.nulls`);
-  assertAllowedOrderByKeys(obj, fieldName);
-  return { direction, nulls };
 }
-function normalizeFiniteInteger(name, v) {
-  if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
-    throw new Error(`${name} must be an integer`);
+function assertValidNextIndex(index) {
+  if (!Number.isInteger(index) || index < 1) {
+    throw new Error(`CRITICAL: Index must be integer >= 1, got ${index}`);
   }
-  return v;
 }
-function normalizeNonNegativeInt(name, v) {
-  if (isDynamicParameter(v)) return v;
-  const n = normalizeFiniteInteger(name, v);
-  if (n < 0) {
-    throw new Error(`${name} must be >= 0`);
-  }
-  if (n > MAX_LIMIT_OFFSET) {
-    throw new Error(`${name} must be <= ${MAX_LIMIT_OFFSET}`);
+function assertNextIndexMatches(mappingsLength, nextIndex) {
+  const expected = mappingsLength + 1;
+  if (nextIndex !== expected) {
+    throw new Error(
+      `CRITICAL: Next index mismatch - expected ${expected}, got ${nextIndex}`
+    );
   }
-  return n;
 }
-function hasNonNullishProp(v, key) {
-  return isPlainObject(v) && key in v && isNotNullish(v[key]);
-}
-function normalizeIntegerOrDynamic(name, v) {
-  if (isDynamicParameter(v)) return v;
-  return normalizeFiniteInteger(name, v);
-}
-function readSkipTake(relArgs) {
-  const hasSkip = hasNonNullishProp(relArgs, "skip");
-  const hasTake = hasNonNullishProp(relArgs, "take");
-  if (!hasSkip && !hasTake) {
-    return {
-      hasSkip: false,
-      hasTake: false,
-      skipVal: void 0,
-      takeVal: void 0
-    };
+function assertSequentialIndex(actual, expected) {
+  if (actual !== expected) {
+    throw new Error(
+      `CRITICAL: Indices must be sequential from 1..N. Expected ${expected}, got ${actual}`
+    );
   }
-  const obj = relArgs;
-  const skipVal = hasSkip ? normalizeNonNegativeInt("skip", obj.skip) : void 0;
-  const takeVal = hasTake ? normalizeIntegerOrDynamic("take", obj.take) : void 0;
-  return { hasSkip, hasTake, skipVal, takeVal };
 }
-function buildOrderByFragment(entries, alias, dialect, model) {
-  if (entries.length === 0) return "";
-  const out = [];
-  for (const e of entries) {
-    const dir = e.direction.toUpperCase();
-    const c = col(alias, e.field, model);
-    if (dialect === "postgres") {
-      const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
-      out.push(`${c} ${dir}${nulls}`);
-      continue;
-    }
-    if (isNotNullish(e.nulls)) {
-      const isNullExpr = `(${c} IS NULL)`;
-      const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
-      out.push(`${isNullExpr} ${nullRankDir}`);
-      out.push(`${c} ${dir}`);
-      continue;
-    }
-    out.push(`${c} ${dir}`);
+function assertExactlyOneOfDynamicOrValue(m) {
+  const hasDynamic = typeof m.dynamicName === "string";
+  const hasStatic = m.value !== void 0;
+  if (hasDynamic === hasStatic) {
+    throw new Error(
+      `CRITICAL: ParamMap ${m.index} must have exactly one of dynamicName or value`
+    );
   }
-  return out.join(SQL_SEPARATORS.ORDER_BY);
 }
-function defaultNullsFor(dialect, direction) {
-  if (dialect === "postgres") {
-    return direction === "asc" ? "last" : "first";
+function normalizeDynamicNameOrThrow(dynamicName, index) {
+  const dn = dynamicName.trim();
+  if (dn.length === 0) {
+    throw new Error(`CRITICAL: dynamicName cannot be empty (index=${index})`);
   }
-  return direction === "asc" ? "first" : "last";
+  return dn;
 }
-function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
-  const existing = /* @__PURE__ */ new Map();
-  for (const e of orderEntries) existing.set(e.field, e);
-  const out = [...orderEntries];
-  for (const [field] of cursorEntries) {
-    if (!existing.has(field)) {
-      out.push({ field, direction: "asc" });
-      existing.set(field, out[out.length - 1]);
-    }
+function assertUniqueDynamicName(dn, seen) {
+  if (seen.has(dn)) {
+    throw new Error(`CRITICAL: Duplicate dynamic param name in mappings: ${dn}`);
   }
-  return out;
+  seen.add(dn);
 }
-function buildCursorFilterParts(cursor, cursorAlias, params, model) {
-  const entries = Object.entries(cursor);
-  if (entries.length === 0) {
-    throw new Error("cursor must have at least one field");
-  }
-  const placeholdersByField = /* @__PURE__ */ new Map();
-  const parts = [];
-  for (const [field, value] of entries) {
-    const c = `${cursorAlias}.${quote(field)}`;
-    if (value === null) {
-      parts.push(`${c} IS NULL`);
-      continue;
-    }
-    const ph = addAutoScoped(params, value, `cursor.filter.${field}`);
-    placeholdersByField.set(field, ph);
-    parts.push(`${c} = ${ph}`);
+function validateMappingEntry(m, expectedIndex, seenDynamic) {
+  assertSequentialIndex(m.index, expectedIndex);
+  assertExactlyOneOfDynamicOrValue(m);
+  if (typeof m.dynamicName === "string") {
+    const dn = normalizeDynamicNameOrThrow(m.dynamicName, m.index);
+    assertUniqueDynamicName(dn, seenDynamic);
   }
-  return {
-    whereSql: parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`,
-    placeholdersByField
-  };
-}
-function cursorValueExpr(tableName, cursorAlias, cursorWhereSql, field, model) {
-  const colName = quote(field);
-  return `(SELECT ${cursorAlias}.${colName} ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
 }
-function buildCursorRowExistsExpr(tableName, cursorAlias, cursorWhereSql) {
-  return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
+function validateMappings(mappings) {
+  const seenDynamic = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mappings.length; i++) {
+    validateMappingEntry(mappings[i], i + 1, seenDynamic);
+  }
 }
-function buildCursorEqualityExpr(columnExpr, valueExpr) {
-  return `((${valueExpr} IS NULL AND ${columnExpr} IS NULL) OR (${valueExpr} IS NOT NULL AND ${columnExpr} = ${valueExpr}))`;
+function validateState(params, mappings, index) {
+  assertSameLength(params, mappings);
+  assertValidNextIndex(index);
+  if (mappings.length === 0) return;
+  validateMappings(mappings);
+  assertNextIndexMatches(mappings.length, index);
 }
-function buildCursorInequalityExpr(columnExpr, direction, nulls, valueExpr) {
-  const op = direction === "asc" ? ">" : "<";
-  if (nulls === "first") {
-    return `(CASE WHEN ${valueExpr} IS NULL THEN (${columnExpr} IS NOT NULL) ELSE (${columnExpr} ${op} ${valueExpr}) END)`;
+function normalizeValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
   }
-  return `(CASE WHEN ${valueExpr} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${valueExpr}) OR (${columnExpr} IS NULL)) END)`;
+  return value;
 }
-function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params, model) {
-  const parts = [];
-  for (const [field, value] of Object.entries(cursor)) {
-    const c = col(outerAlias, field, model);
-    if (value === null) {
-      parts.push(`${c} IS NULL`);
-      continue;
+function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
+  let index = startIndex;
+  const params = [...initialParams];
+  const mappings = [...initialMappings];
+  const dynamicNameToIndex = /* @__PURE__ */ new Map();
+  for (const m of initialMappings) {
+    if (typeof m.dynamicName === "string") {
+      dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
     }
-    const existing = placeholdersByField.get(field);
-    if (typeof existing === "string" && existing.length > 0) {
-      parts.push(`${c} = ${existing}`);
-      continue;
+  }
+  function assertCanAdd() {
+    if (index > MAX_PARAM_INDEX) {
+      throw new Error(
+        `CRITICAL: Cannot add param - would overflow MAX_SAFE_INTEGER. Current index: ${index}`
+      );
     }
-    const ph = addAutoScoped(params, value, `cursor.outerMatch.${field}`);
-    parts.push(`${c} = ${ph}`);
   }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
-}
-function buildOrderEntries(orderBy) {
-  const normalized = normalizeOrderByInput(orderBy, parseOrderByValue);
-  const entries = [];
-  for (const item of normalized) {
-    for (const [field, value] of Object.entries(item)) {
-      if (typeof value === "string") {
-        entries.push({ field, direction: value });
-      } else {
-        entries.push({
-          field,
-          direction: value.sort,
-          nulls: value.nulls
-        });
-      }
+  function normalizeDynamicName(dynamicName) {
+    const dn = dynamicName.trim();
+    if (dn.length === 0) {
+      throw new Error("CRITICAL: dynamicName cannot be empty");
     }
+    return dn;
   }
-  return entries;
-}
-function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
-  var _a;
-  const d = dialect != null ? dialect : getGlobalDialect();
-  const cursorEntries = Object.entries(cursor);
-  if (cursorEntries.length === 0) {
-    throw new Error("cursor must have at least one field");
+  function format(position) {
+    return `$${position}`;
+  }
+  function addDynamic(dynamicName) {
+    const dn = normalizeDynamicName(dynamicName);
+    const existing = dynamicNameToIndex.get(dn);
+    if (existing !== void 0) {
+      return format(existing);
+    }
+    const position = index;
+    dynamicNameToIndex.set(dn, position);
+    params.push(void 0);
+    mappings.push({ index: position, dynamicName: dn });
+    index++;
+    return format(position);
+  }
+  function addStatic(value) {
+    const position = index;
+    const normalizedValue = normalizeValue(value);
+    params.push(normalizedValue);
+    mappings.push({ index: position, value: normalizedValue });
+    index++;
+    return format(position);
   }
-  const cursorAlias = "__tp_cursor_src";
-  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, cursorAlias, params);
-  let orderEntries = buildOrderEntries(orderBy);
-  if (orderEntries.length === 0) {
-    orderEntries = cursorEntries.map(([field]) => ({
-      field,
-      direction: "asc"
-    }));
-  } else {
-    orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
+  function add(value, dynamicName) {
+    assertCanAdd();
+    return dynamicName === void 0 ? addStatic(value) : addDynamic(dynamicName);
   }
-  const existsExpr = buildCursorRowExistsExpr(
-    tableName,
-    cursorAlias,
-    cursorWhereSql
-  );
-  const outerCursorMatch = buildOuterCursorMatch(
-    cursor,
-    alias,
-    placeholdersByField,
-    params,
-    model
-  );
-  const orClauses = [];
-  for (let level = 0; level < orderEntries.length; level++) {
-    const andParts = [];
-    for (let i = 0; i < level; i++) {
-      const e2 = orderEntries[i];
-      const c2 = col(alias, e2.field, model);
-      const v2 = cursorValueExpr(
-        tableName,
-        cursorAlias,
-        cursorWhereSql,
-        e2.field);
-      andParts.push(buildCursorEqualityExpr(c2, v2));
+  function addAuto(value) {
+    if (isDynamicParameter(value)) {
+      const dynamicName = extractDynamicName(value);
+      return add(void 0, dynamicName);
     }
-    const e = orderEntries[level];
-    const c = col(alias, e.field, model);
-    const v = cursorValueExpr(
-      tableName,
-      cursorAlias,
-      cursorWhereSql,
-      e.field);
-    const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
-    andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, v));
-    orClauses.push(`(${andParts.join(SQL_SEPARATORS.CONDITION_AND)})`);
+    return add(value);
   }
-  const exclusive = orClauses.join(SQL_SEPARATORS.CONDITION_OR);
-  return `(${existsExpr} ${SQL_SEPARATORS.CONDITION_AND} ((${exclusive})${SQL_SEPARATORS.CONDITION_OR}(${outerCursorMatch})))`;
-}
-function buildOrderBy(orderBy, alias, dialect, model) {
-  const entries = buildOrderEntries(orderBy);
-  if (entries.length === 0) return "";
-  const d = dialect != null ? dialect : getGlobalDialect();
-  return buildOrderByFragment(entries, alias, d, model);
+  function snapshot() {
+    return Object.freeze({
+      index,
+      params: Object.freeze([...params]),
+      mappings: Object.freeze([...mappings])
+    });
+  }
+  return {
+    add,
+    addAuto,
+    snapshot,
+    get index() {
+      return index;
+    }
+  };
 }
-function buildOrderByClause(args, alias, dialect, model) {
-  if (!isNotNullish(args.orderBy)) return "";
-  const result = buildOrderBy(args.orderBy, alias, dialect, model);
-  if (!isNonEmptyString(result)) {
+function createParamStore(startIndex = 1) {
+  if (!Number.isInteger(startIndex) || startIndex < 1) {
+    throw new Error(`Start index must be integer >= 1, got ${startIndex}`);
+  }
+  if (startIndex > MAX_PARAM_INDEX) {
     throw new Error(
-      "buildOrderByClause: orderBy specified but produced empty result"
+      `Start index too high (${startIndex}), risk of overflow at MAX_SAFE_INTEGER`
     );
   }
-  return result;
+  return createStoreInternal(startIndex);
 }
-function normalizeTakeLike(v) {
-  const n = normalizeIntLike("take", v, {
-    min: Number.MIN_SAFE_INTEGER,
-    max: MAX_LIMIT_OFFSET,
-    allowZero: true
-  });
-  if (typeof n === "number") {
-    if (n === 0) return 0;
-  }
-  return n;
+function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
+  validateState([...existingParams], [...existingMappings], nextIndex);
+  return createStoreInternal(
+    nextIndex,
+    [...existingParams],
+    [...existingMappings]
+  );
 }
-function normalizeSkipLike(v) {
-  return normalizeIntLike("skip", v, {
-    min: 0,
-    max: MAX_LIMIT_OFFSET,
-    allowZero: true
+
+// src/builder/shared/state.ts
+function toPublicResult(clause, joins, params) {
+  const snapshot = params.snapshot();
+  return Object.freeze({
+    clause: clause || DEFAULT_WHERE_CLAUSE,
+    joins: Object.freeze([...joins]),
+    params: snapshot.params,
+    paramMappings: snapshot.mappings,
+    nextParamIndex: snapshot.index
   });
 }
-function getPaginationParams(method, args) {
-  if (method === "findMany") {
-    return {
-      take: normalizeTakeLike(args.take),
-      skip: normalizeSkipLike(args.skip),
-      cursor: args.cursor
-    };
-  }
-  if (method === "findFirst") {
-    const skip = normalizeSkipLike(args.skip);
-    return { take: 1, skip: skip != null ? skip : 0 };
-  }
-  if (method === "findUnique") {
-    return { take: 1, skip: 0 };
+
+// src/builder/where.ts
+function buildWhereClause(where, options) {
+  var _a, _b, _c, _d, _e;
+  const dialect = options.dialect || getGlobalDialect();
+  const params = (_a = options.params) != null ? _a : createParamStore();
+  const ctx = {
+    alias: options.alias,
+    model: options.model,
+    schemaModels: (_b = options.schemaModels) != null ? _b : [],
+    path: (_c = options.path) != null ? _c : [],
+    isSubquery: (_d = options.isSubquery) != null ? _d : false,
+    aliasGen: (_e = options.aliasGen) != null ? _e : createAliasGenerator(),
+    dialect,
+    params,
+    depth: 0
+  };
+  const result = whereBuilderInstance.build(where, ctx);
+  const publicResult = toPublicResult(result.clause, result.joins, params);
+  if (!options.isSubquery) {
+    const nums = [...publicResult.clause.matchAll(/\$(\d+)/g)].map(
+      (m) => parseInt(m[1], 10)
+    );
+    if (nums.length > 0) {
+      const min = Math.min(...nums);
+      if (min === 1) {
+        validateParamConsistency(publicResult.clause, publicResult.params);
+      } else {
+        validateParamConsistencyFragment(
+          publicResult.clause,
+          publicResult.params
+        );
+      }
+    }
   }
-  return {};
+  return publicResult;
 }
 
 // src/builder/select/fields.ts
@@ -3328,8 +3324,8 @@ function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
   const replacement = `${outerAlias}.`;
   return orderBy.split(needle).join(replacement);
 }
-function buildDistinctColumns(distinct, fromAlias) {
-  return distinct.map((f) => col(fromAlias, f)).join(SQL_SEPARATORS.FIELD_LIST);
+function buildDistinctColumns(distinct, fromAlias, model) {
+  return distinct.map((f) => col(fromAlias, f, model)).join(SQL_SEPARATORS.FIELD_LIST);
 }
 function buildOutputColumns(scalarNames, includeNames, hasCount) {
   const outputCols = [...scalarNames, ...includeNames];
@@ -3343,13 +3339,13 @@ function buildOutputColumns(scalarNames, includeNames, hasCount) {
   return formatted;
 }
 function buildWindowOrder(args) {
-  const { baseOrder, idField, fromAlias } = args;
+  const { baseOrder, idField, fromAlias, model } = args;
   const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase());
   const hasIdInOrder = orderFields.some(
     (f) => f.startsWith(`${fromAlias}.id `) || f.startsWith(`${fromAlias}."id" `)
   );
   if (hasIdInOrder) return baseOrder;
-  const idTiebreaker = idField ? `, ${col(fromAlias, "id")} ASC` : "";
+  const idTiebreaker = idField ? `, ${col(fromAlias, "id", model)} ASC` : "";
   return `${baseOrder}${idTiebreaker}`;
 }
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
@@ -3366,14 +3362,17 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     includeNames,
     hasCount
   );
-  const distinctCols = buildDistinctColumns([...distinct], from.alias);
-  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
-  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
+  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f, model)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
+  const idField = model.fields.find(
+    (f) => f.name === "id" && !f.isRelation
+  );
   const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
   const windowOrder = buildWindowOrder({
     baseOrder,
     idField,
-    fromAlias: from.alias
+    fromAlias: from.alias,
+    model
   });
   const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, `"__tp_distinct"`) : replaceOrderByAlias(fallbackOrder, from.alias, `"__tp_distinct"`);
   const joins = buildJoinsSql(whereJoins, countJoins);
@@ -3484,9 +3483,9 @@ function withCountJoins(spec, countJoins, whereJoins) {
     whereJoins: [...whereJoins || [], ...countJoins || []]
   });
 }
-function buildPostgresDistinctOnClause(fromAlias, distinct) {
+function buildPostgresDistinctOnClause(fromAlias, distinct, model) {
   if (!isNonEmptyArray(distinct)) return null;
-  const distinctCols = buildDistinctColumns([...distinct], fromAlias);
+  const distinctCols = buildDistinctColumns([...distinct], fromAlias, model);
   return `${SQL_TEMPLATES.DISTINCT_ON} (${distinctCols})`;
 }
 function pushJoinGroups(parts, ...groups) {
@@ -3516,7 +3515,8 @@ function constructFinalSql(spec) {
     method,
     cursorClause,
     params,
-    dialect
+    dialect,
+    model
   } = spec;
   const useWindowDistinct = hasWindowDistinct(spec);
   assertDistinctAllowed(method, useWindowDistinct);
@@ -3530,7 +3530,7 @@ function constructFinalSql(spec) {
     return finalizeSql(sql2, params);
   }
   const parts = [SQL_TEMPLATES.SELECT];
-  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct) : null;
+  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct, model) : null;
   if (distinctOn) parts.push(distinctOn);
   const baseSelect = (select != null ? select : "").trim();
   const fullSelectList = buildSelectList(baseSelect, includeCols);
@@ -3790,17 +3790,17 @@ function getModelFieldMap(model) {
 function isTruthySelection(v) {
   return v === true;
 }
-function aggExprForField(aggKey, field, alias) {
+function aggExprForField(aggKey, field, alias, model) {
   if (aggKey === "_count") {
-    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field)})`;
+    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field, model)})`;
   }
   if (field === "_all") {
     throw new Error(`'${aggKey}' does not support '_all'`);
   }
-  if (aggKey === "_sum") return `SUM(${col(alias, field)})`;
-  if (aggKey === "_avg") return `AVG(${col(alias, field)})`;
-  if (aggKey === "_min") return `MIN(${col(alias, field)})`;
-  return `MAX(${col(alias, field)})`;
+  if (aggKey === "_sum") return `SUM(${col(alias, field, model)})`;
+  if (aggKey === "_avg") return `AVG(${col(alias, field, model)})`;
+  if (aggKey === "_min") return `MIN(${col(alias, field, model)})`;
+  return `MAX(${col(alias, field, model)})`;
 }
 function buildComparisonOp(op) {
   const sqlOp = COMPARISON_OPS[op];
@@ -3981,7 +3981,7 @@ function buildHavingForAggregateFirstShape(aggKey, target, alias, params, dialec
   for (const [field, filter] of Object.entries(target)) {
     assertHavingAggTarget(aggKey, field, model);
     if (!isPlainObject(filter) || Object.keys(filter).length === 0) continue;
-    const expr = aggExprForField(aggKey, field, alias);
+    const expr = aggExprForField(aggKey, field, alias, model);
     out.push(...buildHavingOpsForExpr(expr, filter, params, dialect));
   }
   return out;
@@ -3998,7 +3998,7 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
     assertAggregateFieldType(aggKey, field.type, field.name, model.name);
     const entries = Object.entries(aggFilter);
     if (entries.length === 0) continue;
-    const expr = aggExprForField(aggKey, fieldName, alias);
+    const expr = aggExprForField(aggKey, fieldName, alias, model);
     for (const [op, val] of entries) {
       if (op === "mode") continue;
       const built = buildSimpleComparison(expr, op, val, params, dialect);
@@ -4037,10 +4037,10 @@ function assertCountableScalarField(fieldMap, model, fieldName) {
     );
   }
 }
-function pushCountField(fields, alias, fieldName) {
+function pushCountField(fields, alias, fieldName, model) {
   const outAlias = `_count.${fieldName}`;
   fields.push(
-    `COUNT(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `COUNT(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addCountFields(fields, countArg, alias, model, fieldMap) {
@@ -4058,7 +4058,7 @@ function addCountFields(fields, countArg, alias, model, fieldMap) {
   );
   for (const [f] of selected) {
     assertCountableScalarField(fieldMap, model, f);
-    pushCountField(fields, alias, f);
+    pushCountField(fields, alias, f, model);
   }
 }
 function getAggregateSelectionObject(args, agg) {
@@ -4079,10 +4079,10 @@ function assertAggregatableScalarField(fieldMap, model, agg, fieldName) {
   }
   return field;
 }
-function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName) {
+function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
   const outAlias = `${agg}.${fieldName}`;
   fields.push(
-    `${aggFn}(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `${aggFn}(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addAggregateFields(fields, args, alias, model, fieldMap) {
@@ -4100,7 +4100,7 @@ function addAggregateFields(fields, args, alias, model, fieldMap) {
         fieldName
       );
       assertAggregateFieldType(agg, field.type, fieldName, model.name);
-      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName);
+      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model);
     }
   }
 }
@@ -4163,7 +4163,7 @@ function assertGroupByBy(args, model) {
   return byFields;
 }
 function buildGroupBySelectParts(args, alias, model, byFields) {
-  const groupCols = byFields.map((f) => col(alias, f));
+  const groupCols = byFields.map((f) => col(alias, f, model));
   const groupFields = groupCols.join(SQL_SEPARATORS.FIELD_LIST);
   const aggFields = buildAggregateFields(args, alias, model);
   const selectFields = isNonEmptyArray(aggFields) ? groupCols.concat(aggFields).join(SQL_SEPARATORS.FIELD_LIST) : groupCols.join(SQL_SEPARATORS.FIELD_LIST);
@@ -4507,35 +4507,301 @@ function transformQueryResults(method, results) {
   const transformer = RESULT_TRANSFORMERS[method];
   return transformer ? transformer(results) : results;
 }
-var ACCELERATED_METHODS = /* @__PURE__ */ new Set([
-  "findMany",
-  "findFirst",
-  "findUnique",
-  "count",
-  "aggregate",
-  "groupBy"
-]);
+
+// src/utils/s3-fifo.ts
+function withDispose(it) {
+  const anyIt = it;
+  if (anyIt[Symbol.dispose] === void 0) {
+    anyIt[Symbol.dispose] = () => {
+    };
+  }
+  return it;
+}
+var BoundedCache = class {
+  constructor(maxSize) {
+    this.map = /* @__PURE__ */ new Map();
+    this.ghost = /* @__PURE__ */ new Set();
+    this.smallHead = null;
+    this.smallTail = null;
+    this.smallSize = 0;
+    this.mainHead = null;
+    this.mainTail = null;
+    this.mainSize = 0;
+    this.maxSize = maxSize;
+    this.smallLimit = Math.max(1, Math.floor(maxSize * 0.1));
+    this.mainLimit = maxSize - this.smallLimit;
+    this.ghostLimit = this.mainLimit;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    node.freq = Math.min(node.freq + 1, 3);
+    return node.value;
+  }
+  set(key, value) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      return this;
+    }
+    if (this.ghost.has(key)) {
+      this.ghost.delete(key);
+      const node2 = this.createNode(key, value, "main");
+      this.map.set(key, node2);
+      this.pushMain(node2);
+      if (this.mainSize > this.mainLimit) this.evictMain();
+      return this;
+    }
+    const node = this.createNode(key, value, "small");
+    this.map.set(key, node);
+    this.pushSmall(node);
+    if (this.size > this.maxSize) {
+      if (this.smallSize > this.smallLimit) this.evictSmall();
+      else this.evictMain();
+    }
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.map.delete(key);
+    this.removeNode(node);
+    return true;
+  }
+  clear() {
+    this.map.clear();
+    this.ghost.clear();
+    this.smallHead = this.smallTail = null;
+    this.mainHead = this.mainTail = null;
+    this.smallSize = this.mainSize = 0;
+  }
+  keys() {
+    return withDispose(
+      (function* (self) {
+        for (const key of self.map.keys()) yield key;
+      })(this)
+    );
+  }
+  values() {
+    return withDispose(
+      (function* (self) {
+        for (const node of self.map.values()) yield node.value;
+      })(this)
+    );
+  }
+  entries() {
+    return withDispose(
+      (function* (self) {
+        for (const [key, node] of self.map.entries())
+          yield [key, node.value];
+      })(this)
+    );
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [key, node] of this.map.entries()) {
+      callbackfn.call(thisArg, node.value, key, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "BoundedCache";
+  }
+  createNode(key, value, queue) {
+    return { key, value, freq: 0, queue, prev: null, next: null };
+  }
+  pushSmall(node) {
+    node.next = this.smallHead;
+    node.prev = null;
+    if (this.smallHead) this.smallHead.prev = node;
+    else this.smallTail = node;
+    this.smallHead = node;
+    this.smallSize++;
+  }
+  pushMain(node) {
+    node.next = this.mainHead;
+    node.prev = null;
+    if (this.mainHead) this.mainHead.prev = node;
+    else this.mainTail = node;
+    this.mainHead = node;
+    this.mainSize++;
+  }
+  popSmall() {
+    if (!this.smallTail) return null;
+    const node = this.smallTail;
+    this.smallTail = node.prev;
+    if (this.smallTail) this.smallTail.next = null;
+    else this.smallHead = null;
+    node.prev = null;
+    node.next = null;
+    this.smallSize--;
+    return node;
+  }
+  popMain() {
+    if (!this.mainTail) return null;
+    const node = this.mainTail;
+    this.mainTail = node.prev;
+    if (this.mainTail) this.mainTail.next = null;
+    else this.mainHead = null;
+    node.prev = null;
+    node.next = null;
+    this.mainSize--;
+    return node;
+  }
+  removeNode(node) {
+    this.unlinkNode(node);
+    if (node.queue === "small") {
+      if (node === this.smallHead) this.smallHead = node.next;
+      if (node === this.smallTail) this.smallTail = node.prev;
+      this.smallSize--;
+    } else {
+      if (node === this.mainHead) this.mainHead = node.next;
+      if (node === this.mainTail) this.mainTail = node.prev;
+      this.mainSize--;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  unlinkNode(node) {
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+  }
+  shouldPromoteFromSmall(node) {
+    return node.freq > 1;
+  }
+  shouldRetryInMain(node) {
+    return node.freq >= 1;
+  }
+  promoteToMain(node) {
+    node.queue = "main";
+    this.pushMain(node);
+  }
+  addToGhost(key) {
+    this.ghost.add(key);
+    if (this.ghost.size <= this.ghostLimit) return;
+    const firstGhost = this.ghost.values().next().value;
+    if (firstGhost !== void 0) this.ghost.delete(firstGhost);
+  }
+  evictFromCache(node) {
+    this.map.delete(node.key);
+  }
+  evictSmall() {
+    while (this.smallSize > 0) {
+      const node = this.popSmall();
+      if (!node) return;
+      if (this.shouldPromoteFromSmall(node)) {
+        this.promoteToMain(node);
+        if (this.mainSize > this.mainLimit) {
+          this.evictMain();
+          return;
+        }
+        continue;
+      }
+      this.evictFromCache(node);
+      this.addToGhost(node.key);
+      return;
+    }
+  }
+  evictMain() {
+    while (this.mainSize > 0) {
+      const node = this.popMain();
+      if (!node) return;
+      if (this.shouldRetryInMain(node)) {
+        node.freq--;
+        this.pushMain(node);
+        continue;
+      }
+      this.evictFromCache(node);
+      return;
+    }
+  }
+};
+function createBoundedCache(maxSize) {
+  return new BoundedCache(maxSize);
+}
+
+// src/query-cache.ts
+var queryCache = createBoundedCache(1e3);
 function makeAlias(name) {
   const base = name.toLowerCase().replace(/[^a-z0-9_]/g, "_").slice(0, 50);
   const safe = /^[a-z_]/.test(base) ? base : `_${base}`;
   return SQL_RESERVED_WORDS.has(safe) ? `${safe}_t` : safe;
 }
 function toSqliteParams(sql, params) {
-  const positions = [];
-  const converted = sql.replace(/\$(\d+)/g, (_, num) => {
-    positions.push(parseInt(num, 10));
-    return "?";
-  });
-  const reordered = positions.map((pos) => {
-    const idx = pos - 1;
-    if (idx < 0 || idx >= params.length) {
-      throw new Error(`Param $${pos} out of bounds (have ${params.length})`);
+  const reorderedParams = [];
+  let lastIndex = 0;
+  const parts = [];
+  for (let i = 0; i < sql.length; i++) {
+    if (sql[i] === "$" && i + 1 < sql.length) {
+      let num = 0;
+      let j = i + 1;
+      while (j < sql.length && sql[j] >= "0" && sql[j] <= "9") {
+        num = num * 10 + (sql.charCodeAt(j) - 48);
+        j++;
+      }
+      if (j > i + 1) {
+        parts.push(sql.substring(lastIndex, i));
+        parts.push("?");
+        reorderedParams.push(params[num - 1]);
+        i = j - 1;
+        lastIndex = j;
+      }
     }
-    return params[idx];
-  });
-  return { sql: converted, params: reordered };
+  }
+  parts.push(sql.substring(lastIndex));
+  return { sql: parts.join(""), params: reorderedParams };
+}
+function canonicalizeQuery(modelName, method, args) {
+  function normalize(obj, path = []) {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (Array.isArray(obj)) return obj.map((v, i) => normalize(v, [...path, String(i)]));
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      const fullPath = [...path, key].join(".");
+      const value = obj[key];
+      if (isDynamicParameter(value)) {
+        sorted[key] = `__DYN:${fullPath}__`;
+      } else {
+        sorted[key] = normalize(value, [...path, key]);
+      }
+    }
+    return sorted;
+  }
+  const canonical = normalize(args);
+  return `${modelName}:${method}:${JSON.stringify(canonical)}`;
 }
-function buildSQL(model, models, method, args, dialect) {
+function extractValueFromPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function rebuildParams(mappings, args) {
+  const params = new Array(mappings.length);
+  for (let i = 0; i < mappings.length; i++) {
+    const mapping = mappings[i];
+    if (mapping.dynamicName !== void 0) {
+      const parts = mapping.dynamicName.split(":");
+      const path = parts.length === 2 ? parts[1] : mapping.dynamicName;
+      params[i] = extractValueFromPath(args, path);
+    } else {
+      params[i] = mapping.value;
+    }
+  }
+  return params;
+}
+function buildSQLFull(model, models, method, args, dialect) {
   const tableName = buildTableReference(
     SQL_TEMPLATES.PUBLIC_SCHEMA,
     model.tableName,
@@ -4557,32 +4823,13 @@ function buildSQL(model, models, method, args, dialect) {
   let result;
   switch (method) {
     case "aggregate":
-      result = buildAggregateSql(
-        withMethod,
-        whereResult,
-        tableName,
-        alias,
-        model
-      );
+      result = buildAggregateSql(withMethod, whereResult, tableName, alias, model);
       break;
     case "groupBy":
-      result = buildGroupBySql(
-        withMethod,
-        whereResult,
-        tableName,
-        alias,
-        model,
-        dialect
-      );
+      result = buildGroupBySql(withMethod, whereResult, tableName, alias, model, dialect);
       break;
     case "count":
-      result = buildCountSql(
-        whereResult,
-        tableName,
-        alias,
-        args.skip,
-        dialect
-      );
+      result = buildCountSql(whereResult, tableName, alias, args.skip, dialect);
       break;
     default:
       result = buildSelectSql({
@@ -4595,7 +4842,35 @@ function buildSQL(model, models, method, args, dialect) {
         dialect
       });
   }
-  return dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
+  const finalResult = dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
+  return __spreadProps(__spreadValues({}, finalResult), {
+    paramMappings: result.paramMappings
+  });
+}
+function buildSQLWithCache(model, models, method, args, dialect) {
+  const cacheKey = canonicalizeQuery(model.name, method, args);
+  const cached = queryCache.get(cacheKey);
+  if (cached) {
+    const params = rebuildParams(cached.paramMappings, args);
+    return { sql: cached.sql, params };
+  }
+  const result = buildSQLFull(model, models, method, args, dialect);
+  queryCache.set(cacheKey, {
+    sql: result.sql,
+    paramMappings: result.paramMappings
+  });
+  return { sql: result.sql, params: result.params };
+}
+var ACCELERATED_METHODS = /* @__PURE__ */ new Set([
+  "findMany",
+  "findFirst",
+  "findUnique",
+  "count",
+  "aggregate",
+  "groupBy"
+]);
+function buildSQL(model, models, method, args, dialect) {
+  return buildSQLWithCache(model, models, method, args, dialect);
 }
 function executePostgres(client, sql, params) {
   return __async(this, null, function* () {