prisma-sql 1.59.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.59.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,155 +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,
-  MAX_HAVING_DEPTH: 50
-});
-
 // src/utils/normalize-value.ts
 var MAX_DEPTH = 20;
 function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
@@ -308,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";
@@ -526,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;
@@ -744,10 +768,13 @@ function quoteIdent(id) {
   if (typeof id !== "string" || id.trim().length === 0) {
     throw new Error("quoteIdent: identifier is required and cannot be empty");
   }
-  if (/[\u0000-\u001F\u007F]/.test(id)) {
-    throw new Error(
-      `quoteIdent: identifier contains invalid characters: ${JSON.stringify(id)}`
-    );
+  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, '""')}"`;
@@ -812,7 +839,13 @@ function getQuotedColumn(model, 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)) {
@@ -887,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)}`
@@ -917,6 +939,8 @@ function assertSafeQualifiedName(input) {
       );
     }
   }
+}
+function parseQualifiedNameParts(trimmed) {
   let i = 0;
   const n = trimmed.length;
   let parts = 0;
@@ -952,6 +976,21 @@ function assertSafeQualifiedName(input) {
     }
   }
 }
+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");
@@ -1041,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)"
     );
@@ -1062,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}"`
     );
@@ -1110,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;
   }
@@ -1119,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 [];
@@ -1281,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
@@ -1450,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" });
@@ -1694,7 +1735,44 @@ 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, depth = 0) {
+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.IN || op === Ops.NOT_IN) && !isNotNullish(dialect)) {
+    throw createError(`IN operators require a SQL dialect`, { operator: op });
+  }
+  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)) {
+    return handleLikeOperator(expr, op, val, params, mode, dialect);
+  }
+  if (op === Ops.IN || op === Ops.NOT_IN) {
+    return handleInOperator(expr, op, val, params, dialect);
+  }
+  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(
@@ -1711,33 +1789,17 @@ function buildScalarOperator(expr, op, val, params, mode, fieldType, dialect, de
     const placeholder = params.addAuto(val);
     return `${expr} <> ${placeholder}`;
   }
-  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && isNotNullish(dialect)) {
-    const placeholder = params.addAuto(val);
-    return caseInsensitiveEquals(expr, placeholder);
-  }
-  const STRING_LIKE_OPS = /* @__PURE__ */ new Set([
-    Ops.CONTAINS,
-    Ops.STARTS_WITH,
-    Ops.ENDS_WITH
-  ]);
-  if (STRING_LIKE_OPS.has(op)) {
-    if (!isNotNullish(dialect)) {
-      throw createError(`Like operators require a SQL dialect`, {
-        operator: op
-      });
-    }
-    return handleLikeOperator(expr, op, val, params, mode, dialect);
-  }
-  if (op === Ops.IN || op === Ops.NOT_IN) {
-    if (!isNotNullish(dialect)) {
-      throw createError(`IN operators require a SQL dialect`, { operator: op });
-    }
-    return handleInOperator(expr, op, val, params, dialect);
-  }
-  if (op === Ops.EQUALS && mode === Modes.INSENSITIVE && !isNotNullish(dialect)) {
-    throw createError(`Insensitive equals requires a SQL dialect`, {
-      operator: op
-    });
+  validateOperatorRequirements(op, mode, dialect);
+  const specialHandler = routeOperatorHandler(
+    expr,
+    op,
+    val,
+    params,
+    mode,
+    dialect
+  );
+  if (specialHandler !== null) {
+    return specialHandler;
   }
   return handleComparisonOperator(expr, op, val, params);
 }
@@ -1761,38 +1823,32 @@ function handleNotOperator(expr, val, params, outerMode, fieldType, dialect, dep
   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,
-        depth + 1
-      );
+        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,
+    (e, subOp, subVal, p, d) => buildScalarOperator(e, subOp, subVal, p, {
+      mode: effectiveMode,
       fieldType,
-      d,
-      depth + 1
-    ),
-    ` ${SQL_TEMPLATES.AND} `
+      dialect: d,
+      depth: depth + 1
+    }),
+    separator
   );
 }
 function buildDynamicLikePattern(op, placeholder) {
@@ -1989,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 }
       );
     }
   }
@@ -2124,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,
@@ -2144,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}.${quote(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 = [
     {
@@ -2179,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(
@@ -2591,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
@@ -2713,47 +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;
-  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;
@@ -2762,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) {
@@ -2986,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,
@@ -3129,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(
@@ -3196,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,
@@ -3203,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);
@@ -3239,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}`;
@@ -3294,7 +3382,6 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   );
   if (!isList) {
     const sql = buildOneToOneIncludeSql({
-      relName,
       relTable,
       relAlias,
       joins: whereParts.joins,
@@ -3322,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.`
@@ -3331,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++;
@@ -3346,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(
@@ -3362,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;
@@ -3388,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,
@@ -3397,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);
@@ -3445,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(
@@ -3581,133 +3672,140 @@ function finalizeSql(sql, params, dialect) {
     paramMappings: snapshot.mappings
   };
 }
+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;
+    }
+    const next = i + 1;
+    if (next < n && s.charCodeAt(next) === 34) {
+      out += '"';
+      saw = true;
+      i += 2;
+      continue;
+    }
+    if (!saw) {
+      throw new Error(
+        `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++;
+  }
+  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 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;
-      i++;
-    }
-    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}`);
-    }
-    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);
-    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);
+  for (const p of parts) {
+    const trimmed = p.trim();
+    if (trimmed.length === 0) continue;
+    names.push(parseSelectField(trimmed, fromAlias));
   }
   return names;
 }
-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 buildDistinctColumns(distinct, fromAlias, model) {
   return distinct.map((f) => col(fromAlias, f, model)).join(SQL_SEPARATORS.FIELD_LIST);
 }
@@ -3730,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;
@@ -3756,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);
@@ -3791,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,
@@ -4626,32 +4787,32 @@ 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,
@@ -4875,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);
 }
@@ -4903,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;
@@ -4915,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}`);
   });
 }
@@ -4972,16 +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'
-import { normalizeValue } from 'prisma-sql/utils/normalize-value'
-
-class DeferredQuery {
+import { normalizeValue } from 'prisma-sql/utils/normalize-value'`;
+}
+function generateCoreTypes() {
+  return `class DeferredQuery {
   constructor(
     public readonly model: string,
     public readonly method: PrismaMethod,
@@ -5013,9 +5447,10 @@ const ACCELERATED_METHODS = new Set<PrismaMethod>([
   'count',
   'aggregate',
   'groupBy',
-])
-
-function createBatchProxy(): BatchProxy {
+])`;
+}
+function generateHelpers() {
+  return `function createBatchProxy(): BatchProxy {
   return new Proxy(
     {},
     {
@@ -5066,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)}
 
@@ -5081,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
 }
 
@@ -5113,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
 }
 
@@ -5202,21 +5713,7 @@ 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> = {}
@@ -5227,43 +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
@@ -5298,49 +5762,56 @@ export function speedExtension(config: {
     const handleMethod = async function(this: any, method: PrismaMethod, args: any) {
       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, sql, params)
-      const duration = Date.now() - startTime
+        const results = await executeQuery(client, method, sql, params)
+        const duration = Date.now() - startTime
 
-      onQuery?.({
-        model: modelName,
-        method,
-        sql,
-        params,
-        duration,
-        prebaked,
-      })
+        onQuery?.({
+          model: modelName,
+          method,
+          sql,
+          params,
+          duration,
+          prebaked,
+        })
 
-      return transformQueryResults(method, results)
+        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)
+      }
     }
 
     async function batch<T extends Record<string, DeferredQuery>>(
@@ -5358,7 +5829,7 @@ export function speedExtension(config: {
         batchQueries[key] = {
           model: deferred.model,
           method: deferred.method,
-          args: deferred.args || {},
+          args: transformEnumValuesByModel(deferred.model, deferred.args || {}),
         }
       }
 
@@ -5379,7 +5850,7 @@ 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 results = parseBatchResults(row, keys, batchQueries, aliases, MODEL_MAP)
 
       const duration = Date.now() - startTime
       onQuery?.({
@@ -5436,7 +5907,11 @@ export function speedExtension(config: {
       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',
@@ -5483,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>>(
@@ -5495,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) {