prisma-sql 1.58.0 → 1.60.0

package/dist/generator.cjs

@@ -14,6 +14,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -30,6 +33,18 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve3, reject) => {
     var fulfilled = (value) => {
@@ -56,7 +71,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.58.0",
+      version: "1.60.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -94,7 +109,7 @@ var require_package = __commonJS({
         "prisma:migrate": "npx prisma migrate dev --schema=tests/prisma/schema.prisma",
         "prisma:reset": "npx prisma db push --force-reset --skip-generate --schema=tests/prisma/schema.prisma",
         prepublishOnly: "npm run build",
-        "sonar-cli": "sonar-scanner   -Dsonar.projectKey=prisma-sql   -Dsonar.sources=./src   -Dsonar.host.url=http://localhost:9000   -Dsonar.login=sqp_9fe07460d0aa83f711d0edf4f317f05019d0613b",
+        "sonar-cli": "sonar-scanner   -Dsonar.projectKey=b   -Dsonar.sources=./src   -Dsonar.host.url=http://localhost:9000   -Dsonar.login=sqp_0d5fbc16a275fceb6458d193a8aa8a975956edc1",
         sonar: "npm run sonar-cli && npx tsx scripts/sonar.ts"
       },
       keywords: [
@@ -152,154 +167,6 @@ var require_package = __commonJS({
   }
 });
 
-// src/builder/shared/constants.ts
-var IS_PRODUCTION = process.env.NODE_ENV === "production";
-var SQL_SEPARATORS = Object.freeze({
-  FIELD_LIST: ", ",
-  CONDITION_AND: " AND ",
-  CONDITION_OR: " OR ",
-  ORDER_BY: ", "
-});
-var ALIAS_FORBIDDEN_KEYWORDS = /* @__PURE__ */ new Set([
-  "select",
-  "from",
-  "where",
-  "having",
-  "order",
-  "group",
-  "limit",
-  "offset",
-  "join",
-  "inner",
-  "left",
-  "right",
-  "outer",
-  "cross",
-  "full",
-  "and",
-  "or",
-  "not",
-  "by",
-  "as",
-  "on",
-  "union",
-  "intersect",
-  "except",
-  "case",
-  "when",
-  "then",
-  "else",
-  "end"
-]);
-var SQL_KEYWORDS = /* @__PURE__ */ new Set([
-  ...ALIAS_FORBIDDEN_KEYWORDS,
-  "user",
-  "users",
-  "table",
-  "column",
-  "index",
-  "values",
-  "in",
-  "like",
-  "between",
-  "is",
-  "exists",
-  "null",
-  "true",
-  "false",
-  "all",
-  "any",
-  "some",
-  "update",
-  "insert",
-  "delete",
-  "create",
-  "drop",
-  "alter",
-  "truncate",
-  "grant",
-  "revoke",
-  "exec",
-  "execute"
-]);
-var SQL_RESERVED_WORDS = SQL_KEYWORDS;
-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/utils/normalize-value.ts
 var MAX_DEPTH = 20;
 function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
@@ -307,45 +174,54 @@ function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0)
     throw new Error(`Max normalization depth exceeded (${MAX_DEPTH} levels)`);
   }
   if (value instanceof Date) {
-    const t = value.getTime();
-    if (!Number.isFinite(t)) {
-      throw new Error("Invalid Date value in SQL params");
-    }
-    return value.toISOString();
+    return normalizeDateValue(value);
   }
   if (typeof value === "bigint") {
     return value.toString();
   }
   if (Array.isArray(value)) {
-    const arrRef = value;
-    if (seen.has(arrRef)) {
-      throw new Error("Circular reference in SQL params");
-    }
-    seen.add(arrRef);
-    const out = value.map((v) => normalizeValue(v, seen, depth + 1));
-    seen.delete(arrRef);
-    return out;
+    return normalizeArrayValue(value, seen, depth);
   }
   if (value && typeof value === "object") {
-    if (value instanceof Uint8Array) return value;
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return value;
-    const proto = Object.getPrototypeOf(value);
-    const isPlain = proto === Object.prototype || proto === null;
-    if (!isPlain) return value;
-    const obj = value;
-    if (seen.has(obj)) {
-      throw new Error("Circular reference in SQL params");
-    }
-    seen.add(obj);
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-      out[k] = normalizeValue(v, seen, depth + 1);
-    }
-    seen.delete(obj);
-    return out;
+    return normalizeObjectValue(value, seen, depth);
   }
   return value;
 }
+function normalizeDateValue(date) {
+  const t = date.getTime();
+  if (!Number.isFinite(t)) {
+    throw new Error("Invalid Date value in SQL params");
+  }
+  return date.toISOString();
+}
+function normalizeArrayValue(value, seen, depth) {
+  const arrRef = value;
+  if (seen.has(arrRef)) {
+    throw new Error("Circular reference in SQL params");
+  }
+  seen.add(arrRef);
+  const out = value.map((v) => normalizeValue(v, seen, depth + 1));
+  seen.delete(arrRef);
+  return out;
+}
+function normalizeObjectValue(value, seen, depth) {
+  if (value instanceof Uint8Array) return value;
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return value;
+  const proto = Object.getPrototypeOf(value);
+  const isPlain = proto === Object.prototype || proto === null;
+  if (!isPlain) return value;
+  const obj = value;
+  if (seen.has(obj)) {
+    throw new Error("Circular reference in SQL params");
+  }
+  seen.add(obj);
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    out[k] = normalizeValue(v, seen, depth + 1);
+  }
+  seen.delete(obj);
+  return out;
+}
 
 // src/sql-builder-dialect.ts
 var globalDialect = "postgres";
@@ -525,9 +401,158 @@ function prepareArrayParam(value, dialect) {
   if (dialect === "postgres") {
     return value.map((v) => normalizeValue(v));
   }
-  return JSON.stringify(value);
+  return JSON.stringify(value.map((v) => normalizeValue(v)));
 }
 
+// src/builder/shared/constants.ts
+var IS_PRODUCTION = process.env.NODE_ENV === "production";
+var SQL_SEPARATORS = Object.freeze({
+  FIELD_LIST: ", ",
+  CONDITION_AND: " AND ",
+  CONDITION_OR: " OR ",
+  ORDER_BY: ", "
+});
+var ALIAS_FORBIDDEN_KEYWORDS = /* @__PURE__ */ new Set([
+  "select",
+  "from",
+  "where",
+  "having",
+  "order",
+  "group",
+  "limit",
+  "offset",
+  "join",
+  "inner",
+  "left",
+  "right",
+  "outer",
+  "cross",
+  "full",
+  "and",
+  "or",
+  "not",
+  "by",
+  "as",
+  "on",
+  "union",
+  "intersect",
+  "except",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end"
+]);
+var SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  ...ALIAS_FORBIDDEN_KEYWORDS,
+  "user",
+  "users",
+  "table",
+  "column",
+  "index",
+  "values",
+  "in",
+  "like",
+  "between",
+  "is",
+  "exists",
+  "null",
+  "true",
+  "false",
+  "all",
+  "any",
+  "some",
+  "update",
+  "insert",
+  "delete",
+  "create",
+  "drop",
+  "alter",
+  "truncate",
+  "grant",
+  "revoke",
+  "exec",
+  "execute"
+]);
+var SQL_RESERVED_WORDS = SQL_KEYWORDS;
+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,
+  MAX_HAVING_DEPTH: 50
+});
+
 // src/builder/shared/validators/type-guards.ts
 function isNotNullish(value) {
   return value !== null && value !== void 0;
@@ -594,73 +619,6 @@ function createError(message, ctx, code = "VALIDATION_ERROR") {
   return new SqlBuilderError(parts.join("\n"), code, ctx);
 }
 
-// src/builder/shared/model-field-cache.ts
-var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
-function quote(id) {
-  const needsQuoting2 = !/^[a-z_][a-z0-9_]*$/.test(id) || /^(select|from|where|having|order|group|limit|offset|join|inner|left|right|outer|cross|full|and|or|not|by|as|on|union|intersect|except|case|when|then|else|end|user|users|table|column|index|values|in|like|between|is|exists|null|true|false|all|any|some|update|insert|delete|create|drop|alter|truncate|grant|revoke|exec|execute)$/i.test(
-    id
-  );
-  if (needsQuoting2) {
-    return `"${id.replace(/"/g, '""')}"`;
-  }
-  return id;
-}
-function ensureFullCache(model) {
-  let cache = MODEL_CACHE.get(model);
-  if (!cache) {
-    const fieldInfo = /* @__PURE__ */ new Map();
-    const scalarFields = /* @__PURE__ */ new Set();
-    const relationFields = /* @__PURE__ */ new Set();
-    const columnMap = /* @__PURE__ */ new Map();
-    const fieldByName = /* @__PURE__ */ new Map();
-    const quotedColumns = /* @__PURE__ */ new Map();
-    for (const f of model.fields) {
-      const info = {
-        name: f.name,
-        dbName: f.dbName || f.name,
-        type: f.type,
-        isRelation: !!f.isRelation,
-        isRequired: !!f.isRequired
-      };
-      fieldInfo.set(f.name, info);
-      fieldByName.set(f.name, f);
-      if (info.isRelation) {
-        relationFields.add(f.name);
-      } else {
-        scalarFields.add(f.name);
-        const dbName = info.dbName;
-        columnMap.set(f.name, dbName);
-        quotedColumns.set(f.name, quote(dbName));
-      }
-    }
-    cache = {
-      fieldInfo,
-      scalarFields,
-      relationFields,
-      columnMap,
-      fieldByName,
-      quotedColumns
-    };
-    MODEL_CACHE.set(model, cache);
-  }
-  return cache;
-}
-function getFieldInfo(model, fieldName) {
-  return ensureFullCache(model).fieldInfo.get(fieldName);
-}
-function getScalarFieldSet(model) {
-  return ensureFullCache(model).scalarFields;
-}
-function getRelationFieldSet(model) {
-  return ensureFullCache(model).relationFields;
-}
-function getColumnMap(model) {
-  return ensureFullCache(model).columnMap;
-}
-function getQuotedColumn(model, fieldName) {
-  return ensureFullCache(model).quotedColumns.get(fieldName);
-}
-
 // src/builder/shared/validators/sql-validators.ts
 function isValidWhereClause(clause) {
   return isNotNullish(clause) && clause.trim().length > 0 && clause !== DEFAULT_WHERE_CLAUSE;
@@ -804,9 +762,90 @@ function needsQuoting(identifier) {
   return false;
 }
 
+// src/builder/shared/model-field-cache.ts
+var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
+function quoteIdent(id) {
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new Error("quoteIdent: identifier is required and cannot be empty");
+  }
+  for (let i = 0; i < id.length; i++) {
+    const code = id.charCodeAt(i);
+    if (code >= 0 && code <= 31 || code === 127) {
+      throw new Error(
+        `quoteIdent: identifier contains invalid characters: ${JSON.stringify(id)}`
+      );
+    }
+  }
+  if (needsQuoting(id)) {
+    return `"${id.replace(/"/g, '""')}"`;
+  }
+  return id;
+}
+function ensureFullCache(model) {
+  let cache = MODEL_CACHE.get(model);
+  if (!cache) {
+    const fieldInfo = /* @__PURE__ */ new Map();
+    const scalarFields = /* @__PURE__ */ new Set();
+    const relationFields = /* @__PURE__ */ new Set();
+    const columnMap = /* @__PURE__ */ new Map();
+    const fieldByName = /* @__PURE__ */ new Map();
+    const quotedColumns = /* @__PURE__ */ new Map();
+    for (const f of model.fields) {
+      const info = {
+        name: f.name,
+        dbName: f.dbName || f.name,
+        type: f.type,
+        isRelation: !!f.isRelation,
+        isRequired: !!f.isRequired
+      };
+      fieldInfo.set(f.name, info);
+      fieldByName.set(f.name, f);
+      if (info.isRelation) {
+        relationFields.add(f.name);
+      } else {
+        scalarFields.add(f.name);
+        const dbName = info.dbName;
+        columnMap.set(f.name, dbName);
+        quotedColumns.set(f.name, quoteIdent(dbName));
+      }
+    }
+    cache = {
+      fieldInfo,
+      scalarFields,
+      relationFields,
+      columnMap,
+      fieldByName,
+      quotedColumns
+    };
+    MODEL_CACHE.set(model, cache);
+  }
+  return cache;
+}
+function getFieldInfo(model, fieldName) {
+  return ensureFullCache(model).fieldInfo.get(fieldName);
+}
+function getScalarFieldSet(model) {
+  return ensureFullCache(model).scalarFields;
+}
+function getRelationFieldSet(model) {
+  return ensureFullCache(model).relationFields;
+}
+function getColumnMap(model) {
+  return ensureFullCache(model).columnMap;
+}
+function getQuotedColumn(model, fieldName) {
+  return ensureFullCache(model).quotedColumns.get(fieldName);
+}
+
 // src/builder/shared/sql-utils.ts
 function containsControlChars(s) {
-  return /[\u0000-\u001F\u007F]/.test(s);
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code >= 0 && code <= 31 || code === 127) {
+      return true;
+    }
+  }
+  return false;
 }
 function assertNoControlChars(label, s) {
   if (containsControlChars(s)) {
@@ -881,20 +920,9 @@ function parseUnquotedPart(input, start) {
   }
   return i;
 }
-function assertSafeQualifiedName(input) {
-  const raw = String(input);
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) {
-    throw new Error("tableName/tableRef is required and cannot be empty");
-  }
-  if (raw !== trimmed) {
-    throw new Error(
-      `tableName/tableRef must not contain leading/trailing whitespace: ${JSON.stringify(raw)}`
-    );
-  }
-  assertNoControlChars("tableName/tableRef", trimmed);
-  for (let i2 = 0; i2 < trimmed.length; i2++) {
-    const c = trimmed.charCodeAt(i2);
+function validateQualifiedNameFormat(trimmed) {
+  for (let i = 0; i < trimmed.length; i++) {
+    const c = trimmed.charCodeAt(i);
     if (c === 9 || c === 11 || c === 12 || c === 32) {
       throw new Error(
         `tableName/tableRef must not contain whitespace: ${JSON.stringify(trimmed)}`
@@ -911,6 +939,8 @@ function assertSafeQualifiedName(input) {
       );
     }
   }
+}
+function parseQualifiedNameParts(trimmed) {
   let i = 0;
   const n = trimmed.length;
   let parts = 0;
@@ -946,7 +976,22 @@ function assertSafeQualifiedName(input) {
     }
   }
 }
-function quote2(id) {
+function assertSafeQualifiedName(input) {
+  const raw = String(input);
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new Error("tableName/tableRef is required and cannot be empty");
+  }
+  if (raw !== trimmed) {
+    throw new Error(
+      `tableName/tableRef must not contain leading/trailing whitespace: ${JSON.stringify(raw)}`
+    );
+  }
+  assertNoControlChars("tableName/tableRef", trimmed);
+  validateQualifiedNameFormat(trimmed);
+  parseQualifiedNameParts(trimmed);
+}
+function quote(id) {
   if (isEmptyString(id)) {
     throw new Error("quote: identifier is required and cannot be empty");
   }
@@ -966,13 +1011,13 @@ function resolveColumnName(model, fieldName) {
   return columnMap.get(fieldName) || fieldName;
 }
 function quoteColumn(model, fieldName) {
-  if (!model) return quote2(fieldName);
+  if (!model) return quote(fieldName);
   const cached = getQuotedColumn(model, fieldName);
-  return cached || quote2(fieldName);
+  return cached || quote(fieldName);
 }
 function col(alias, field, model) {
   const columnName = model ? getColumnMap(model).get(field) || field : field;
-  const quoted = model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName);
+  const quoted = model ? getQuotedColumn(model, field) || quote(columnName) : quote(columnName);
   return alias + "." + quoted;
 }
 function colWithAlias(alias, field, model) {
@@ -983,9 +1028,9 @@ function colWithAlias(alias, field, model) {
     throw new Error("colWithAlias: field is required and cannot be empty");
   }
   const columnName = resolveColumnName(model, field);
-  const columnRef = alias + "." + (model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName));
+  const columnRef = alias + "." + (model ? getQuotedColumn(model, field) || quote(columnName) : quote(columnName));
   if (columnName !== field) {
-    return columnRef + " AS " + quote2(field);
+    return columnRef + " AS " + quote(field);
   }
   return columnRef;
 }
@@ -1008,7 +1053,7 @@ function buildTableReference(schemaName, tableName, dialect) {
   }
   const d = dialect != null ? dialect : "postgres";
   if (d === "sqlite") {
-    return quote2(tableName);
+    return quote(tableName);
   }
   if (isEmptyString(schemaName)) {
     throw new Error(
@@ -1035,7 +1080,7 @@ function assertSafeAlias(alias) {
   if (a !== alias) {
     throw new Error("Invalid alias: leading/trailing whitespace");
   }
-  if (/[\u0000-\u001F\u007F]/.test(a)) {
+  if (containsControlChars(a)) {
     throw new Error(
       "Invalid alias: contains unsafe characters (control characters)"
     );
@@ -1056,7 +1101,7 @@ function assertSafeAlias(alias) {
       "Invalid alias: must be a simple identifier without whitespace"
     );
   }
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(a)) {
+  if (!/^[A-Za-z_]\w*$/.test(a)) {
     throw new Error(
       `Invalid alias: must be a simple identifier (alphanumeric with underscores): "${alias}"`
     );
@@ -1104,8 +1149,7 @@ function isValidRelationField(field) {
     return false;
   const fk = normalizeKeyList(field.foreignKey);
   if (fk.length === 0) return false;
-  const refsRaw = field.references;
-  const refs = normalizeKeyList(refsRaw);
+  const refs = normalizeKeyList(field.references);
   if (refs.length === 0) {
     return fk.length === 1;
   }
@@ -1113,8 +1157,7 @@ function isValidRelationField(field) {
   return true;
 }
 function getReferenceFieldNames(field, foreignKeyCount) {
-  const refsRaw = field.references;
-  const refs = normalizeKeyList(refsRaw);
+  const refs = normalizeKeyList(field.references);
   if (refs.length === 0) {
     if (foreignKeyCount === 1) return [SPECIAL_FIELDS.ID];
     return [];
@@ -1275,29 +1318,35 @@ function normalizeOrderByInput(orderBy, parseValue) {
 }
 
 // src/builder/shared/order-by-determinism.ts
-function modelHasScalarId(model) {
-  if (!model) return false;
-  return getScalarFieldSet(model).has("id");
+function findTiebreakerField(model) {
+  if (!model) return null;
+  const scalarSet = getScalarFieldSet(model);
+  for (const f of model.fields) {
+    if (f.isId && !f.isRelation && scalarSet.has(f.name)) return f.name;
+  }
+  if (scalarSet.has("id")) return "id";
+  return null;
 }
-function hasIdTiebreaker(orderBy, parse) {
+function hasTiebreaker(orderBy, parse, field) {
   if (!isNotNullish(orderBy)) return false;
   const normalized = normalizeOrderByInput(orderBy, parse);
   return normalized.some(
-    (obj) => Object.prototype.hasOwnProperty.call(obj, "id")
+    (obj) => Object.prototype.hasOwnProperty.call(obj, field)
   );
 }
-function addIdTiebreaker(orderBy) {
-  if (Array.isArray(orderBy)) return [...orderBy, { id: "asc" }];
-  return [orderBy, { id: "asc" }];
+function addTiebreaker(orderBy, field) {
+  if (Array.isArray(orderBy)) return [...orderBy, { [field]: "asc" }];
+  return [orderBy, { [field]: "asc" }];
 }
 function ensureDeterministicOrderByInput(args) {
   const { orderBy, model, parseValue } = args;
-  if (!modelHasScalarId(model)) return orderBy;
+  const tiebreaker = findTiebreakerField(model);
+  if (!tiebreaker) return orderBy;
   if (!isNotNullish(orderBy)) {
-    return { id: "asc" };
+    return { [tiebreaker]: "asc" };
   }
-  if (hasIdTiebreaker(orderBy, parseValue)) return orderBy;
-  return addIdTiebreaker(orderBy);
+  if (hasTiebreaker(orderBy, parseValue, tiebreaker)) return orderBy;
+  return addTiebreaker(orderBy, tiebreaker);
 }
 
 // src/builder/shared/validators/field-assertions.ts
@@ -1444,11 +1493,9 @@ function defaultNullsFor(dialect, direction) {
 function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
   if (cursorEntries.length === 0) return orderEntries;
   const existing = /* @__PURE__ */ new Set();
-  for (let i = 0; i < orderEntries.length; i++)
-    existing.add(orderEntries[i].field);
+  for (const entry of orderEntries) existing.add(entry.field);
   let out = null;
-  for (let i = 0; i < cursorEntries.length; i++) {
-    const field = cursorEntries[i][0];
+  for (const [field] of cursorEntries) {
     if (!existing.has(field)) {
       if (!out) out = orderEntries.slice();
       out.push({ field, direction: "asc" });
@@ -1673,6 +1720,7 @@ function buildOrderEntries(orderBy) {
   }
   return entries;
 }
+var MAX_NOT_DEPTH = 50;
 function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
   const entries = Object.entries(val).filter(
     ([k, v]) => k !== "mode" && v !== void 0
@@ -1687,45 +1735,71 @@ function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
   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);
+function validateOperatorRequirements(op, mode, dialect) {
+  const STRING_LIKE_OPS = /* @__PURE__ */ new Set([
+    Ops.CONTAINS,
+    Ops.STARTS_WITH,
+    Ops.ENDS_WITH
+  ]);
+  if (STRING_LIKE_OPS.has(op) && !isNotNullish(dialect)) {
+    throw createError(`Like operators require a SQL dialect`, { operator: op });
   }
-  if (op === Ops.NOT && isPlainObject(val)) {
-    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
+  if ((op === Ops.IN || op === Ops.NOT_IN) && !isNotNullish(dialect)) {
+    throw createError(`IN operators require a SQL dialect`, { operator: op });
   }
-  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);
+  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && !isNotNullish(dialect)) {
+    throw createError(`Insensitive equals requires a SQL dialect`, {
+      operator: op
+    });
   }
+}
+function routeOperatorHandler(expr, op, val, params, mode, dialect) {
   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);
   }
-  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && !isNotNullish(dialect)) {
-    throw createError(`Insensitive equals requires a SQL dialect`, {
-      operator: op
-    });
+  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && isNotNullish(dialect)) {
+    const placeholder = params.addAuto(val);
+    return caseInsensitiveEquals(expr, placeholder);
+  }
+  return null;
+}
+function buildScalarOperator(expr, op, val, params, options = {}) {
+  const { mode, fieldType, dialect, depth = 0 } = options;
+  if (val === void 0) return "";
+  if (depth > MAX_NOT_DEPTH) {
+    throw new Error(
+      `NOT operator nesting too deep (max ${MAX_NOT_DEPTH} levels). This usually indicates a circular reference or adversarial input.`
+    );
+  }
+  if (val === null) {
+    return handleNullValue(expr, op);
+  }
+  if (op === Ops.NOT && isPlainObject(val)) {
+    return handleNotOperator(expr, val, params, mode, fieldType, dialect, depth);
+  }
+  if (op === Ops.NOT) {
+    const placeholder = params.addAuto(val);
+    return `${expr} <> ${placeholder}`;
+  }
+  validateOperatorRequirements(op, mode, dialect);
+  const specialHandler = routeOperatorHandler(
+    expr,
+    op,
+    val,
+    params,
+    mode,
+    dialect
+  );
+  if (specialHandler !== null) {
+    return specialHandler;
   }
   return handleComparisonOperator(expr, op, val, params);
 }
@@ -1739,7 +1813,7 @@ function normalizeMode(v) {
   if (v === Modes.DEFAULT) return Modes.DEFAULT;
   return void 0;
 }
-function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
+function handleNotOperator(expr, val, params, outerMode, fieldType, dialect, depth = 0) {
   const innerMode = normalizeMode(val.mode);
   const effectiveMode = innerMode != null ? innerMode : outerMode;
   const entries = Object.entries(val).filter(
@@ -1749,43 +1823,35 @@ function handleNotOperator(expr, val, params, outerMode, fieldType, dialect) {
   if (!isNotNullish(dialect)) {
     const clauses = [];
     for (const [subOp, subVal] of entries) {
-      const sub = buildScalarOperator(
-        expr,
-        subOp,
-        subVal,
-        params,
-        effectiveMode,
+      const sub = buildScalarOperator(expr, subOp, subVal, params, {
+        mode: effectiveMode,
         fieldType,
-        void 0
-      );
+        dialect: void 0,
+        depth: depth + 1
+      });
       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(` ${SQL_TEMPLATES.AND} `)})`;
+    const separator2 = ` ${SQL_TEMPLATES.AND} `;
+    return `${SQL_TEMPLATES.NOT} (${clauses.join(separator2)})`;
   }
+  const separator = ` ${SQL_TEMPLATES.AND} `;
   return buildNotComposite(
     expr,
     val,
     params,
     dialect,
-    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, effectiveMode, fieldType, d),
-    ` ${SQL_TEMPLATES.AND} `
+    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, {
+      mode: effectiveMode,
+      fieldType,
+      dialect: d,
+      depth: depth + 1
+    }),
+    separator
   );
 }
-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;
-    }
-  }
+function buildDynamicLikePattern(op, placeholder) {
   switch (op) {
     case Ops.CONTAINS:
       return `('%' || ${placeholder} || '%')`;
@@ -1801,7 +1867,7 @@ function handleLikeOperator(expr, op, val, params, mode, dialect) {
   if (val === void 0) return "";
   if (schemaParser.isDynamicParameter(val)) {
     const placeholder2 = params.addAuto(val);
-    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
+    const patternExpr = buildDynamicLikePattern(op, placeholder2);
     if (mode === Modes.INSENSITIVE) {
       return caseInsensitiveLike(expr, patternExpr, dialect);
     }
@@ -1979,24 +2045,42 @@ function handleArrayIsEmpty(expr, val, dialect) {
 // src/builder/where/operators-json.ts
 var SAFE_JSON_PATH_SEGMENT = /^[a-zA-Z_]\w*$/;
 var MAX_PATH_SEGMENT_LENGTH = 255;
+var MAX_PATH_SEGMENTS = 100;
+function sanitizeForError(s) {
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code >= 0 && code <= 31 || code === 127) {
+      result += `\\x${code.toString(16).padStart(2, "0")}`;
+    } else {
+      result += s[i];
+    }
+  }
+  return result;
+}
 function validateJsonPathSegments(segments) {
-  for (const segment of segments) {
+  if (segments.length > MAX_PATH_SEGMENTS) {
+    throw createError(`JSON path too long: max ${MAX_PATH_SEGMENTS} segments`, {
+      operator: Ops.PATH
+    });
+  }
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
     if (typeof segment !== "string") {
-      throw createError("JSON path segments must be strings", {
-        operator: Ops.PATH,
-        value: segment
+      throw createError(`JSON path segment at index ${i} must be string`, {
+        operator: Ops.PATH
       });
     }
     if (segment.length > MAX_PATH_SEGMENT_LENGTH) {
       throw createError(
-        `JSON path segment too long: max ${MAX_PATH_SEGMENT_LENGTH} characters`,
-        { operator: Ops.PATH, value: `[${segment.length} chars]` }
+        `JSON path segment at index ${i} too long: max ${MAX_PATH_SEGMENT_LENGTH} characters`,
+        { operator: Ops.PATH }
       );
     }
     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 }
+        `Invalid JSON path segment at index ${i}: '${sanitizeForError(segment)}'`,
+        { operator: Ops.PATH }
       );
     }
   }
@@ -2087,7 +2171,7 @@ function freezeJoins(items) {
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
-function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join3, wantNull) {
+function buildToOneNullCheck(field, parentModel, parentAlias, relTable, relAlias, join3, wantNull) {
   const isLocal = field.isForeignKeyLocal === true;
   const fkFields = normalizeKeyList(field.foreignKey);
   if (isLocal) {
@@ -2097,8 +2181,7 @@ function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join3, want
       });
     }
     const parts = fkFields.map((fk) => {
-      const safe = fk.replace(/"/g, '""');
-      const expr = `${parentAlias}."${safe}"`;
+      const expr = `${parentAlias}.${quoteColumn(parentModel, fk)}`;
       return wantNull ? `${expr} ${SQL_TEMPLATES.IS_NULL}` : `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
     });
     if (parts.length === 1) return parts[0];
@@ -2115,6 +2198,35 @@ function buildToOneNotExistsMatch(relTable, relAlias, join3, 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} ${join3} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
+function tryOptimizeNoneFilter(noneValue, ctx, relModel, relTable, relAlias, join3, sub) {
+  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) return null;
+  const checkField = relModel.fields.find(
+    (f) => !f.isRelation && f.isRequired && f.name !== "id"
+  ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
+  if (!checkField) return null;
+  const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join3}`;
+  const whereClause = `${relAlias}.${quoteColumn(relModel, checkField.name)} IS NULL`;
+  return Object.freeze({
+    clause: whereClause,
+    joins: freezeJoins([leftJoinSql])
+  });
+}
+function processRelationFilter(key, wrap, args) {
+  const { value, fieldName, ctx, relAlias, relModel, whereBuilder } = args;
+  const raw = value[key];
+  if (raw === void 0 || raw === null) return null;
+  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(" ")}` : "";
+  return wrap(sub.clause, j);
+}
 function buildListRelationFilters(args) {
   const {
     fieldName,
@@ -2135,21 +2247,16 @@ function buildListRelationFilters(args) {
       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 ${join3}`;
-        const whereClause = `${relAlias}.${quote2(checkField.name)} IS NULL`;
-        return Object.freeze({
-          clause: whereClause,
-          joins: freezeJoins([leftJoinSql])
-        });
-      }
-    }
+    const optimized = tryOptimizeNoneFilter(
+      noneValue,
+      ctx,
+      relModel,
+      relTable,
+      relAlias,
+      join3,
+      sub
+    );
+    if (optimized) return optimized;
   }
   const filters = [
     {
@@ -2170,17 +2277,8 @@ function buildListRelationFilters(args) {
   ];
   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));
+    const clause = processRelationFilter(key, wrap, args);
+    if (clause) clauses.push(clause);
   }
   if (clauses.length === 0) {
     throw createError(
@@ -2236,6 +2334,7 @@ function buildToOneRelationFilters(args) {
     const wantNull = filterKey === "is";
     const clause2 = buildToOneNullCheck(
       field,
+      ctx.model,
       ctx.alias,
       relTable,
       relAlias,
@@ -2465,7 +2564,8 @@ function buildWhereInternal(where, ctx, builder) {
   }
   const allJoins = [];
   const clauses = [];
-  for (const [key, value] of Object.entries(where)) {
+  for (const key in where) {
+    const value = where[key];
     if (value === void 0) continue;
     const result = buildWhereEntry(key, value, ctx, builder);
     appendResult(result, clauses, allJoins);
@@ -2580,15 +2680,11 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
   if (fieldType && isJsonType(fieldType) && JSON_OPS.has(op)) {
     return buildJsonOperator(expr, op, val, ctx.params, ctx.dialect);
   }
-  return buildScalarOperator(
-    expr,
-    op,
-    val,
-    ctx.params,
+  return buildScalarOperator(expr, op, val, ctx.params, {
     mode,
     fieldType,
-    ctx.dialect
-  );
+    dialect: ctx.dialect
+  });
 }
 
 // src/builder/shared/alias-generator.ts
@@ -2702,49 +2798,50 @@ function validateState(params, mappings, index) {
   validateMappings(mappings);
   assertNextIndexMatches(mappings.length, index);
 }
-function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
-  let index = startIndex;
-  const params = initialParams.length > 0 ? initialParams.slice() : [];
-  const mappings = initialMappings.length > 0 ? initialMappings.slice() : [];
+function buildDynamicNameIndex(mappings) {
   const dynamicNameToIndex = /* @__PURE__ */ new Map();
-  for (let i = 0; i < mappings.length; i++) {
-    const m = mappings[i];
+  for (const m of mappings) {
     if (typeof m.dynamicName === "string") {
       dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
     }
   }
-  let dirty = true;
-  let cachedSnapshot = null;
-  let frozenParams = null;
-  let frozenMappings = null;
-  function assertCanAdd() {
-    if (index > MAX_PARAM_INDEX) {
-      throw new Error(
-        `CRITICAL: Cannot add param - would overflow MAX_SAFE_INTEGER. Current index: ${index}`
-      );
-    }
-  }
-  function format(position) {
-    return `$${position}`;
+  return dynamicNameToIndex;
+}
+function assertCanAddParam(currentIndex) {
+  if (currentIndex > MAX_PARAM_INDEX) {
+    throw new Error(
+      `CRITICAL: Cannot add param - would overflow MAX_SAFE_INTEGER. Current index: ${currentIndex}`
+    );
   }
-  function normalizeDynamicName(dynamicName) {
-    const dn = dynamicName.trim();
-    if (dn.length === 0) {
-      throw new Error("CRITICAL: dynamicName cannot be empty");
-    }
-    return dn;
+}
+function formatPosition(position) {
+  return `$${position}`;
+}
+function validateDynamicName(dynamicName) {
+  const dn = dynamicName.trim();
+  if (dn.length === 0) {
+    throw new Error("CRITICAL: dynamicName cannot be empty");
   }
+  return dn;
+}
+function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
+  let index = startIndex;
+  const params = initialParams.length > 0 ? initialParams.slice() : [];
+  const mappings = initialMappings.length > 0 ? initialMappings.slice() : [];
+  const dynamicNameToIndex = buildDynamicNameIndex(mappings);
+  let dirty = true;
+  let cachedSnapshot = null;
   function addDynamic(dynamicName) {
-    const dn = normalizeDynamicName(dynamicName);
+    const dn = validateDynamicName(dynamicName);
     const existing = dynamicNameToIndex.get(dn);
-    if (existing !== void 0) return format(existing);
+    if (existing !== void 0) return formatPosition(existing);
     const position = index;
     dynamicNameToIndex.set(dn, position);
     params.push(void 0);
     mappings.push({ index: position, dynamicName: dn });
     index++;
     dirty = true;
-    return format(position);
+    return formatPosition(position);
   }
   function addStatic(value) {
     const position = index;
@@ -2753,10 +2850,10 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     mappings.push({ index: position, value: normalizedValue });
     index++;
     dirty = true;
-    return format(position);
+    return formatPosition(position);
   }
   function add(value, dynamicName) {
-    assertCanAdd();
+    assertCanAddParam(index);
     return dynamicName === void 0 ? addStatic(value) : addDynamic(dynamicName);
   }
   function addAuto(value) {
@@ -2768,17 +2865,13 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
   }
   function snapshot() {
     if (!dirty && cachedSnapshot) return cachedSnapshot;
-    if (!frozenParams) frozenParams = Object.freeze(params.slice());
-    if (!frozenMappings) frozenMappings = Object.freeze(mappings.slice());
     const snap = {
       index,
-      params: frozenParams,
-      mappings: frozenMappings
+      params: params.slice(),
+      mappings: mappings.slice()
     };
     cachedSnapshot = snap;
     dirty = false;
-    frozenParams = null;
-    frozenMappings = null;
     return snap;
   }
   return {
@@ -2981,6 +3074,17 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
 var MAX_INCLUDE_DEPTH = 10;
 var MAX_TOTAL_SUBQUERIES = 100;
 var MAX_TOTAL_INCLUDES = 50;
+function buildIncludeScope(includePath) {
+  if (includePath.length === 0) return "include";
+  let scope = "include";
+  for (let i = 0; i < includePath.length; i++) {
+    scope += `.${includePath[i]}`;
+    if (i < includePath.length - 1) {
+      scope += ".include";
+    }
+  }
+  return scope;
+}
 function getRelationTableReference(relModel, dialect) {
   return buildTableReference(
     SQL_TEMPLATES.PUBLIC_SCHEMA,
@@ -3124,19 +3228,11 @@ function finalizeOrderByForInclude(args) {
 }
 function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
   let relSelect = buildRelationSelect(relArgs, relModel, relAlias);
-  const nestedIncludes = isPlainObject(relArgs) ? buildIncludeSqlInternal(
-    relArgs,
-    relModel,
-    ctx.schemas,
-    ctx.schemaByName,
-    relAlias,
-    ctx.aliasGen,
-    ctx.params,
-    ctx.dialect,
-    ctx.visitPath || [],
-    (ctx.depth || 0) + 1,
-    ctx.stats
-  ) : [];
+  const nestedIncludes = isPlainObject(relArgs) ? buildIncludeSqlInternal(relArgs, __spreadProps(__spreadValues({}, ctx), {
+    model: relModel,
+    parentAlias: relAlias,
+    depth: (ctx.depth || 0) + 1
+  })) : [];
   if (isNonEmptyArray(nestedIncludes)) {
     const emptyJson = ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
     const nestedSelects = nestedIncludes.map(
@@ -3191,6 +3287,7 @@ function buildOneToOneIncludeSql(args) {
     whereClause: args.whereClause
   });
   if (args.orderBySql) sql += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
+  const scopeBase = buildIncludeScope(args.ctx.includePath);
   if (isNotNullish(args.takeVal)) {
     return appendLimitOffset(
       sql,
@@ -3198,15 +3295,10 @@ function buildOneToOneIncludeSql(args) {
       args.ctx.params,
       args.takeVal,
       args.skipVal,
-      `include.${args.relName}`
+      scopeBase
     );
   }
-  return limitOneSql(
-    sql,
-    args.ctx.params,
-    args.skipVal,
-    `include.${args.relName}`
-  );
+  return limitOneSql(sql, args.ctx.params, args.skipVal, scopeBase);
 }
 function buildListIncludeSpec(args) {
   const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
@@ -3234,13 +3326,14 @@ function buildListIncludeSpec(args) {
     whereClause: args.whereClause
   });
   if (args.orderBySql) base += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
+  const scopeBase = buildIncludeScope(args.ctx.includePath);
   base = appendLimitOffset(
     base,
     args.ctx.dialect,
     args.ctx.params,
     args.takeVal,
     args.skipVal,
-    `include.${args.relName}`
+    scopeBase
   );
   const selectExpr = jsonAgg("row", args.ctx.dialect);
   const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${SQL_TEMPLATES.AS} ${rowAlias}`;
@@ -3289,7 +3382,6 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   );
   if (!isList) {
     const sql = buildOneToOneIncludeSql({
-      relName,
       relTable,
       relAlias,
       joins: whereParts.joins,
@@ -3317,8 +3409,14 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     ctx
   });
 }
-function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias, aliasGen, params, dialect, visitPath = [], depth = 0, stats) {
-  if (!stats) stats = { totalIncludes: 0, totalSubqueries: 0, maxDepth: 0 };
+function buildIncludeSqlInternal(args, ctx) {
+  const stats = ctx.stats || {
+    totalIncludes: 0,
+    totalSubqueries: 0,
+    maxDepth: 0
+  };
+  const depth = ctx.depth || 0;
+  const visitPath = ctx.visitPath || [];
   if (depth > MAX_INCLUDE_DEPTH) {
     throw new Error(
       `Maximum include depth of ${MAX_INCLUDE_DEPTH} exceeded. Path: ${visitPath.join(" -> ")}. Deep includes cause exponential SQL complexity and performance issues.`
@@ -3326,7 +3424,7 @@ function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias
   }
   stats.maxDepth = Math.max(stats.maxDepth, depth);
   const includes = [];
-  const entries = relationEntriesFromArgs(args, model);
+  const entries = relationEntriesFromArgs(args, ctx.model);
   for (const [relName, relArgs] of entries) {
     if (relArgs === false) continue;
     stats.totalIncludes++;
@@ -3341,8 +3439,12 @@ function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias
         `Query complexity limit exceeded: ${stats.totalSubqueries} subqueries generated. Maximum allowed: ${MAX_TOTAL_SUBQUERIES}. This indicates exponential include nesting. Stats: depth=${stats.maxDepth}, includes=${stats.totalIncludes}. Path: ${visitPath.join(" -> ")}. Simplify your include structure or split into multiple queries.`
       );
     }
-    const resolved = resolveRelationOrThrow(model, schemaByName, relName);
-    const relationPath = `${model.name}.${relName}`;
+    const resolved = resolveRelationOrThrow(
+      ctx.model,
+      ctx.schemaByName,
+      relName
+    );
+    const relationPath = `${ctx.model.name}.${relName}`;
     const currentPath = [...visitPath, relationPath];
     if (visitPath.includes(relationPath)) {
       throw new Error(
@@ -3357,19 +3459,14 @@ function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias
         `Include too deeply nested: model '${resolved.relModel.name}' appears ${modelOccurrences} times in path: ${currentPath.join(" -> ")}`
       );
     }
+    const nextIncludePath = [...ctx.includePath, relName];
     includes.push(
-      buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, {
-        model,
-        schemas,
-        schemaByName,
-        parentAlias,
-        aliasGen,
-        dialect,
-        params,
+      buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, __spreadProps(__spreadValues({}, ctx), {
+        includePath: nextIncludePath,
         visitPath: currentPath,
         depth: depth + 1,
         stats
-      })
+      }))
     );
   }
   return includes;
@@ -3383,8 +3480,7 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
   };
   const schemaByName = /* @__PURE__ */ new Map();
   for (const m of schemas) schemaByName.set(m.name, m);
-  return buildIncludeSqlInternal(
-    args,
+  return buildIncludeSqlInternal(args, {
     model,
     schemas,
     schemaByName,
@@ -3392,10 +3488,11 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     aliasGen,
     params,
     dialect,
-    [],
-    0,
+    includePath: [],
+    visitPath: [],
+    depth: 0,
     stats
-  );
+  });
 }
 function resolveCountRelationOrThrow(relName, model, schemaByName) {
   const relationSet = getRelationFieldSet(model);
@@ -3440,8 +3537,7 @@ function resolveCountKeyPairs(field) {
   if (fkFields.length === 0) {
     throw new Error("Relation count requires foreignKey");
   }
-  const refsRaw = field.references;
-  const refs = normalizeKeyList(refsRaw);
+  const refs = normalizeKeyList(field.references);
   const refFields = refs.length > 0 ? refs : defaultReferencesForCount(fkFields.length);
   if (refFields.length !== fkFields.length) {
     throw new Error(
@@ -3576,139 +3672,146 @@ function finalizeSql(sql, params, dialect) {
     paramMappings: snapshot.mappings
   };
 }
-function parseSimpleScalarSelect(select, fromAlias) {
-  const raw = select.trim();
-  if (raw.length === 0) return [];
-  const fromLower = fromAlias.toLowerCase();
-  const parts = raw.split(SQL_SEPARATORS.FIELD_LIST);
-  const names = [];
-  const isIdent = (s) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(s);
-  const readIdentOrQuoted = (s, start) => {
-    const n = s.length;
-    if (start >= n) return { text: "", next: start, quoted: false };
-    if (s.charCodeAt(start) === 34) {
-      let i2 = start + 1;
-      let out = "";
-      let saw = false;
-      while (i2 < n) {
-        const c = s.charCodeAt(i2);
-        if (c === 34) {
-          const next = i2 + 1;
-          if (next < n && s.charCodeAt(next) === 34) {
-            out += '"';
-            saw = true;
-            i2 += 2;
-            continue;
-          }
-          if (!saw)
-            throw new Error(
-              `sqlite distinct emulation: empty quoted identifier in: ${s}`
-            );
-          return { text: out, next: i2 + 1, quoted: true };
-        }
-        out += s[i2];
-        saw = true;
-        i2++;
-      }
-      throw new Error(
-        `sqlite distinct emulation: unterminated quoted identifier in: ${s}`
-      );
-    }
-    let i = start;
-    while (i < n) {
-      const c = s.charCodeAt(i);
-      if (c === 32 || c === 9) break;
-      if (c === 46) break;
-      i++;
-    }
-    return { text: s.slice(start, i), next: i, quoted: false };
-  };
-  const skipSpaces = (s, i) => {
-    while (i < s.length) {
-      const c = s.charCodeAt(i);
-      if (c !== 32 && c !== 9) break;
+function isIdent(s) {
+  return /^[A-Za-z_]\w*$/.test(s);
+}
+function skipSpaces(s, i) {
+  while (i < s.length) {
+    const c = s.charCodeAt(i);
+    if (c !== 32 && c !== 9) break;
+    i++;
+  }
+  return i;
+}
+function parseQuotedIdentifier(s, start) {
+  const n = s.length;
+  let i = start + 1;
+  let out = "";
+  let saw = false;
+  while (i < n) {
+    const c = s.charCodeAt(i);
+    if (c !== 34) {
+      out += s[i];
+      saw = true;
       i++;
+      continue;
     }
-    return i;
-  };
-  for (let idx = 0; idx < parts.length; idx++) {
-    const p = parts[idx].trim();
-    if (p.length === 0) continue;
-    let i = 0;
-    i = skipSpaces(p, i);
-    const a = readIdentOrQuoted(p, i);
-    const actualAlias = a.text.toLowerCase();
-    if (!isIdent(a.text)) {
-      throw new Error(
-        `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
-      );
-    }
-    if (actualAlias !== fromLower) {
-      throw new Error(`Expected alias '${fromAlias}', got '${a.text}' in: ${p}`);
+    const next = i + 1;
+    if (next < n && s.charCodeAt(next) === 34) {
+      out += '"';
+      saw = true;
+      i += 2;
+      continue;
     }
-    i = a.next;
-    if (i >= p.length || p.charCodeAt(i) !== 46) {
+    if (!saw) {
       throw new Error(
-        `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
+        `sqlite distinct emulation: empty quoted identifier in: ${s}`
       );
     }
+    return { text: out, next: i + 1, quoted: true };
+  }
+  throw new Error(
+    `sqlite distinct emulation: unterminated quoted identifier in: ${s}`
+  );
+}
+function parseUnquotedIdentifier(s, start) {
+  const n = s.length;
+  let i = start;
+  while (i < n) {
+    const c = s.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 46) break;
     i++;
-    i = skipSpaces(p, i);
-    const colPart = readIdentOrQuoted(p, i);
-    const columnName = colPart.text.trim();
-    if (columnName.length === 0) {
-      throw new Error(`Failed to parse selected column name from: ${p}`);
-    }
-    i = colPart.next;
-    i = skipSpaces(p, i);
-    let outAlias = "";
-    if (i < p.length) {
-      const rest = p.slice(i).trim();
-      if (rest.length > 0) {
-        const m = rest.match(/^AS\s+/i);
-        if (!m) {
-          throw new Error(
-            `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
-          );
-        }
-        let j = i;
-        j = skipSpaces(p, j);
-        if (!/^AS\b/i.test(p.slice(j))) {
-          throw new Error(`Failed to parse AS in: ${p}`);
-        }
-        j += 2;
-        j = skipSpaces(p, j);
-        const out = readIdentOrQuoted(p, j);
-        outAlias = out.text.trim();
-        if (outAlias.length === 0) {
-          throw new Error(`Failed to parse output alias from: ${p}`);
-        }
-        j = skipSpaces(p, out.next);
-        if (j !== p.length) {
-          throw new Error(
-            `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
-          );
-        }
-      }
-    }
-    const name = outAlias.length > 0 ? outAlias : columnName;
-    names.push(name);
   }
-  return names;
+  return { text: s.slice(start, i), next: i, quoted: false };
+}
+function readIdentOrQuoted(s, start) {
+  const n = s.length;
+  if (start >= n) return { text: "", next: start, quoted: false };
+  if (s.charCodeAt(start) === 34) {
+    return parseQuotedIdentifier(s, start);
+  }
+  return parseUnquotedIdentifier(s, start);
+}
+function parseOutputAlias(p, i) {
+  if (i >= p.length) return "";
+  const rest = p.slice(i).trim();
+  if (rest.length === 0) return "";
+  const m = rest.match(/^AS\s+/i);
+  if (!m) {
+    throw new Error(
+      `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
+    );
+  }
+  let j = i;
+  j = skipSpaces(p, j);
+  if (!/^AS\b/i.test(p.slice(j))) {
+    throw new Error(`Failed to parse AS in: ${p}`);
+  }
+  j += 2;
+  j = skipSpaces(p, j);
+  const out = readIdentOrQuoted(p, j);
+  const outAlias = out.text.trim();
+  if (outAlias.length === 0) {
+    throw new Error(`Failed to parse output alias from: ${p}`);
+  }
+  j = skipSpaces(p, out.next);
+  if (j !== p.length) {
+    throw new Error(
+      `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
+    );
+  }
+  return outAlias;
+}
+function parseSelectField(p, fromAlias) {
+  const fromLower = fromAlias.toLowerCase();
+  let i = 0;
+  i = skipSpaces(p, i);
+  const a = readIdentOrQuoted(p, i);
+  const actualAlias = a.text.toLowerCase();
+  if (!isIdent(a.text)) {
+    throw new Error(
+      `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
+    );
+  }
+  if (actualAlias !== fromLower) {
+    throw new Error(`Expected alias '${fromAlias}', got '${a.text}' in: ${p}`);
+  }
+  i = a.next;
+  if (i >= p.length || p.charCodeAt(i) !== 46) {
+    throw new Error(
+      `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
+    );
+  }
+  i++;
+  i = skipSpaces(p, i);
+  const colPart = readIdentOrQuoted(p, i);
+  const columnName = colPart.text.trim();
+  if (columnName.length === 0) {
+    throw new Error(`Failed to parse selected column name from: ${p}`);
+  }
+  i = colPart.next;
+  i = skipSpaces(p, i);
+  const outAlias = parseOutputAlias(p, i);
+  return outAlias.length > 0 ? outAlias : columnName;
 }
-function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
-  const src = String(fromAlias);
-  if (src.length === 0) return orderBy;
-  const escaped = src.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const re = new RegExp(`\\b${escaped}\\.`, "gi");
-  return orderBy.replace(re, outerAlias + ".");
+function parseSimpleScalarSelect(select, fromAlias) {
+  const raw = select.trim();
+  if (raw.length === 0) return [];
+  const parts = raw.split(SQL_SEPARATORS.FIELD_LIST);
+  const names = [];
+  for (const p of parts) {
+    const trimmed = p.trim();
+    if (trimmed.length === 0) continue;
+    names.push(parseSelectField(trimmed, fromAlias));
+  }
+  return names;
 }
 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 = hasCount ? [...scalarNames, ...includeNames, "_count"] : [...scalarNames, ...includeNames];
-  const formatted = outputCols.map((n) => quote2(n)).join(SQL_SEPARATORS.FIELD_LIST);
+  const formatted = outputCols.map((n) => quote(n)).join(SQL_SEPARATORS.FIELD_LIST);
   if (!isNonEmptyString(formatted)) {
     throw new Error("distinct emulation requires at least one output column");
   }
@@ -3725,6 +3828,52 @@ function buildWindowOrder(args) {
   const idTiebreaker = idField ? ", " + col(fromAlias, "id", model) + " ASC" : "";
   return baseOrder + idTiebreaker;
 }
+function extractDistinctOrderEntries(spec) {
+  if (isNotNullish(spec.args.orderBy)) {
+    const normalized = normalizeOrderByInput(
+      spec.args.orderBy,
+      parseOrderByValue
+    );
+    const entries = [];
+    for (const item of normalized) {
+      for (const field in item) {
+        if (!Object.prototype.hasOwnProperty.call(item, field)) continue;
+        const value = item[field];
+        if (typeof value === "string") {
+          entries.push({ field, direction: value });
+        } else {
+          const obj = value;
+          entries.push({ field, direction: obj.sort, nulls: obj.nulls });
+        }
+      }
+    }
+    if (entries.length > 0) return entries;
+  }
+  if (isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct)) {
+    return [...spec.distinct].map((f) => ({
+      field: f,
+      direction: "asc"
+    }));
+  }
+  return [];
+}
+function buildFieldNameOrderBy(entries, alias) {
+  if (entries.length === 0) return "";
+  const out = [];
+  for (const e of entries) {
+    const dir = e.direction.toUpperCase();
+    const c = `${alias}.${quote(e.field)}`;
+    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 buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   var _a, _b;
   const { includes, from, whereClause, whereJoins, orderBy, distinct, model } = spec;
@@ -3751,7 +3900,8 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     fromAlias: from.alias,
     model
   });
-  const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, '"__tp_distinct"') : replaceOrderByAlias(fallbackOrder, from.alias, '"__tp_distinct"');
+  const outerEntries = extractDistinctOrderEntries(spec);
+  const outerOrder = buildFieldNameOrderBy(outerEntries, '"__tp_distinct"');
   const joins = buildJoinsSql(whereJoins, countJoins);
   const conditions = [];
   if (whereClause && whereClause !== "1=1") conditions.push(whereClause);
@@ -3786,17 +3936,33 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   }
   return outerParts.join(" ");
 }
+function resolveCountSelect(countSelectRaw, model) {
+  if (countSelectRaw === true) {
+    const relationSet = getRelationFieldSet(model);
+    if (relationSet.size === 0) return null;
+    const allRelations = {};
+    for (const name of relationSet) {
+      allRelations[name] = true;
+    }
+    return allRelations;
+  }
+  if (isPlainObject(countSelectRaw) && "select" in countSelectRaw) {
+    return countSelectRaw.select;
+  }
+  return null;
+}
 function buildIncludeColumns(spec) {
   var _a, _b;
   const { select, includes, dialect, model, schemas, from, params } = spec;
   const baseSelect = (select != null ? select : "").trim();
   let countCols = "";
   let countJoins = [];
-  const countSelect = (_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count;
-  if (countSelect) {
-    if (isPlainObject(countSelect) && "select" in countSelect) {
+  const countSelectRaw = (_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count;
+  if (countSelectRaw) {
+    const resolvedCountSelect = resolveCountSelect(countSelectRaw, model);
+    if (resolvedCountSelect && Object.keys(resolvedCountSelect).length > 0) {
       const countBuild = buildRelationCountSql(
-        countSelect.select,
+        resolvedCountSelect,
         model,
         schemas,
         from.alias,
@@ -3804,7 +3970,7 @@ function buildIncludeColumns(spec) {
         dialect
       );
       if (countBuild.jsonPairs) {
-        countCols = jsonBuildObject(countBuild.jsonPairs, dialect) + " " + SQL_TEMPLATES.AS + " " + quote2("_count");
+        countCols = jsonBuildObject(countBuild.jsonPairs, dialect) + " " + SQL_TEMPLATES.AS + " " + quote("_count");
       }
       countJoins = countBuild.joins;
     }
@@ -3817,7 +3983,7 @@ function buildIncludeColumns(spec) {
   const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
   const includeCols = hasIncludes ? includes.map((inc) => {
     const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
-    return expr + " " + SQL_TEMPLATES.AS + " " + quote2(inc.name);
+    return expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name);
   }).join(SQL_SEPARATORS.FIELD_LIST) : "";
   const allCols = joinNonEmpty(
     [includeCols, countCols],
@@ -4182,6 +4348,7 @@ function buildComparisons(expr, filter, params, dialect, builder, excludeKeys =
 }
 
 // src/builder/aggregates.ts
+var MAX_NOT_DEPTH2 = 50;
 var AGGREGATES = [
   ["_sum", "SUM"],
   ["_avg", "AVG"],
@@ -4296,8 +4463,13 @@ function buildBinaryComparison(expr, op, val, params) {
   const placeholder = addHavingParam(params, op, val);
   return expr + " " + sqlOp + " " + placeholder;
 }
-function buildSimpleComparison(expr, op, val, params, dialect) {
+function buildSimpleComparison(expr, op, val, params, dialect, depth = 0) {
   assertHavingOp(op);
+  if (depth > MAX_NOT_DEPTH2) {
+    throw new Error(
+      `NOT operator nesting too deep in HAVING (max ${MAX_NOT_DEPTH2} levels).`
+    );
+  }
   if (val === null) return buildNullComparison(expr, op);
   if (op === Ops.NOT && isPlainObject(val)) {
     return buildNotComposite(
@@ -4305,7 +4477,7 @@ function buildSimpleComparison(expr, op, val, params, dialect) {
       val,
       params,
       dialect,
-      buildSimpleComparison,
+      (e, subOp, subVal, p, d) => buildSimpleComparison(e, subOp, subVal, p, d, depth + 1),
       SQL_SEPARATORS.CONDITION_AND
     );
   }
@@ -4322,23 +4494,36 @@ function combineLogical(key, subClauses) {
   if (key === LogicalOps.NOT) return negateClauses(subClauses);
   return subClauses.join(" " + key + " ");
 }
-function buildHavingNode(node, alias, params, dialect, model) {
+function buildHavingNode(node, alias, params, dialect, model, depth = 0) {
+  if (depth > LIMITS.MAX_HAVING_DEPTH) {
+    throw new Error(
+      `HAVING clause nesting too deep (max ${LIMITS.MAX_HAVING_DEPTH} levels). This usually indicates a circular reference.`
+    );
+  }
   const clauses = [];
   for (const key in node) {
     if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
     const value = node[key];
-    const built = buildHavingEntry(key, value, alias, params, dialect, model);
+    const built = buildHavingEntry(
+      key,
+      value,
+      alias,
+      params,
+      dialect,
+      model,
+      depth
+    );
     for (const c of built) {
       if (c && c.length > 0) clauses.push(c);
     }
   }
   return clauses.join(SQL_SEPARATORS.CONDITION_AND);
 }
-function buildLogicalClause2(key, value, alias, params, dialect, model) {
+function buildLogicalClause2(key, value, alias, params, dialect, model, depth = 0) {
   const items = normalizeLogicalValue2(key, value);
   const subClauses = [];
   for (const it of items) {
-    const c = buildHavingNode(it, alias, params, dialect, model);
+    const c = buildHavingNode(it, alias, params, dialect, model, depth + 1);
     if (c && c.length > 0) subClauses.push("(" + c + ")");
   }
   if (subClauses.length === 0) return "";
@@ -4397,7 +4582,7 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
   }
   return out;
 }
-function buildHavingEntry(key, value, alias, params, dialect, model) {
+function buildHavingEntry(key, value, alias, params, dialect, model, depth = 0) {
   if (isLogicalKey(key)) {
     const logical = buildLogicalClause2(
       key,
@@ -4405,7 +4590,8 @@ function buildHavingEntry(key, value, alias, params, dialect, model) {
       alias,
       params,
       dialect,
-      model
+      model,
+      depth
     );
     return logical ? [logical] : [];
   }
@@ -4432,7 +4618,7 @@ function buildHavingClause(having, alias, params, model, dialect) {
   if (!isNotNullish(having)) return "";
   const d = dialect != null ? dialect : getGlobalDialect();
   if (!isPlainObject(having)) throw new Error("having must be an object");
-  return buildHavingNode(having, alias, params, d, model);
+  return buildHavingNode(having, alias, params, d, model, 0);
 }
 function normalizeCountArg(v) {
   if (!isNotNullish(v)) return void 0;
@@ -4442,13 +4628,13 @@ function normalizeCountArg(v) {
 }
 function pushCountAllField(fields) {
   fields.push(
-    SQL_TEMPLATES.COUNT_ALL + " " + SQL_TEMPLATES.AS + " " + quote2("_count._all")
+    SQL_TEMPLATES.COUNT_ALL + " " + SQL_TEMPLATES.AS + " " + quote("_count._all")
   );
 }
 function pushCountField(fields, alias, fieldName, model) {
   const outAlias = "_count." + fieldName;
   fields.push(
-    "COUNT(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
+    "COUNT(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote(outAlias)
   );
 }
 function addCountFields(fields, countArg, alias, model) {
@@ -4485,7 +4671,7 @@ function assertAggregatableScalarField(model, agg, fieldName) {
 function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
   const outAlias = agg + "." + fieldName;
   fields.push(
-    aggFn + "(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
+    aggFn + "(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote(outAlias)
   );
 }
 function addAggregateFields(fields, args, alias, model) {
@@ -4569,7 +4755,7 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
   assertSafeAlias(alias);
   assertSafeTableRef(tableName);
   const byFields = assertGroupByBy(args, model);
-  const d = getGlobalDialect();
+  const d = dialect != null ? dialect : getGlobalDialect();
   const params = createParamStore(whereResult.nextParamIndex);
   const { groupFields, selectFields } = buildGroupBySelectParts(
     args,
@@ -4601,38 +4787,38 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     paramMappings: allMappings
   };
 }
+function isPositiveInteger(value) {
+  return Number.isFinite(value) && Number.isInteger(value) && value > 0;
+}
+function parseSkipValue(skip) {
+  return typeof skip === "string" ? Number(skip.trim()) : skip;
+}
+function validateSkipParameter(skip) {
+  if (skip === void 0 || skip === null) {
+    return;
+  }
+  if (schemaParser.isDynamicParameter(skip)) {
+    throw new Error(
+      "count() with skip is not supported because it produces nondeterministic results. Dynamic skip cannot be validated at build time. Use findMany().length or add explicit orderBy + cursor/skip logic in a deterministic query."
+    );
+  }
+  const skipValue = parseSkipValue(skip);
+  if (isPositiveInteger(skipValue)) {
+    throw new Error(
+      "count() with skip is not supported because it produces nondeterministic results. Use findMany().length or add explicit orderBy to ensure deterministic behavior."
+    );
+  }
+}
 function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
   assertSafeAlias(alias);
   assertSafeTableRef(tableName);
-  if (skip !== void 0 && skip !== null) {
-    if (schemaParser.isDynamicParameter(skip)) {
-      throw new Error(
-        "count() with skip is not supported because it produces nondeterministic results. Dynamic skip cannot be validated at build time. Use findMany().length or add explicit orderBy + cursor/skip logic in a deterministic query."
-      );
-    }
-    if (typeof skip === "string") {
-      const s = skip.trim();
-      if (s.length > 0) {
-        const n = Number(s);
-        if (Number.isFinite(n) && Number.isInteger(n) && n > 0) {
-          throw new Error(
-            "count() with skip is not supported because it produces nondeterministic results. Use findMany().length or add explicit orderBy to ensure deterministic behavior."
-          );
-        }
-      }
-    }
-    if (typeof skip === "number" && Number.isFinite(skip) && Number.isInteger(skip) && skip > 0) {
-      throw new Error(
-        "count() with skip is not supported because it produces nondeterministic results. Use findMany().length or add explicit orderBy to ensure deterministic behavior."
-      );
-    }
-  }
+  validateSkipParameter(skip);
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
     SQL_TEMPLATES.COUNT_ALL,
     SQL_TEMPLATES.AS,
-    quote2("_count._all"),
+    quote("_count._all"),
     SQL_TEMPLATES.FROM,
     tableName,
     alias
@@ -4673,15 +4859,21 @@ function buildSqlResult(args) {
     return buildAggregateSql(processed, whereResult, tableName, alias, modelDef);
   }
   if (method === "groupBy") {
-    return buildGroupBySql(processed, whereResult, tableName, alias, modelDef);
+    return buildGroupBySql(
+      processed,
+      whereResult,
+      tableName,
+      alias,
+      modelDef,
+      dialect
+    );
   }
   if (method === "count") {
     return buildCountSql(
       whereResult,
       tableName,
       alias,
-      processed.skip
-    );
+      processed.skip);
   }
   return buildSelectSql({
     method,
@@ -4721,22 +4913,23 @@ function normalizeSqlAndMappingsForDialect(sql, paramMappings, dialect) {
 }
 function buildParamsFromMappings(mappings) {
   const sorted = [...mappings].sort((a, b) => a.index - b.index);
-  return sorted.reduce(
-    (acc, m) => {
-      if (m.dynamicName !== void 0) {
-        acc.dynamicKeys.push(m.dynamicName);
-        return acc;
-      }
-      if (m.value !== void 0) {
-        acc.staticParams.push(m.value);
-        return acc;
-      }
+  const staticParams = [];
+  const dynamicKeys = [];
+  let paramOrder = "";
+  for (const m of sorted) {
+    if (m.dynamicName !== void 0) {
+      dynamicKeys.push(m.dynamicName);
+      paramOrder += "d";
+    } else if (m.value !== void 0) {
+      staticParams.push(m.value);
+      paramOrder += "s";
+    } else {
       throw new Error(
         `CRITICAL: ParamMap ${m.index} has neither dynamicName nor value`
       );
-    },
-    { staticParams: [], dynamicKeys: [] }
-  );
+    }
+  }
+  return { staticParams, dynamicKeys, paramOrder };
 }
 function resolveModelContext(directive) {
   const { model, datamodel } = directive.context;
@@ -4802,12 +4995,13 @@ function finalizeDirective(args) {
     return (_a = m.value) != null ? _a : void 0;
   });
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
-  const { staticParams, dynamicKeys } = buildParamsFromMappings(normalizedMappings);
+  const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
   return {
     method: directive.method,
     sql: normalizedSql,
     staticParams,
     dynamicKeys,
+    paramOrder,
     paramMappings: normalizedMappings,
     originalDirective: directive
   };
@@ -4842,6 +5036,257 @@ function generateSQL(directive) {
     dialect
   });
 }
+
+// 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 _hits, _misses;
+var QueryCacheStats = class {
+  constructor() {
+    __privateAdd(this, _hits, 0);
+    __privateAdd(this, _misses, 0);
+  }
+  hit() {
+    __privateWrapper(this, _hits)._++;
+  }
+  miss() {
+    __privateWrapper(this, _misses)._++;
+  }
+  reset() {
+    __privateSet(this, _hits, 0);
+    __privateSet(this, _misses, 0);
+  }
+  get snapshot() {
+    return Object.freeze({
+      hits: __privateGet(this, _hits),
+      misses: __privateGet(this, _misses),
+      size: queryCache.size
+    });
+  }
+};
+_hits = new WeakMap();
+_misses = new WeakMap();
+var queryCache = createBoundedCache(1e3);
+new QueryCacheStats();
+
+// src/index.ts
 function generateSQL2(directive) {
   return generateSQL(directive);
 }
@@ -4870,6 +5315,57 @@ function extractEnumMappings(datamodel) {
   }
   return { mappings, fieldTypes };
 }
+function processModelDirectives(modelName, result, config) {
+  const modelQueries = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const directive of result.directives) {
+    try {
+      const method = directive.method;
+      const sqlDirective = generateSQL2(directive);
+      if (!modelQueries.has(method)) {
+        modelQueries.set(method, /* @__PURE__ */ new Map());
+      }
+      const methodQueriesMap = modelQueries.get(method);
+      const queryKey = createQueryKey(directive.query.processed);
+      methodQueriesMap.set(queryKey, {
+        sql: sqlDirective.sql,
+        params: sqlDirective.staticParams,
+        dynamicKeys: sqlDirective.dynamicKeys,
+        paramMappings: sqlDirective.paramMappings
+      });
+    } catch (error) {
+      if (!config.skipInvalid) throw error;
+      skipped++;
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.warn(`  \u26A0 Skipped ${modelName}.${directive.method}: ${errMsg}`);
+    }
+  }
+  return { modelQueries, skipped };
+}
+function processAllModelDirectives(directiveResults, config) {
+  const queries = /* @__PURE__ */ new Map();
+  let skippedCount = 0;
+  for (const [modelName, result] of directiveResults) {
+    if (result.directives.length === 0) continue;
+    const { modelQueries, skipped } = processModelDirectives(
+      modelName,
+      result,
+      config
+    );
+    queries.set(modelName, modelQueries);
+    skippedCount += skipped;
+  }
+  return { queries, skippedCount };
+}
+function countTotalQueries(queries) {
+  return Array.from(queries.values()).reduce(
+    (sum, methodMap) => sum + Array.from(methodMap.values()).reduce(
+      (s, queryMap) => s + queryMap.size,
+      0
+    ),
+    0
+  );
+}
 function generateClient(options) {
   return __async(this, null, function* () {
     const { datamodel, outputDir, config } = options;
@@ -4882,48 +5378,22 @@ function generateClient(options) {
         skipInvalid: config.skipInvalid
       }
     );
-    const queries = /* @__PURE__ */ new Map();
-    for (const [modelName, result] of directiveResults) {
-      if (result.directives.length === 0) continue;
-      if (!queries.has(modelName)) {
-        queries.set(modelName, /* @__PURE__ */ new Map());
-      }
-      const modelQueries = queries.get(modelName);
-      for (const directive of result.directives) {
-        try {
-          const method = directive.method;
-          const sqlDirective = generateSQL2(directive);
-          if (!modelQueries.has(method)) {
-            modelQueries.set(method, /* @__PURE__ */ new Map());
-          }
-          const methodQueriesMap = modelQueries.get(method);
-          const queryKey = createQueryKey(directive.query.processed);
-          methodQueriesMap.set(queryKey, {
-            sql: sqlDirective.sql,
-            params: sqlDirective.staticParams,
-            dynamicKeys: sqlDirective.dynamicKeys,
-            paramMappings: sqlDirective.paramMappings
-          });
-        } catch (error) {
-          if (!config.skipInvalid) throw error;
-        }
-      }
-    }
+    const { queries, skippedCount } = processAllModelDirectives(
+      directiveResults,
+      config
+    );
     const absoluteOutputDir = path.resolve(process.cwd(), outputDir);
     yield promises.mkdir(absoluteOutputDir, { recursive: true });
     const code = generateCode(models, queries, config.dialect, datamodel);
     const outputPath = path.join(absoluteOutputDir, "index.ts");
     yield promises.writeFile(outputPath, code);
-    const totalQueries = Array.from(queries.values()).reduce(
-      (sum, methodMap) => sum + Array.from(methodMap.values()).reduce(
-        (s, queryMap) => s + queryMap.size,
-        0
-      ),
-      0
-    );
+    const totalQueries = countTotalQueries(queries);
     console.log(
       `\u2713 Generated ${queries.size} models, ${totalQueries} prebaked queries`
     );
+    if (skippedCount > 0) {
+      console.log(`\u26A0 Skipped ${skippedCount} directive(s) due to errors`);
+    }
     console.log(`\u2713 Output: ${outputPath}`);
   });
 }
@@ -4939,15 +5409,13 @@ function createQueryKey(processedQuery) {
     return value;
   });
 }
-function generateCode(models, queries, dialect, datamodel) {
-  const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
-    fields: model.fields.filter((f) => f !== void 0 && f !== null)
-  }));
-  const { mappings, fieldTypes } = extractEnumMappings(datamodel);
+function generateImports() {
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
 import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, type PrismaMethod, type Model, type BatchQuery, type BatchCountQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'
-
-class DeferredQuery {
+import { normalizeValue } from 'prisma-sql/utils/normalize-value'`;
+}
+function generateCoreTypes() {
+  return `class DeferredQuery {
   constructor(
     public readonly model: string,
     public readonly method: PrismaMethod,
@@ -4979,22 +5447,21 @@ const ACCELERATED_METHODS = new Set<PrismaMethod>([
   'count',
   'aggregate',
   'groupBy',
-])
-
-function createBatchProxy(): BatchProxy {
+])`;
+}
+function generateHelpers() {
+  return `function createBatchProxy(): BatchProxy {
   return new Proxy(
     {},
     {
       get(_target, modelName: string): any {
         if (typeof modelName === 'symbol') return undefined
-
         const model = MODEL_MAP.get(modelName)
         if (!model) {
           throw new Error(
             \`Model '\${modelName}' not found. Available: \${[...MODEL_MAP.keys()].join(', ')}\`,
           )
         }
-
         return new Proxy(
           {},
           {
@@ -5004,7 +5471,6 @@ function createBatchProxy(): BatchProxy {
                   \`Method '\${method}' not supported in batch. Supported: \${[...ACCELERATED_METHODS].join(', ')}\`,
                 )
               }
-
               return (args?: any): DeferredQuery => {
                 return new DeferredQuery(
                   modelName,
@@ -5020,52 +5486,6 @@ function createBatchProxy(): BatchProxy {
   ) as BatchProxy
 }
 
-function normalizeValue(value: unknown, seen = new WeakSet<object>(), depth = 0): unknown {
-  const MAX_DEPTH = 20
-  if (depth > MAX_DEPTH) {
-    throw new Error(\`Max normalization depth exceeded (\${MAX_DEPTH} levels)\`)
-  }
-  if (value instanceof Date) {
-    const t = value.getTime()
-    if (!Number.isFinite(t)) {
-      throw new Error('Invalid Date value in SQL params')
-    }
-    return value.toISOString()
-  }
-  if (typeof value === 'bigint') {
-    return value.toString()
-  }
-  if (Array.isArray(value)) {
-    const arrRef = value as unknown as object
-    if (seen.has(arrRef)) {
-      throw new Error('Circular reference in SQL params')
-    }
-    seen.add(arrRef)
-    const out = value.map((v) => normalizeValue(v, seen, depth + 1))
-    seen.delete(arrRef)
-    return out
-  }
-  if (value && typeof value === 'object') {
-    if (value instanceof Uint8Array) return value
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) return value
-    const proto = Object.getPrototypeOf(value)
-    const isPlain = proto === Object.prototype || proto === null
-    if (!isPlain) return value
-    const obj = value as Record<string, unknown>
-    if (seen.has(obj)) {
-      throw new Error('Circular reference in SQL params')
-    }
-    seen.add(obj)
-    const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(obj)) {
-      out[k] = normalizeValue(v, seen, depth + 1)
-    }
-    seen.delete(obj)
-    return out
-  }
-  return value
-}
-
 function normalizeParams(params: unknown[]): unknown[] {
   return params.map(p => normalizeValue(p))
 }
@@ -5081,7 +5501,68 @@ function getByPath(obj: any, path: string): unknown {
   return result
 }
 
-export const MODELS: Model[] = ${JSON.stringify(cleanModels, null, 2)}
+function resolveParamsFromMappings(args: any, paramMappings: any[]): unknown[] {
+  const params: unknown[] = []
+  for (let i = 0; i < paramMappings.length; i++) {
+    const m = paramMappings[i]
+    if (m.value !== undefined) {
+      params.push(m.value)
+      continue
+    }
+    if (m.dynamicName === undefined) {
+      throw new Error(\`CRITICAL: ParamMap \${m.index} has neither dynamicName nor value\`)
+    }
+    const colonIdx = m.dynamicName.indexOf(':')
+    const scopePath = colonIdx !== -1 ? m.dynamicName.slice(0, colonIdx) : null
+    const name = colonIdx !== -1 ? m.dynamicName.slice(colonIdx + 1) : m.dynamicName
+    let value: unknown
+    if (!scopePath || scopePath.startsWith('root.')) {
+      value = name.includes('.')
+        ? getByPath(args, name)
+        : args?.[name]
+    } else {
+      value = getByPath(args, scopePath)
+    }
+    if (value === undefined) {
+      throw new Error(\`Missing required parameter: \${m.dynamicName}\`)
+    }
+    params.push(normalizeValue(value))
+  }
+  return params
+}
+
+function shouldSqliteUseGet(method: string): boolean {
+  return (
+    method === 'count' ||
+    method === 'findFirst' ||
+    method === 'findUnique' ||
+    method === 'aggregate'
+  )
+}
+
+async function executeQuery(client: any, method: string, sql: string, params: unknown[]): Promise<unknown[]> {
+  const normalizedParams = normalizeParams(params)
+  if (DIALECT === 'postgres') {
+    return await client.unsafe(sql, normalizedParams)
+  }
+  const stmt = client.prepare(sql)
+  if (shouldSqliteUseGet(method)) {
+    const row = stmt.get(...normalizedParams)
+    if (row === undefined) return []
+    return [row]
+  }
+  return stmt.all(...normalizedParams)
+}
+
+async function executeRaw(client: any, sql: string, params?: unknown[]): Promise<unknown[]> {
+  if (DIALECT === 'postgres') {
+    return await client.unsafe(sql, (params || []) as any[])
+  }
+  throw new Error('Raw execution for sqlite not supported in transactions')
+}`;
+}
+function generateDataConstants(cleanModels, mappings, fieldTypes, queries, dialect) {
+  return `export const MODELS: Model[] = ${JSON.stringify(cleanModels, null, 2)}
 
 const ENUM_MAPPINGS: Record<string, Record<string, string>> = ${JSON.stringify(mappings, null, 2)}
 
@@ -5096,12 +5577,19 @@ const QUERIES: Record<string, Record<string, Record<string, {
 
 const DIALECT = ${JSON.stringify(dialect)}
 
-const MODEL_MAP = new Map(MODELS.map(m => [m.name, m]))
-
-function isDynamicKeyForQueryKey(path: string[], key: string): boolean {
+const MODEL_MAP = new Map(MODELS.map(m => [m.name, m]))`;
+}
+function generateTransformLogic() {
+  return `function isDynamicKeyForQueryKey(path: string[], key: string): boolean {
   if (key !== 'skip' && key !== 'take' && key !== 'cursor') return false
+  const parent = path.length > 0 ? path[path.length - 1] : null
+  if (!parent) return true
+  if (parent === 'include' || parent === 'select') return false
   if (path.includes('where')) return false
   if (path.includes('data')) return false
+  if (path.includes('orderBy')) return false
+  if (path.includes('having')) return false
+  if (path.includes('by')) return false
   return true
 }
 
@@ -5128,6 +5616,14 @@ function transformEnumInValue(value: unknown, enumType: string | undefined): unk
     return mapping[value]
   }
 
+  if (typeof value === 'object' && !(value instanceof Date)) {
+    const result: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      result[k] = transformEnumInValue(v, enumType)
+    }
+    return result
+  }
+
   return value
 }
 
@@ -5155,19 +5651,16 @@ function transformEnumValuesByModel(modelName: string, obj: any, path: string[]
   if (typeof obj === 'object') {
     const transformed: any = {}
     const modelFields = ENUM_FIELDS[modelName] || {}
-
     for (const [key, value] of Object.entries(obj)) {
       const nextPath = [...path, key]
 
       const relModel = getRelatedModelName(modelName, key)
-
       if (relModel && value && typeof value === 'object') {
         transformed[key] = transformEnumValuesByModel(relModel, value, nextPath)
         continue
       }
 
       const enumType = modelFields[key]
-
       if (enumType) {
         if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
           const transformedOperators: any = {}
@@ -5186,25 +5679,27 @@ function transformEnumValuesByModel(modelName: string, obj: any, path: string[]
         transformed[key] = value
       }
     }
-
     return transformed
   }
 
   return obj
 }
 
+function bigIntSafeReplacer(_key: string, value: unknown): unknown {
+  if (typeof value === 'bigint') return '__bigint__' + value.toString()
+  return value
+}
+
 function normalizeQuery(args: any): string {
   if (!args) return '{}'
-
-  const normalized = JSON.parse(JSON.stringify(args))
+  const jsonStr = JSON.stringify(args, bigIntSafeReplacer)
+  const normalized = JSON.parse(jsonStr)
 
   function replaceDynamicParams(obj: any, path: string[] = []): any {
     if (!obj || typeof obj !== 'object') return obj
-
     if (Array.isArray(obj)) {
       return obj.map((v) => replaceDynamicParams(v, path))
     }
-
     const result: any = {}
     for (const [key, value] of Object.entries(obj)) {
       if (isDynamicKeyForQueryKey(path, key)) {
@@ -5218,22 +5713,8 @@ function normalizeQuery(args: any): string {
 
   const withMarkers = replaceDynamicParams(normalized)
 
-  function removeEmptyObjects(obj: any): any {
-    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return obj
-
-    const result: any = {}
-    for (const [key, value] of Object.entries(obj)) {
-      if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
-        continue
-      }
-      result[key] = removeEmptyObjects(value)
-    }
-    return result
-  }
-
-  const cleaned = removeEmptyObjects(withMarkers)
-
-  return JSON.stringify(cleaned, (key, value) => {
+  return JSON.stringify(withMarkers, (key, value) => {
+    if (typeof value === 'bigint') return '__bigint__' + value.toString()
     if (value && typeof value === 'object' && !Array.isArray(value)) {
       const sorted: Record<string, unknown> = {}
       for (const k of Object.keys(value).sort()) {
@@ -5243,52 +5724,10 @@ function normalizeQuery(args: any): string {
     }
     return value
   })
+}`;
 }
-
-function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
-  const params: unknown[] = []
-
-  for (const key of dynamicKeys) {
-    const parts = key.split(':')
-    const lookupKey = parts.length === 2 ? parts[1] : key
-
-    const value =
-      lookupKey.includes('.') ? getByPath(args, lookupKey) : args?.[lookupKey]
-
-    if (value === undefined) {
-      throw new Error(\`Missing required parameter: \${key}\`)
-    }
-
-    params.push(normalizeValue(value))
-  }
-
-  return params
-}
-
-async function executeQuery(client: any, sql: string, params: unknown[]): Promise<unknown[]> {
-  const normalizedParams = normalizeParams(params)
-
-  if (DIALECT === 'postgres') {
-    return await client.unsafe(sql, normalizedParams)
-  }
-
-  const stmt = client.prepare(sql)
-
-  if (sql.toUpperCase().includes('COUNT(*) AS')) {
-    return [stmt.get(...normalizedParams)]
-  }
-
-  return stmt.all(...normalizedParams)
-}
-
-async function executeRaw(client: any, sql: string, params?: unknown[]): Promise<unknown[]> {
-  if (DIALECT === 'postgres') {
-    return await client.unsafe(sql, (params || []) as any[])
-  }
-  throw new Error('Raw execution for sqlite not supported in transactions')
-}
-
-export function speedExtension(config: {
+function generateExtension() {
+  return `export function speedExtension(config: {
   postgres?: any
   sqlite?: any
   debug?: boolean
@@ -5302,14 +5741,11 @@ export function speedExtension(config: {
   }) => void
 }) {
   const { postgres, sqlite, debug, onQuery } = config
-
   if (!postgres && !sqlite) {
     throw new Error('speedExtension requires postgres or sqlite client')
   }
-
   const client = postgres || sqlite
   const actualDialect = postgres ? 'postgres' : 'sqlite'
-
   if (actualDialect !== DIALECT) {
     throw new Error(\`Generated code is for \${DIALECT}, but you provided \${actualDialect}\`)
   }
@@ -5327,53 +5763,55 @@ export function speedExtension(config: {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
 
-      const transformedArgs = transformEnumValuesByModel(modelName, args || {})
-
-      const queryKey = normalizeQuery(transformedArgs)
-      const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
-
-      let sql: string
-      let params: unknown[]
-      let prebaked = false
-
-      if (prebakedQuery) {
-        sql = prebakedQuery.sql
-        params = normalizeParams([
-          ...prebakedQuery.params,
-          ...extractDynamicParams(transformedArgs, prebakedQuery.dynamicKeys),
-        ])
-        prebaked = true
-      } else {
-        const model = MODELS.find((m) => m.name === modelName)
-
-        if (!model) {
-          return this.$parent[modelName][method](args)
+      try {
+        const transformedArgs = transformEnumValuesByModel(modelName, args || {})
+        const queryKey = normalizeQuery(transformedArgs)
+        const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
+        let sql: string
+        let params: unknown[]
+        let prebaked = false
+
+        if (prebakedQuery) {
+          sql = prebakedQuery.sql
+          params = resolveParamsFromMappings(transformedArgs, prebakedQuery.paramMappings)
+          prebaked = true
+        } else {
+          const model = MODELS.find((m) => m.name === modelName)
+          if (!model) {
+            return this.$parent[modelName][method](args)
+          }
+          const result = buildSQL(model, MODELS, method, transformedArgs, DIALECT)
+          sql = result.sql
+          params = result.params as unknown[]
         }
 
-        const result = buildSQL(model, MODELS, method, transformedArgs, DIALECT)
-        sql = result.sql
-        params = normalizeParams(result.params as unknown[])
-      }
+        if (debug) {
+          console.log(\`[\${DIALECT}] \${modelName}.\${method} \${prebaked ? '\u26A1 PREBAKED' : '\u{1F528} RUNTIME'}\`)
+          console.log('SQL:', sql)
+          console.log('Params:', params)
+        }
 
-      if (debug) {
-        console.log(\`[\${DIALECT}] \${modelName}.\${method} \${prebaked ? '\u26A1 PREBAKED' : '\u{1F528} RUNTIME'}\`)
-        console.log('SQL:', sql)
-        console.log('Params:', params)
+        const results = await executeQuery(client, method, sql, params)
+        const duration = Date.now() - startTime
+
+        onQuery?.({
+          model: modelName,
+          method,
+          sql,
+          params,
+          duration,
+          prebaked,
+        })
+
+        return transformQueryResults(method, results)
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error)
+        console.warn(\`[prisma-sql] \${modelName}.\${method} acceleration failed, falling back to Prisma: \${msg}\`)
+        if (debug && error instanceof Error && error.stack) {
+          console.warn(error.stack)
+        }
+        return this.$parent[modelName][method](args)
       }
-
-      const results = await executeQuery(client, sql, params)
-      const duration = Date.now() - startTime
-
-      onQuery?.({
-        model: modelName,
-        method,
-        sql,
-        params,
-        duration,
-        prebaked,
-      })
-
-      return transformQueryResults(method, results)
     }
 
     async function batch<T extends Record<string, DeferredQuery>>(
@@ -5381,20 +5819,17 @@ export function speedExtension(config: {
     ): Promise<{ [K in keyof T]: any }> {
       const batchProxy = createBatchProxy()
       const queries = await callback(batchProxy)
-
       const batchQueries: Record<string, BatchQuery> = {}
-
       for (const [key, deferred] of Object.entries(queries)) {
         if (!(deferred instanceof DeferredQuery)) {
           throw new Error(
             \`Batch query '\${key}' must be a deferred query. Did you await it?\`,
           )
         }
-
         batchQueries[key] = {
           model: deferred.model,
           method: deferred.method,
-          args: deferred.args || {},
+          args: transformEnumValuesByModel(deferred.model, deferred.args || {}),
         }
       }
 
@@ -5415,9 +5850,9 @@ export function speedExtension(config: {
       const normalizedParams = normalizeParams(params)
       const rows = await client.unsafe(sql, normalizedParams as any[])
       const row = rows[0] as Record<string, unknown>
-      const results = parseBatchResults(row, keys, batchQueries, aliases)
-      const duration = Date.now() - startTime
+      const results = parseBatchResults(row, keys, batchQueries, aliases, MODEL_MAP)
 
+      const duration = Date.now() - startTime
       onQuery?.({
         model: '_batch',
         method: 'batch',
@@ -5432,7 +5867,6 @@ export function speedExtension(config: {
 
     async function batchCount(queries: BatchCountQuery[]): Promise<number[]> {
       if (queries.length === 0) return []
-
       const startTime = Date.now()
       const { sql, params } = buildBatchCountSql(
         queries,
@@ -5451,8 +5885,8 @@ export function speedExtension(config: {
       const rows = await client.unsafe(sql, normalizedParams as any[])
       const row = rows[0] as Record<string, unknown>
       const results = parseBatchCountResults(row, queries.length)
-      const duration = Date.now() - startTime
 
+      const duration = Date.now() - startTime
       onQuery?.({
         model: '_batch',
         method: 'count',
@@ -5470,14 +5904,15 @@ export function speedExtension(config: {
       options?: TransactionOptions,
     ): Promise<unknown[]> {
       const startTime = Date.now()
-
       if (debug) {
         console.log(\`[\${DIALECT}] $transaction (\${queries.length} queries)\`)
       }
-
-      const results = await txExecutor.execute(queries, options)
+      const transformedQueries = queries.map(q => ({
+        ...q,
+        args: transformEnumValuesByModel(q.model, q.args || {}),
+      }))
+      const results = await txExecutor.execute(transformedQueries, options)
       const duration = Date.now() - startTime
-
       onQuery?.({
         model: '_transaction',
         method: 'transaction',
@@ -5486,13 +5921,11 @@ export function speedExtension(config: {
         duration,
         prebaked: false,
       })
-
       return results
     }
 
     return prisma.$extends({
       name: 'prisma-sql-generated',
-
       client: {
         $original: prisma,
         $batch: batch as <T extends Record<string, DeferredQuery>>(
@@ -5501,7 +5934,6 @@ export function speedExtension(config: {
         $batchCount: batchCount as (...args: any[]) => Promise<number[]>,
         $transaction: transaction as (...args: any[]) => Promise<unknown[]>,
       },
-
       model: {
         $allModels: {
           async findMany(args: any) {
@@ -5526,9 +5958,10 @@ export function speedExtension(config: {
       },
     })
   }
+}`;
 }
-
-type SpeedExtensionReturn = ReturnType<ReturnType<typeof speedExtension>>
+function generateTypeExports() {
+  return `type SpeedExtensionReturn = ReturnType<ReturnType<typeof speedExtension>>
 
 export type SpeedClient<T> = T & {
   $batch<T extends Record<string, DeferredQuery>>(
@@ -5538,8 +5971,22 @@ export type SpeedClient<T> = T & {
   $transaction(queries: TransactionQuery[], options?: TransactionOptions): Promise<unknown[]>
 }
 
-export type { BatchCountQuery, TransactionQuery, TransactionOptions }
-`;
+export type { BatchCountQuery, TransactionQuery, TransactionOptions }`;
+}
+function generateCode(models, queries, dialect, datamodel) {
+  const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
+    fields: model.fields.filter((f) => f !== void 0 && f !== null)
+  }));
+  const { mappings, fieldTypes } = extractEnumMappings(datamodel);
+  return [
+    generateImports(),
+    generateCoreTypes(),
+    generateHelpers(),
+    generateDataConstants(cleanModels, mappings, fieldTypes, queries, dialect),
+    generateTransformLogic(),
+    generateExtension(),
+    generateTypeExports()
+  ].join("\n\n");
 }
 function formatQueries(queries) {
   if (queries.size === 0) {