prisma-sql 1.58.0 → 1.60.0

package/dist/index.js

@@ -1,5 +1,4 @@
 import { convertDMMFToModels, isDynamicParameter, extractDynamicName } from '@dee-wan/schema-parser';
-export { convertDMMFToModels } from '@dee-wan/schema-parser';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -7,6 +6,9 @@ var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 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 = {}))
@@ -20,6 +22,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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((resolve, reject) => {
     var fulfilled = (value) => {
@@ -41,154 +55,6 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// 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) {
@@ -196,45 +62,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";
@@ -414,140 +289,222 @@ function prepareArrayParam(value, dialect) {
   if (dialect === "postgres") {
     return value.map((v) => normalizeValue(v));
   }
-  return JSON.stringify(value);
-}
-
-// src/builder/shared/validators/type-guards.ts
-function isNotNullish(value) {
-  return value !== null && value !== void 0;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function isEmptyString(value) {
-  return typeof value === "string" && value.trim().length === 0;
-}
-function isNonEmptyArray(value) {
-  return Array.isArray(value) && value.length > 0;
-}
-function isEmptyArray(value) {
-  return Array.isArray(value) && value.length === 0;
-}
-function isPlainObject(val) {
-  if (!isNotNullish(val)) return false;
-  if (Array.isArray(val)) return false;
-  if (typeof val !== "object") return false;
-  return Object.prototype.toString.call(val) === "[object Object]";
-}
-function hasProperty(obj, key) {
-  return isPlainObject(obj) && key in obj;
-}
-function isArrayType(t) {
-  if (!isNotNullish(t)) return false;
-  const normalized = t.replace(/\?$/, "");
-  return normalized.endsWith("[]");
-}
-function isJsonType(t) {
-  return isNotNullish(t) && (t === "Json" || t === "Json?");
-}
-function hasValidContent(sql) {
-  return isNotNullish(sql) && sql.trim().length > 0;
-}
-function hasRequiredKeywords(sql) {
-  const upper = sql.toUpperCase();
-  const hasSelect = upper.includes("SELECT");
-  const hasFrom = upper.includes("FROM");
-  return hasSelect && hasFrom && upper.indexOf("SELECT") < upper.indexOf("FROM");
-}
-
-// src/builder/shared/errors.ts
-var SqlBuilderError = class extends Error {
-  constructor(message, code, context) {
-    super(message);
-    this.name = "SqlBuilderError";
-    this.code = code;
-    this.context = context;
-  }
-};
-function createError(message, ctx, code = "VALIDATION_ERROR") {
-  const parts = [message];
-  if (isNonEmptyArray(ctx.path)) {
-    parts.push(`Path: ${ctx.path.join(".")}`);
-  }
-  if (isNotNullish(ctx.modelName)) {
-    parts.push(`Model: ${ctx.modelName}`);
-  }
-  if (isNonEmptyArray(ctx.availableFields)) {
-    parts.push(`Available fields: ${ctx.availableFields.join(", ")}`);
-  }
-  return new SqlBuilderError(parts.join("\n"), code, ctx);
+  return JSON.stringify(value.map((v) => normalizeValue(v)));
 }
 
-// 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;
+// 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;
 }
-function getFieldInfo(model, fieldName) {
-  return ensureFullCache(model).fieldInfo.get(fieldName);
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
 }
-function getScalarFieldSet(model) {
-  return ensureFullCache(model).scalarFields;
+function isEmptyString(value) {
+  return typeof value === "string" && value.trim().length === 0;
 }
-function getRelationFieldSet(model) {
-  return ensureFullCache(model).relationFields;
+function isNonEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
 }
-function getColumnMap(model) {
-  return ensureFullCache(model).columnMap;
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
 }
-function getQuotedColumn(model, fieldName) {
-  return ensureFullCache(model).quotedColumns.get(fieldName);
+function isPlainObject(val) {
+  if (!isNotNullish(val)) return false;
+  if (Array.isArray(val)) return false;
+  if (typeof val !== "object") return false;
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+function hasProperty(obj, key) {
+  return isPlainObject(obj) && key in obj;
+}
+function isArrayType(t) {
+  if (!isNotNullish(t)) return false;
+  const normalized = t.replace(/\?$/, "");
+  return normalized.endsWith("[]");
+}
+function isJsonType(t) {
+  return isNotNullish(t) && (t === "Json" || t === "Json?");
+}
+function hasValidContent(sql) {
+  return isNotNullish(sql) && sql.trim().length > 0;
+}
+function hasRequiredKeywords(sql) {
+  const upper = sql.toUpperCase();
+  const hasSelect = upper.includes("SELECT");
+  const hasFrom = upper.includes("FROM");
+  return hasSelect && hasFrom && upper.indexOf("SELECT") < upper.indexOf("FROM");
+}
+
+// src/builder/shared/errors.ts
+var SqlBuilderError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.name = "SqlBuilderError";
+    this.code = code;
+    this.context = context;
+  }
+};
+function createError(message, ctx, code = "VALIDATION_ERROR") {
+  const parts = [message];
+  if (isNonEmptyArray(ctx.path)) {
+    parts.push(`Path: ${ctx.path.join(".")}`);
+  }
+  if (isNotNullish(ctx.modelName)) {
+    parts.push(`Model: ${ctx.modelName}`);
+  }
+  if (isNonEmptyArray(ctx.availableFields)) {
+    parts.push(`Available fields: ${ctx.availableFields.join(", ")}`);
+  }
+  return new SqlBuilderError(parts.join("\n"), code, ctx);
 }
 
 // src/builder/shared/validators/sql-validators.ts
@@ -693,23 +650,104 @@ function needsQuoting(identifier) {
   return false;
 }
 
-// src/builder/shared/sql-utils.ts
-function containsControlChars(s) {
-  return /[\u0000-\u001F\u007F]/.test(s);
-}
-function assertNoControlChars(label, s) {
-  if (containsControlChars(s)) {
-    throw new Error(
-      `${label} contains invalid characters: ${JSON.stringify(s)}`
-    );
+// 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");
   }
-}
-function quoteRawIdent(id) {
-  return `"${id.replace(/"/g, '""')}"`;
-}
-function isIdentCharCode(c) {
-  return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
-}
+  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) {
+  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)) {
+    throw new Error(
+      `${label} contains invalid characters: ${JSON.stringify(s)}`
+    );
+  }
+}
+function quoteRawIdent(id) {
+  return `"${id.replace(/"/g, '""')}"`;
+}
+function isIdentCharCode(c) {
+  return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
+}
 function isIdentStartCharCode(c) {
   return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
 }
@@ -770,20 +808,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)}`
@@ -800,6 +827,8 @@ function assertSafeQualifiedName(input) {
       );
     }
   }
+}
+function parseQualifiedNameParts(trimmed) {
   let i = 0;
   const n = trimmed.length;
   let parts = 0;
@@ -835,7 +864,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");
   }
@@ -855,13 +899,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) {
@@ -872,9 +916,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;
 }
@@ -897,7 +941,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(
@@ -924,7 +968,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)"
     );
@@ -945,7 +989,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}"`
     );
@@ -993,8 +1037,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;
   }
@@ -1002,8 +1045,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 [];
@@ -1164,29 +1206,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
@@ -1333,11 +1381,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" });
@@ -1562,6 +1608,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
@@ -1576,45 +1623,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);
-  }
-  if (op === Ops.NOT && isPlainObject(val)) {
-    return handleNotOperator(expr, val, params, mode, fieldType, dialect);
+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) {
-    const placeholder = params.addAuto(val);
-    return `${expr} <> ${placeholder}`;
+  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)) {
-    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);
 }
@@ -1628,7 +1701,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(
@@ -1638,43 +1711,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} || '%')`;
@@ -1690,7 +1755,7 @@ function handleLikeOperator(expr, op, val, params, mode, dialect) {
   if (val === void 0) return "";
   if (isDynamicParameter(val)) {
     const placeholder2 = params.addAuto(val);
-    const patternExpr = buildDynamicLikePattern(op, placeholder2, dialect);
+    const patternExpr = buildDynamicLikePattern(op, placeholder2);
     if (mode === Modes.INSENSITIVE) {
       return caseInsensitiveLike(expr, patternExpr, dialect);
     }
@@ -1868,24 +1933,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 }
       );
     }
   }
@@ -1976,7 +2059,7 @@ function freezeJoins(items) {
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
-function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join, wantNull) {
+function buildToOneNullCheck(field, parentModel, parentAlias, relTable, relAlias, join, wantNull) {
   const isLocal = field.isForeignKeyLocal === true;
   const fkFields = normalizeKeyList(field.foreignKey);
   if (isLocal) {
@@ -1986,8 +2069,7 @@ function buildToOneNullCheck(field, parentAlias, relTable, relAlias, join, wantN
       });
     }
     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];
@@ -2004,6 +2086,35 @@ function buildToOneNotExistsMatch(relTable, relAlias, join, sub) {
   const joins = sub.joins.length > 0 ? ` ${sub.joins.join(" ")}` : "";
   return `${SQL_TEMPLATES.NOT} EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${relTable} ${relAlias}${joins} ${SQL_TEMPLATES.WHERE} ${join} ${SQL_TEMPLATES.AND} ${sub.clause})`;
 }
+function tryOptimizeNoneFilter(noneValue, ctx, relModel, relTable, relAlias, join, 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 ${join}`;
+  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,
@@ -2024,21 +2135,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 ${join}`;
-        const whereClause = `${relAlias}.${quote2(checkField.name)} IS NULL`;
-        return Object.freeze({
-          clause: whereClause,
-          joins: freezeJoins([leftJoinSql])
-        });
-      }
-    }
+    const optimized = tryOptimizeNoneFilter(
+      noneValue,
+      ctx,
+      relModel,
+      relTable,
+      relAlias,
+      join,
+      sub
+    );
+    if (optimized) return optimized;
   }
   const filters = [
     {
@@ -2059,17 +2165,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(
@@ -2125,6 +2222,7 @@ function buildToOneRelationFilters(args) {
     const wantNull = filterKey === "is";
     const clause2 = buildToOneNullCheck(
       field,
+      ctx.model,
       ctx.alias,
       relTable,
       relAlias,
@@ -2354,7 +2452,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);
@@ -2469,15 +2568,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
@@ -2591,49 +2686,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;
@@ -2642,10 +2738,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) {
@@ -2657,17 +2753,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 {
@@ -2870,6 +2962,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,
@@ -3013,19 +3116,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(
@@ -3080,6 +3175,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,
@@ -3087,15 +3183,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);
@@ -3123,13 +3214,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}`;
@@ -3178,7 +3270,6 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   );
   if (!isList) {
     const sql = buildOneToOneIncludeSql({
-      relName,
       relTable,
       relAlias,
       joins: whereParts.joins,
@@ -3206,16 +3297,22 @@ 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 };
-  if (depth > MAX_INCLUDE_DEPTH) {
+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.`
     );
   }
   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++;
@@ -3230,8 +3327,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(
@@ -3246,19 +3347,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;
@@ -3272,8 +3368,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,
@@ -3281,10 +3376,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);
@@ -3329,8 +3425,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(
@@ -3465,139 +3560,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");
   }
@@ -3614,6 +3716,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;
@@ -3640,7 +3788,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);
@@ -3675,17 +3824,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,
@@ -3693,7 +3858,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;
     }
@@ -3706,7 +3871,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],
@@ -4071,6 +4236,7 @@ function buildComparisons(expr, filter, params, dialect, builder, excludeKeys =
 }
 
 // src/builder/aggregates.ts
+var MAX_NOT_DEPTH2 = 50;
 var AGGREGATES = [
   ["_sum", "SUM"],
   ["_avg", "AVG"],
@@ -4185,8 +4351,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(
@@ -4194,7 +4365,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
     );
   }
@@ -4211,23 +4382,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 "";
@@ -4286,7 +4470,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,
@@ -4294,7 +4478,8 @@ function buildHavingEntry(key, value, alias, params, dialect, model) {
       alias,
       params,
       dialect,
-      model
+      model,
+      depth
     );
     return logical ? [logical] : [];
   }
@@ -4321,7 +4506,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;
@@ -4331,13 +4516,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) {
@@ -4374,7 +4559,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) {
@@ -4490,38 +4675,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 (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 (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
@@ -4562,15 +4747,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,
@@ -4610,22 +4801,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;
@@ -4691,12 +4883,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
   };
@@ -4732,62 +4925,6 @@ function generateSQL(directive) {
   });
 }
 
-// src/result-transformers.ts
-function parseAggregateValue(value) {
-  if (typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value)) {
-    return parseFloat(value);
-  }
-  return value;
-}
-function transformGroupByResults(results) {
-  return results.map((row) => {
-    const raw = row;
-    const parsed = {};
-    for (const [key, value] of Object.entries(raw)) {
-      const parts = key.split(".");
-      if (parts.length === 2) {
-        const [group, field] = parts;
-        if (!parsed[group]) parsed[group] = {};
-        parsed[group][field] = parseAggregateValue(value);
-      } else {
-        parsed[key] = value;
-      }
-    }
-    return parsed;
-  });
-}
-function transformCountResults(results) {
-  const result = results[0];
-  const count = (result == null ? void 0 : result["_count._all"]) || (result == null ? void 0 : result.count) || 0;
-  return typeof count === "string" ? parseInt(count, 10) : count;
-}
-function transformAggregateResults(results) {
-  const raw = results[0] || {};
-  const parsed = {};
-  for (const [key, value] of Object.entries(raw)) {
-    const parts = key.split(".");
-    if (parts.length === 2) {
-      const [group, field] = parts;
-      if (!parsed[group]) parsed[group] = {};
-      parsed[group][field] = parseAggregateValue(value);
-    } else {
-      parsed[key] = value;
-    }
-  }
-  return parsed;
-}
-var RESULT_TRANSFORMERS = {
-  findFirst: (results) => results[0] || null,
-  findUnique: (results) => results[0] || null,
-  count: transformCountResults,
-  aggregate: transformAggregateResults,
-  groupBy: transformGroupByResults
-};
-function transformQueryResults(method, results) {
-  const transformer = RESULT_TRANSFORMERS[method];
-  return transformer ? transformer(results) : results;
-}
-
 // src/utils/s3-fifo.ts
 function withDispose(it) {
   const anyIt = it;
@@ -5007,107 +5144,374 @@ function createBoundedCache(maxSize) {
   return new BoundedCache(maxSize);
 }
 
-// src/query-cache.ts
-var queryCache = createBoundedCache(1e3);
-function makeAlias(name) {
-  const base = name.toLowerCase().replace(/[^a-z0-9_]/g, "_").slice(0, 50);
-  const safe = /^[a-z_]/.test(base) ? base : `_${base}`;
-  return SQL_RESERVED_WORDS.has(safe) ? `${safe}_t` : safe;
-}
-function toSqliteParams(sql, params) {
-  const reorderedParams = [];
-  let lastIndex = 0;
-  const parts = [];
-  for (let i = 0; i < sql.length; i++) {
-    if (sql[i] === "$" && i + 1 < sql.length) {
-      let num = 0;
-      let j = i + 1;
-      while (j < sql.length && sql[j] >= "0" && sql[j] <= "9") {
-        num = num * 10 + (sql.charCodeAt(j) - 48);
-        j++;
-      }
-      if (j > i + 1) {
-        parts.push(sql.substring(lastIndex, i));
-        parts.push("?");
-        reorderedParams.push(params[num - 1]);
-        i = j - 1;
-        lastIndex = j;
-      }
-    }
-  }
-  parts.push(sql.substring(lastIndex));
-  return { sql: parts.join(""), params: reorderedParams };
+// src/fast-path.ts
+function getIdField(model) {
+  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (!idField) return null;
+  return {
+    name: "id",
+    dbName: idField.dbName || "id"
+  };
 }
-function canonicalizeQuery(modelName, method, args, dialect) {
-  function normalize(obj) {
-    if (obj === null || obj === void 0) return obj;
-    if (obj instanceof Date) {
-      return "__DATE_PARAM__";
-    }
-    if (Array.isArray(obj)) {
-      return obj.map(normalize);
-    }
-    if (typeof obj === "object") {
-      const sorted = {};
-      for (const key of Object.keys(obj).sort()) {
-        const value = obj[key];
-        sorted[key] = isDynamicParameter(value) ? "__DYN__" : normalize(value);
-      }
-      return sorted;
+function buildColumnList(model, alias) {
+  const cols = [];
+  for (const f of model.fields) {
+    if (f.isRelation) continue;
+    if (f.name.startsWith("@") || f.name.startsWith("//")) continue;
+    const dbName = f.dbName || f.name;
+    if (dbName !== f.name) {
+      cols.push(`${alias}.${quote(dbName)} AS ${quote(f.name)}`);
+    } else {
+      cols.push(`${alias}.${quote(dbName)}`);
     }
-    return obj;
   }
-  const canonical = normalize(args);
-  return `${dialect}:${modelName}:${method}:${JSON.stringify(canonical)}`;
+  return cols.join(", ");
 }
-function buildSQLFull(model, models, method, args, dialect) {
+function getTableAndAlias(model, dialect) {
   const tableName = buildTableReference(
     SQL_TEMPLATES.PUBLIC_SCHEMA,
     model.tableName,
     dialect
   );
   const alias = makeAlias(model.tableName);
-  const whereResult = buildWhereClause(
-    args.where || {},
-    {
-      alias,
-      schemaModels: models,
-      model,
-      path: ["where"],
-      isSubquery: false,
-      dialect
-    }
+  return { tableName, alias };
+}
+function buildSimpleQuery(model, dialect, where, params, suffix = "") {
+  const { tableName, alias } = getTableAndAlias(model, dialect);
+  const columns = buildColumnList(model, alias);
+  const sql = `SELECT ${columns} FROM ${tableName} ${alias} ${where}${suffix}`;
+  return { sql, params };
+}
+function norm(value) {
+  return normalizeValue(value);
+}
+function isScalar(value) {
+  return value !== null && typeof value !== "object";
+}
+function tryFindUniqueById(model, args, dialect) {
+  const where = args.where;
+  if (!isPlainObject(where) || Object.keys(where).length !== 1 || !("id" in where) || !isScalar(where.id) || args.select || args.include) {
+    return null;
+  }
+  const idField = getIdField(model);
+  if (!idField) return null;
+  const { alias } = getTableAndAlias(model, dialect);
+  const whereClause = dialect === "sqlite" ? `WHERE ${alias}.${quote(idField.dbName)} = ?` : `WHERE ${alias}.${quote(idField.dbName)} = $1`;
+  return buildSimpleQuery(
+    model,
+    dialect,
+    whereClause,
+    [norm(where.id)],
+    " LIMIT 1"
   );
-  const withMethod = __spreadProps(__spreadValues({}, args), { method });
-  let result;
-  switch (method) {
-    case "aggregate":
-      result = buildAggregateSql(
-        withMethod,
-        whereResult,
-        tableName,
-        alias,
-        model
-      );
-      break;
-    case "groupBy":
-      result = buildGroupBySql(
-        withMethod,
-        whereResult,
-        tableName,
-        alias,
-        model,
-        dialect
-      );
-      break;
-    case "count":
-      result = buildCountSql(
-        whereResult,
-        tableName,
-        alias,
-        args.skip);
-      break;
-    default:
+}
+function tryFindManyById(model, args, dialect) {
+  const where = args.where;
+  if (!isPlainObject(where) || Object.keys(where).length !== 1 || !("id" in where) || !isScalar(where.id) || args.select || args.include || args.orderBy || args.take || args.skip || args.distinct || args.cursor) {
+    return null;
+  }
+  const idField = getIdField(model);
+  if (!idField) return null;
+  const { alias } = getTableAndAlias(model, dialect);
+  const whereClause = dialect === "sqlite" ? `WHERE ${alias}.${quote(idField.dbName)} = ?` : `WHERE ${alias}.${quote(idField.dbName)} = $1`;
+  return buildSimpleQuery(model, dialect, whereClause, [norm(where.id)]);
+}
+function tryCountAll(model, args, dialect) {
+  const where = args.where;
+  if (where && Object.keys(where).length > 0 || args.select || args.skip) {
+    return null;
+  }
+  const { tableName, alias } = getTableAndAlias(model, dialect);
+  const sql = `SELECT COUNT(*) AS ${quote("_count._all")} FROM ${tableName} ${alias}`;
+  return { sql, params: [] };
+}
+function tryFindManyWithLimit(model, args, dialect) {
+  const where = args.where;
+  if (where && Object.keys(where).length > 0 || args.select || args.include || args.orderBy || args.skip || args.distinct || args.cursor || typeof args.take !== "number" || !Number.isInteger(args.take) || args.take <= 0) {
+    return null;
+  }
+  const { tableName, alias } = getTableAndAlias(model, dialect);
+  const columns = buildColumnList(model, alias);
+  const sql = dialect === "sqlite" ? `SELECT ${columns} FROM ${tableName} ${alias} LIMIT ?` : `SELECT ${columns} FROM ${tableName} ${alias} LIMIT $1`;
+  return { sql, params: [norm(args.take)] };
+}
+function tryFindFirstBySingleField(model, args, dialect) {
+  const where = args.where;
+  if (!isPlainObject(where) || Object.keys(where).length !== 1 || args.select || args.include || args.orderBy || args.skip) {
+    return null;
+  }
+  const field = Object.keys(where)[0];
+  const value = where[field];
+  if (value === null || typeof value === "object") {
+    return null;
+  }
+  const fieldDef = model.fields.find((f) => f.name === field);
+  if (!fieldDef || fieldDef.isRelation) {
+    return null;
+  }
+  const { alias } = getTableAndAlias(model, dialect);
+  const columnName = fieldDef.dbName || field;
+  const whereClause = dialect === "sqlite" ? `WHERE ${alias}.${quote(columnName)} = ?` : `WHERE ${alias}.${quote(columnName)} = $1`;
+  return buildSimpleQuery(
+    model,
+    dialect,
+    whereClause,
+    [norm(value)],
+    " LIMIT 1"
+  );
+}
+function tryFindManyBySingleField(model, args, dialect) {
+  const where = args.where;
+  if (!isPlainObject(where) || Object.keys(where).length !== 1 || args.select || args.include || args.orderBy || args.take || args.skip || args.distinct || args.cursor) {
+    return null;
+  }
+  const field = Object.keys(where)[0];
+  const value = where[field];
+  if (value === null || typeof value === "object") {
+    return null;
+  }
+  const fieldDef = model.fields.find((f) => f.name === field);
+  if (!fieldDef || fieldDef.isRelation) {
+    return null;
+  }
+  const { alias } = getTableAndAlias(model, dialect);
+  const columnName = fieldDef.dbName || field;
+  const whereClause = dialect === "sqlite" ? `WHERE ${alias}.${quote(columnName)} = ?` : `WHERE ${alias}.${quote(columnName)} = $1`;
+  return buildSimpleQuery(model, dialect, whereClause, [norm(value)]);
+}
+function tryFindManyAll(model, args, dialect) {
+  const where = args.where;
+  if (where && Object.keys(where).length > 0 || args.select || args.include || args.orderBy || args.take !== void 0 || args.skip !== void 0 || args.distinct || args.cursor) {
+    return null;
+  }
+  const { tableName, alias } = getTableAndAlias(model, dialect);
+  const columns = buildColumnList(model, alias);
+  const sql = `SELECT ${columns} FROM ${tableName} ${alias}`;
+  return { sql, params: [] };
+}
+function tryFastPath(model, method, args, dialect) {
+  if (method === "findUnique") {
+    return tryFindUniqueById(model, args, dialect);
+  }
+  if (method === "count") {
+    return tryCountAll(model, args, dialect);
+  }
+  if (method === "findFirst") {
+    return tryFindFirstBySingleField(model, args, dialect);
+  }
+  if (method === "findMany") {
+    return tryFindManyById(model, args, dialect) || tryFindManyWithLimit(model, args, dialect) || tryFindManyBySingleField(model, args, dialect) || tryFindManyAll(model, args, dialect);
+  }
+  return null;
+}
+
+// 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);
+var queryCacheStats = new QueryCacheStats();
+function makeAlias(name) {
+  const base = name.toLowerCase().replace(/[^a-z0-9_]/g, "_").slice(0, 50);
+  const safe = /^[a-z_]/.test(base) ? base : `_${base}`;
+  return SQL_RESERVED_WORDS.has(safe) ? `${safe}_t` : safe;
+}
+function handleSingleQuote(sql, state) {
+  const n = sql.length;
+  let i = state.position;
+  let out = state.output + sql[i];
+  i++;
+  while (i < n) {
+    out += sql[i];
+    if (sql.charCodeAt(i) === 39) {
+      if (i + 1 < n && sql.charCodeAt(i + 1) === 39) {
+        out += sql[i + 1];
+        i += 2;
+        continue;
+      }
+      return __spreadProps(__spreadValues({}, state), { mode: "normal", position: i + 1, output: out });
+    }
+    i++;
+  }
+  return __spreadProps(__spreadValues({}, state), { position: i, output: out });
+}
+function handleDoubleQuote(sql, state) {
+  const n = sql.length;
+  let i = state.position;
+  let out = state.output + sql[i];
+  i++;
+  while (i < n) {
+    out += sql[i];
+    if (sql.charCodeAt(i) === 34) {
+      if (i + 1 < n && sql.charCodeAt(i + 1) === 34) {
+        out += sql[i + 1];
+        i += 2;
+        continue;
+      }
+      return __spreadProps(__spreadValues({}, state), { mode: "normal", position: i + 1, output: out });
+    }
+    i++;
+  }
+  return __spreadProps(__spreadValues({}, state), { position: i, output: out });
+}
+function extractParameterNumber(sql, startPos) {
+  const n = sql.length;
+  let j = startPos + 1;
+  let num = 0;
+  let hasDigit = false;
+  while (j < n) {
+    const d = sql.charCodeAt(j);
+    if (d >= 48 && d <= 57) {
+      num = num * 10 + (d - 48);
+      hasDigit = true;
+      j++;
+    } else {
+      break;
+    }
+  }
+  if (hasDigit && num >= 1) {
+    return { num, nextPos: j };
+  }
+  return null;
+}
+function handleParameterSubstitution(sql, params, state) {
+  const result = extractParameterNumber(sql, state.position);
+  if (result) {
+    return __spreadProps(__spreadValues({}, state), {
+      position: result.nextPos,
+      output: state.output + "?",
+      reorderedParams: [...state.reorderedParams, params[result.num - 1]]
+    });
+  }
+  return __spreadProps(__spreadValues({}, state), {
+    position: state.position + 1,
+    output: state.output + sql[state.position]
+  });
+}
+function toSqliteParams(sql, params) {
+  const n = sql.length;
+  let state = {
+    mode: "normal",
+    position: 0,
+    output: "",
+    reorderedParams: []
+  };
+  while (state.position < n) {
+    const ch = sql.charCodeAt(state.position);
+    if (state.mode === "single") {
+      state = handleSingleQuote(sql, state);
+      continue;
+    }
+    if (state.mode === "double") {
+      state = handleDoubleQuote(sql, state);
+      continue;
+    }
+    if (ch === 39) {
+      state = __spreadProps(__spreadValues({}, state), { mode: "single" });
+      continue;
+    }
+    if (ch === 34) {
+      state = __spreadProps(__spreadValues({}, state), { mode: "double" });
+      continue;
+    }
+    if (ch === 36) {
+      state = handleParameterSubstitution(sql, params, state);
+      continue;
+    }
+    state = __spreadProps(__spreadValues({}, state), {
+      position: state.position + 1,
+      output: state.output + sql[state.position]
+    });
+  }
+  return { sql: state.output, params: state.reorderedParams };
+}
+function canonicalizeReplacer(key, value) {
+  if (typeof value === "bigint") return `__bigint__${value.toString()}`;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const sorted = {};
+    for (const k of Object.keys(obj).sort()) {
+      sorted[k] = obj[k];
+    }
+    return sorted;
+  }
+  return value;
+}
+function canonicalizeQuery(modelName, method, args, dialect) {
+  if (!args) return `${dialect}:${modelName}:${method}:{}`;
+  return `${dialect}:${modelName}:${method}:${JSON.stringify(args, canonicalizeReplacer)}`;
+}
+function buildSQLFull(model, models, method, args, dialect) {
+  const tableName = buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    model.tableName,
+    dialect
+  );
+  const alias = makeAlias(model.tableName);
+  const whereResult = buildWhereClause(
+    args.where || {},
+    {
+      alias,
+      schemaModels: models,
+      model,
+      path: ["where"],
+      isSubquery: false,
+      dialect
+    }
+  );
+  const withMethod = __spreadProps(__spreadValues({}, args), { method });
+  let result;
+  switch (method) {
+    case "aggregate":
+      result = buildAggregateSql(
+        withMethod,
+        whereResult,
+        tableName,
+        alias,
+        model
+      );
+      break;
+    case "groupBy":
+      result = buildGroupBySql(
+        withMethod,
+        whereResult,
+        tableName,
+        alias,
+        model,
+        dialect
+      );
+      break;
+    case "count":
+      result = buildCountSql(
+        whereResult,
+        tableName,
+        alias,
+        args.skip);
+      break;
+    default:
       result = buildSelectSql({
         method,
         args: withMethod,
@@ -5122,207 +5526,211 @@ function buildSQLFull(model, models, method, args, dialect) {
 }
 function buildSQLWithCache(model, models, method, args, dialect) {
   const cacheKey = canonicalizeQuery(model.name, method, args, dialect);
-  const cachedSql = queryCache.get(cacheKey);
-  if (cachedSql) {
-    const result2 = buildSQLFull(model, models, method, args, dialect);
-    return { sql: cachedSql, params: result2.params };
+  const cached = queryCache.get(cacheKey);
+  if (cached) {
+    queryCacheStats.hit();
+    return { sql: cached.sql, params: [...cached.params] };
+  }
+  queryCacheStats.miss();
+  const fastResult = tryFastPath(model, method, args, dialect);
+  if (fastResult) {
+    queryCache.set(cacheKey, {
+      sql: fastResult.sql,
+      params: [...fastResult.params]
+    });
+    return fastResult;
   }
   const result = buildSQLFull(model, models, method, args, dialect);
-  queryCache.set(cacheKey, result.sql);
-  queryCache.size;
+  queryCache.set(cacheKey, { sql: result.sql, params: [...result.params] });
   return result;
 }
 
 // src/batch.ts
-function assertNoControlChars2(label, s) {
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    if (c <= 31 || c === 127) {
-      throw new Error(`${label} contains control characters`);
-    }
+function quoteBatchIdent(id) {
+  const raw = String(id);
+  assertSafeAlias(raw);
+  return `"${raw.replace(/"/g, '""')}"`;
+}
+function makeBatchAlias(i) {
+  return `k${i}`;
+}
+function isDigit(charCode) {
+  return charCode >= 48 && charCode <= 57;
+}
+function isAlphaNumericOrUnderscore(charCode) {
+  return isDigit(charCode) || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 95;
+}
+function readDollarTag(s, pos, n) {
+  if (s.charCodeAt(pos) !== 36) return null;
+  let j = pos + 1;
+  while (j < n && isAlphaNumericOrUnderscore(s.charCodeAt(j))) {
+    j++;
+  }
+  if (j < n && s.charCodeAt(j) === 36 && j > pos) {
+    return s.slice(pos, j + 1);
+  }
+  if (pos + 1 < n && s.charCodeAt(pos + 1) === 36) {
+    return "$$";
   }
+  return null;
 }
-function assertSafeIdentifier(label, s) {
-  const raw = String(s);
-  if (raw.trim() !== raw) {
-    throw new Error(`${label} must not contain leading/trailing whitespace`);
+function parseParamPlaceholder(s, i, n, replace) {
+  let j = i + 1;
+  if (j >= n) {
+    return { consumed: 1, output: s[i] };
   }
-  if (raw.length === 0) throw new Error(`${label} cannot be empty`);
-  assertNoControlChars2(label, raw);
-  if (/[ \t\r\n]/.test(raw)) {
-    throw new Error(`${label} must not contain whitespace`);
+  const c1 = s.charCodeAt(j);
+  if (!isDigit(c1)) {
+    return { consumed: 1, output: s[i] };
   }
-  if (raw.includes(";")) {
-    throw new Error(`${label} must not contain semicolons`);
+  while (j < n && isDigit(s.charCodeAt(j))) {
+    j++;
   }
-  if (raw.includes("--") || raw.includes("/*") || raw.includes("*/")) {
-    throw new Error(`${label} must not contain SQL comment tokens`);
+  const numStr = s.slice(i + 1, j);
+  const oldIndex = Number(numStr);
+  if (!Number.isInteger(oldIndex) || oldIndex < 1) {
+    throw new Error(`Invalid param placeholder: $${numStr}`);
   }
+  return { consumed: j - i, output: replace(oldIndex) };
 }
-function quoteIdent(id) {
-  const raw = String(id);
-  assertSafeIdentifier("Identifier", raw);
-  return `"${raw.replace(/"/g, '""')}"`;
+function handleDollarInNormalMode(s, i, n, state, replace) {
+  const tag = readDollarTag(s, i, n);
+  if (tag) {
+    return {
+      consumed: tag.length,
+      output: tag,
+      newState: { mode: "dollar", dollarTag: tag }
+    };
+  }
+  const placeholder = parseParamPlaceholder(s, i, n, replace);
+  return __spreadProps(__spreadValues({}, placeholder), { newState: state });
 }
-function makeBatchAlias(i) {
-  return `k${i}`;
+function handleCommentStart(s, i, n, ch) {
+  if (ch === 45 && i + 1 < n && s.charCodeAt(i + 1) === 45) {
+    return {
+      consumed: 2,
+      output: "--",
+      newState: { mode: "lineComment", dollarTag: null }
+    };
+  }
+  if (ch === 47 && i + 1 < n && s.charCodeAt(i + 1) === 42) {
+    return {
+      consumed: 2,
+      output: "/*",
+      newState: { mode: "blockComment", dollarTag: null }
+    };
+  }
+  return null;
+}
+function processNormalMode(s, i, n, state, replace) {
+  const ch = s.charCodeAt(i);
+  if (ch === 39) {
+    return {
+      consumed: 1,
+      output: s[i],
+      newState: { mode: "single", dollarTag: null }
+    };
+  }
+  if (ch === 34) {
+    return {
+      consumed: 1,
+      output: s[i],
+      newState: { mode: "double", dollarTag: null }
+    };
+  }
+  const commentResult = handleCommentStart(s, i, n, ch);
+  if (commentResult) return commentResult;
+  if (ch === 36) {
+    return handleDollarInNormalMode(s, i, n, state, replace);
+  }
+  return { consumed: 1, output: s[i], newState: state };
+}
+function processQuoteMode(s, i, n, quoteChar) {
+  const ch = s.charCodeAt(i);
+  if (ch === quoteChar) {
+    if (i + 1 < n && s.charCodeAt(i + 1) === quoteChar) {
+      return { consumed: 2, output: s[i] + s[i + 1], shouldExitMode: false };
+    }
+    return { consumed: 1, output: s[i], shouldExitMode: true };
+  }
+  return { consumed: 1, output: s[i], shouldExitMode: false };
+}
+function processBlockCommentMode(s, i, n) {
+  const ch = s.charCodeAt(i);
+  if (ch === 42 && i + 1 < n && s.charCodeAt(i + 1) === 47) {
+    return { consumed: 2, output: "*/", shouldExitMode: true };
+  }
+  return { consumed: 1, output: s[i], shouldExitMode: false };
+}
+function processDollarMode(s, i, dollarTag) {
+  if (s.slice(i, i + dollarTag.length) === dollarTag) {
+    return {
+      consumed: dollarTag.length,
+      output: dollarTag,
+      shouldExitMode: true
+    };
+  }
+  return { consumed: 1, output: s[i], shouldExitMode: false };
+}
+function processLineCommentMode(ch) {
+  return { shouldExitMode: ch === 10 };
+}
+function processCharacter(s, i, n, state, replace) {
+  const ch = s.charCodeAt(i);
+  switch (state.mode) {
+    case "normal":
+      return processNormalMode(s, i, n, state, replace);
+    case "single":
+      return processQuoteMode(s, i, n, 39);
+    case "double":
+      return processQuoteMode(s, i, n, 34);
+    case "lineComment": {
+      const result = processLineCommentMode(ch);
+      return {
+        consumed: 1,
+        output: s[i],
+        shouldExitMode: result.shouldExitMode
+      };
+    }
+    case "blockComment":
+      return processBlockCommentMode(s, i, n);
+    case "dollar":
+      return state.dollarTag ? processDollarMode(s, i, state.dollarTag) : { consumed: 1, output: s[i], shouldExitMode: false };
+    default:
+      return { consumed: 1, output: s[i], shouldExitMode: false };
+  }
+}
+function updateStateAfterProcessing(currentState, result) {
+  if (result.newState) {
+    return result.newState;
+  }
+  if (result.shouldExitMode) {
+    return { mode: "normal", dollarTag: null };
+  }
+  return currentState;
 }
 function replacePgPlaceholders(sql, replace) {
   const s = String(sql);
   const n = s.length;
   let i = 0;
-  let mode = "normal";
-  let dollarTag = null;
+  let state = { mode: "normal", dollarTag: null };
   let out = "";
-  const startsWith = (pos, lit) => s.slice(pos, pos + lit.length) === lit;
-  const readDollarTag = (pos) => {
-    if (s.charCodeAt(pos) !== 36) return null;
-    let j = pos + 1;
-    while (j < n) {
-      const c = s.charCodeAt(j);
-      if (c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95) {
-        j++;
-        continue;
-      }
-      break;
-    }
-    if (j < n && s.charCodeAt(j) === 36 && j > pos) {
-      return s.slice(pos, j + 1);
-    }
-    if (pos + 1 < n && s.charCodeAt(pos + 1) === 36) {
-      return "$$";
-    }
-    return null;
-  };
-  while (i < n) {
-    const ch = s.charCodeAt(i);
-    if (mode === "normal") {
-      if (ch === 39) {
-        out += s[i];
-        mode = "single";
-        i++;
-        continue;
-      }
-      if (ch === 34) {
-        out += s[i];
-        mode = "double";
-        i++;
-        continue;
-      }
-      if (ch === 45 && i + 1 < n && s.charCodeAt(i + 1) === 45) {
-        out += "--";
-        mode = "lineComment";
-        i += 2;
-        continue;
-      }
-      if (ch === 47 && i + 1 < n && s.charCodeAt(i + 1) === 42) {
-        out += "/*";
-        mode = "blockComment";
-        i += 2;
-        continue;
-      }
-      if (ch === 36) {
-        const tag = readDollarTag(i);
-        if (tag) {
-          out += tag;
-          mode = "dollar";
-          dollarTag = tag;
-          i += tag.length;
-          continue;
-        }
-        let j = i + 1;
-        if (j < n) {
-          const c1 = s.charCodeAt(j);
-          if (c1 >= 48 && c1 <= 57) {
-            while (j < n) {
-              const cj = s.charCodeAt(j);
-              if (cj >= 48 && cj <= 57) {
-                j++;
-                continue;
-              }
-              break;
-            }
-            const numStr = s.slice(i + 1, j);
-            const oldIndex = Number(numStr);
-            if (!Number.isInteger(oldIndex) || oldIndex < 1) {
-              throw new Error(`Invalid param placeholder: $${numStr}`);
-            }
-            out += replace(oldIndex);
-            i = j;
-            continue;
-          }
-        }
-      }
-      out += s[i];
-      i++;
-      continue;
-    }
-    if (mode === "single") {
-      out += s[i];
-      if (ch === 39) {
-        if (i + 1 < n && s.charCodeAt(i + 1) === 39) {
-          out += s[i + 1];
-          i += 2;
-          continue;
-        }
-        mode = "normal";
-        i++;
-        continue;
-      }
-      i++;
-      continue;
-    }
-    if (mode === "double") {
-      out += s[i];
-      if (ch === 34) {
-        if (i + 1 < n && s.charCodeAt(i + 1) === 34) {
-          out += s[i + 1];
-          i += 2;
-          continue;
-        }
-        mode = "normal";
-        i++;
-        continue;
-      }
-      i++;
-      continue;
-    }
-    if (mode === "lineComment") {
-      out += s[i];
-      if (ch === 10) {
-        mode = "normal";
-      }
-      i++;
-      continue;
-    }
-    if (mode === "blockComment") {
-      if (ch === 42 && i + 1 < n && s.charCodeAt(i + 1) === 47) {
-        out += "*/";
-        i += 2;
-        mode = "normal";
-        continue;
-      }
-      out += s[i];
-      i++;
-      continue;
-    }
-    if (mode === "dollar") {
-      if (dollarTag && startsWith(i, dollarTag)) {
-        out += dollarTag;
-        i += dollarTag.length;
-        mode = "normal";
-        dollarTag = null;
-        continue;
-      }
-      out += s[i];
-      i++;
-      continue;
-    }
-    out += s[i];
-    i++;
+  while (i < n) {
+    const result = processCharacter(s, i, n, state, replace);
+    out += result.output;
+    i += result.consumed;
+    state = updateStateAfterProcessing(state, result);
   }
   return out;
 }
+function containsPgPlaceholder(sql) {
+  let found = false;
+  replacePgPlaceholders(sql, (oldIndex) => {
+    found = true;
+    return `$${oldIndex}`;
+  });
+  return found;
+}
 function reindexParams(sql, params, offset) {
   if (!Number.isInteger(offset) || offset < 0) {
     throw new Error(`Invalid param offset: ${offset}`);
@@ -5346,7 +5754,7 @@ function reindexParams(sql, params, offset) {
   return { sql: reindexed, params: newParams };
 }
 function wrapQueryForMethod(method, cteName, resultAlias) {
-  const outKey = quoteIdent(resultAlias);
+  const outKey = quoteBatchIdent(resultAlias);
   switch (method) {
     case "findMany":
     case "groupBy":
@@ -5364,24 +5772,70 @@ function wrapQueryForMethod(method, cteName, resultAlias) {
 }
 function isAllCountQueries(queries, keys) {
   var _a;
-  for (let i = 0; i < keys.length; i++) {
-    if (((_a = queries[keys[i]]) == null ? void 0 : _a.method) !== "count") return false;
+  for (const key of keys) {
+    if (((_a = queries[key]) == null ? void 0 : _a.method) !== "count") return false;
   }
   return true;
 }
 function looksTooComplexForFilter(sql) {
   const s = sql.toLowerCase();
-  if (s.includes(" group by ")) return true;
-  if (s.includes(" having ")) return true;
-  if (s.includes(" union ")) return true;
-  if (s.includes(" intersect ")) return true;
-  if (s.includes(" except ")) return true;
-  if (s.includes(" window ")) return true;
-  if (s.includes(" distinct ")) return true;
-  return false;
+  const complexKeywords = [
+    " group by ",
+    " having ",
+    " union ",
+    " intersect ",
+    " except ",
+    " window ",
+    " distinct "
+  ];
+  return complexKeywords.some((keyword) => s.includes(keyword));
 }
-function containsPgPlaceholder(sql) {
-  return /\$[1-9][0-9]*/.test(sql);
+function skipWhitespace(s, i) {
+  while (i < s.length && /\s/.test(s[i])) {
+    i++;
+  }
+  return i;
+}
+function matchKeyword(s, i, keyword) {
+  const lower = s.slice(i).toLowerCase();
+  if (!lower.startsWith(keyword)) return -1;
+  const endPos = i + keyword.length;
+  if (endPos < s.length && /[a-z0-9_]/i.test(s[endPos])) return -1;
+  return endPos;
+}
+function parseQuotedIdentifier2(s, i) {
+  let j = i + 1;
+  while (j < s.length) {
+    if (s[j] === '"') {
+      if (j + 1 < s.length && s[j + 1] === '"') {
+        j += 2;
+        continue;
+      }
+      return { value: s.slice(i, j + 1), endPos: j + 1 };
+    }
+    j++;
+  }
+  return null;
+}
+function parseUnquotedIdentifier2(s, i) {
+  if (!/[a-z_]/i.test(s[i])) return null;
+  let j = i;
+  while (j < s.length && /[a-z0-9_.]/i.test(s[j])) {
+    j++;
+  }
+  return { value: s.slice(i, j), endPos: j };
+}
+function parseIdentifier(s, i) {
+  if (i >= s.length) return null;
+  if (s[i] === '"') {
+    return parseQuotedIdentifier2(s, i);
+  }
+  return parseUnquotedIdentifier2(s, i);
+}
+function findFromClauseEnd(s, fromStart) {
+  const lower = s.slice(fromStart).toLowerCase();
+  const whereIdx = lower.indexOf(" where ");
+  return whereIdx === -1 ? s.length : fromStart + whereIdx;
 }
 function parseSimpleCountSql(sql) {
   const trimmed = sql.trim().replace(/;$/, "").trim();
@@ -5389,111 +5843,181 @@ function parseSimpleCountSql(sql) {
   if (!lower.startsWith("select")) return null;
   if (!lower.includes("count(*)")) return null;
   if (looksTooComplexForFilter(trimmed)) return null;
-  const match = trimmed.match(
-    /^select\s+count\(\*\)(?:\s*::\s*[a-zA-Z0-9_\."]+)?\s+as\s+("[^"]+"|[a-zA-Z_][a-zA-Z0-9_\.]*)\s+from\s+([\s\S]+?)(?:\s+where\s+([\s\S]+))?$/i
-  );
-  if (!match) return null;
-  const fromSql = match[2].trim();
-  const whereSql = match[3] ? match[3].trim() : null;
+  let pos = matchKeyword(trimmed, 0, "select");
+  if (pos === -1) return null;
+  pos = skipWhitespace(trimmed, pos);
+  const countMatch = trimmed.slice(pos).match(/^count\(\*\)/i);
+  if (!countMatch) return null;
+  pos += countMatch[0].length;
+  pos = skipWhitespace(trimmed, pos);
+  const castMatch = trimmed.slice(pos).match(/^::\s*\w+/);
+  if (castMatch) {
+    pos += castMatch[0].length;
+    pos = skipWhitespace(trimmed, pos);
+  }
+  const asPos = matchKeyword(trimmed, pos, "as");
+  if (asPos === -1) return null;
+  pos = skipWhitespace(trimmed, asPos);
+  const ident = parseIdentifier(trimmed, pos);
+  if (!ident) return null;
+  pos = skipWhitespace(trimmed, ident.endPos);
+  const fromPos = matchKeyword(trimmed, pos, "from");
+  if (fromPos === -1) return null;
+  pos = skipWhitespace(trimmed, fromPos);
+  const fromEnd = findFromClauseEnd(trimmed, pos);
+  const fromSql = trimmed.slice(pos, fromEnd).trim();
   if (!fromSql) return null;
+  let whereSql = null;
+  if (fromEnd < trimmed.length) {
+    const adjustedPos = skipWhitespace(trimmed, fromEnd);
+    const wherePos = matchKeyword(trimmed, adjustedPos, "where");
+    if (wherePos !== -1) {
+      whereSql = trimmed.slice(skipWhitespace(trimmed, wherePos)).trim();
+    }
+  }
   return { fromSql, whereSql };
 }
-function buildMergedCountBatchSql(queries, keys, aliasesByKey, modelMap, models, dialect) {
+function processCountQuery(item, model, models, dialect, sharedFrom, localParams) {
+  const built = buildSQLWithCache(model, models, "count", item.args, dialect);
+  const parsed = parseSimpleCountSql(built.sql);
+  if (!parsed) return null;
+  if (containsPgPlaceholder(parsed.fromSql)) return null;
+  const currentFrom = parsed.fromSql;
+  if (sharedFrom !== null && sharedFrom !== currentFrom) return null;
+  if (!parsed.whereSql) {
+    if (built.params.length > 0) return null;
+    return {
+      expression: `count(*) AS ${quoteBatchIdent(item.alias)}`,
+      reindexedParams: [],
+      sharedFrom: currentFrom
+    };
+  }
+  const re = reindexParams(parsed.whereSql, built.params, localParams.length);
+  return {
+    expression: `count(*) FILTER (WHERE ${re.sql}) AS ${quoteBatchIdent(item.alias)}`,
+    reindexedParams: re.params,
+    sharedFrom: currentFrom
+  };
+}
+function buildCountSubqueriesForModel(items, model, models, dialect, aliasIndex) {
+  let sharedFrom = null;
+  const expressions = [];
+  const localParams = [];
+  const localKeys = [];
+  const localAliases = [];
+  for (const item of items) {
+    const result = processCountQuery(
+      item,
+      model,
+      models,
+      dialect,
+      sharedFrom,
+      localParams
+    );
+    if (!result) return null;
+    sharedFrom = result.sharedFrom;
+    expressions.push(result.expression);
+    for (const param of result.reindexedParams) {
+      localParams.push(param);
+    }
+    localKeys.push(item.key);
+    localAliases.push(item.alias);
+  }
+  if (!sharedFrom) return null;
+  const alias = `m_${aliasIndex}`;
+  const subSql = `(SELECT ${expressions.join(", ")} FROM ${sharedFrom}) ${alias}`;
+  return {
+    alias,
+    sql: subSql,
+    params: localParams,
+    keys: localKeys,
+    aliases: localAliases
+  };
+}
+function groupQueriesByModel(queries, keys, aliasesByKey) {
   const modelGroups = /* @__PURE__ */ new Map();
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
+  for (const key of keys) {
     const q = queries[key];
     const alias = aliasesByKey.get(key);
     if (!alias) return null;
-    if (!modelGroups.has(q.model)) modelGroups.set(q.model, []);
-    modelGroups.get(q.model).push({ key, alias, args: q.args || {} });
+    if (!modelGroups.has(q.model)) {
+      modelGroups.set(q.model, []);
+    }
+    const items = modelGroups.get(q.model);
+    if (items) {
+      items.push({
+        key,
+        alias,
+        args: q.args || {}
+      });
+    }
   }
+  return modelGroups;
+}
+function buildSubqueriesFromGroups(modelGroups, modelMap, models, dialect) {
   const subqueries = [];
   let aliasIndex = 0;
   for (const [modelName, items] of modelGroups) {
     const model = modelMap.get(modelName);
     if (!model) return null;
-    let sharedFrom = null;
-    const expressions = [];
-    const localParams = [];
-    const localKeys = [];
-    const localAliases = [];
-    for (let i = 0; i < items.length; i++) {
-      const { key, alias: alias2, args } = items[i];
-      const built = buildSQLWithCache(model, models, "count", args, dialect);
-      const parsed = parseSimpleCountSql(built.sql);
-      if (!parsed) return null;
-      if (containsPgPlaceholder(parsed.fromSql)) {
-        return null;
-      }
-      if (!parsed.whereSql) {
-        if (built.params.length > 0) return null;
-        if (sharedFrom === null) sharedFrom = parsed.fromSql;
-        if (sharedFrom !== parsed.fromSql) return null;
-        expressions.push(`count(*) AS ${quoteIdent(alias2)}`);
-        localKeys.push(key);
-        localAliases.push(alias2);
-        continue;
-      }
-      if (sharedFrom === null) sharedFrom = parsed.fromSql;
-      if (sharedFrom !== parsed.fromSql) return null;
-      const re = reindexParams(
-        parsed.whereSql,
-        built.params,
-        localParams.length
-      );
-      for (let p = 0; p < re.params.length; p++) localParams.push(re.params[p]);
-      expressions.push(
-        `count(*) FILTER (WHERE ${re.sql}) AS ${quoteIdent(alias2)}`
-      );
-      localKeys.push(key);
-      localAliases.push(alias2);
-    }
-    if (!sharedFrom) return null;
-    const alias = `m_${aliasIndex++}`;
-    const subSql = `(SELECT ${expressions.join(", ")} FROM ${sharedFrom}) ${alias}`;
-    subqueries.push({
-      alias,
-      sql: subSql,
-      params: localParams,
-      keys: localKeys,
-      aliases: localAliases
-    });
+    const subquery = buildCountSubqueriesForModel(
+      items,
+      model,
+      models,
+      dialect,
+      aliasIndex++
+    );
+    if (!subquery) return null;
+    subqueries.push(subquery);
   }
-  if (subqueries.length === 0) return null;
+  return subqueries.length > 0 ? subqueries : null;
+}
+function reindexSubqueries(subqueries) {
   let offset = 0;
   const rewrittenSubs = [];
   const finalParams = [];
-  for (let i = 0; i < subqueries.length; i++) {
-    const sq = subqueries[i];
+  for (const sq of subqueries) {
     const re = reindexParams(sq.sql, sq.params, offset);
     offset += re.params.length;
     rewrittenSubs.push(re.sql);
-    for (let p = 0; p < re.params.length; p++) finalParams.push(re.params[p]);
+    for (const p of re.params) {
+      finalParams.push(p);
+    }
   }
+  return { sql: rewrittenSubs, params: finalParams };
+}
+function buildSelectParts(subqueries) {
   const selectParts = [];
-  for (let i = 0; i < subqueries.length; i++) {
-    const sq = subqueries[i];
-    for (let k = 0; k < sq.aliases.length; k++) {
-      const outAlias = sq.aliases[k];
+  for (const sq of subqueries) {
+    for (const outAlias of sq.aliases) {
       selectParts.push(
-        `${sq.alias}.${quoteIdent(outAlias)} AS ${quoteIdent(outAlias)}`
+        `${sq.alias}.${quoteBatchIdent(outAlias)} AS ${quoteBatchIdent(outAlias)}`
       );
     }
   }
+  return selectParts;
+}
+function buildMergedCountBatchSql(queries, keys, aliasesByKey, modelMap, models, dialect) {
+  const modelGroups = groupQueriesByModel(queries, keys, aliasesByKey);
+  if (!modelGroups) return null;
+  const subqueries = buildSubqueriesFromGroups(
+    modelGroups,
+    modelMap,
+    models,
+    dialect
+  );
+  if (!subqueries) return null;
+  const { sql: rewrittenSubs, params: finalParams } = reindexSubqueries(subqueries);
+  const selectParts = buildSelectParts(subqueries);
   const fromSql = rewrittenSubs.join(" CROSS JOIN ");
   const sql = `SELECT ${selectParts.join(", ")} FROM ${fromSql}`;
-  const aliases = keys.map((k) => aliasesByKey.get(k));
+  const aliases = keys.map((k) => {
+    var _a;
+    return (_a = aliasesByKey.get(k)) != null ? _a : "";
+  });
   return { sql, params: finalParams, keys, aliases };
 }
-function buildBatchSql(queries, modelMap, models, dialect) {
-  const keys = Object.keys(queries);
-  if (keys.length === 0) {
-    throw new Error("buildBatchSql requires at least one query");
-  }
-  if (dialect !== "postgres") {
-    throw new Error("Batch queries are only supported for postgres dialect");
-  }
+function buildAliasesForKeys(keys) {
   const aliases = new Array(keys.length);
   const aliasesByKey = /* @__PURE__ */ new Map();
   for (let i = 0; i < keys.length; i++) {
@@ -5501,17 +6025,9 @@ function buildBatchSql(queries, modelMap, models, dialect) {
     aliases[i] = a;
     aliasesByKey.set(keys[i], a);
   }
-  if (isAllCountQueries(queries, keys)) {
-    const merged = buildMergedCountBatchSql(
-      queries,
-      keys,
-      aliasesByKey,
-      modelMap,
-      models,
-      dialect
-    );
-    if (merged) return merged;
-  }
+  return { aliases, aliasesByKey };
+}
+function buildRegularBatchQueries(queries, keys, aliases, modelMap, models, dialect) {
   const ctes = new Array(keys.length);
   const selects = new Array(keys.length);
   const allParams = [];
@@ -5536,541 +6052,51 @@ function buildBatchSql(queries, modelMap, models, dialect) {
       queryParams,
       allParams.length
     );
-    for (let p = 0; p < reindexedParams.length; p++) {
-      allParams.push(reindexedParams[p]);
+    for (const p of reindexedParams) {
+      allParams.push(p);
     }
     const cteName = `batch_${i}`;
     ctes[i] = `${cteName} AS (${reindexedSql})`;
     selects[i] = wrapQueryForMethod(query.method, cteName, aliases[i]);
   }
   const sql = `WITH ${ctes.join(", ")} SELECT ${selects.join(", ")}`;
-  return { sql, params: allParams, keys, aliases };
+  return { sql, params: allParams };
 }
-function buildBatchCountSql(queries, modelMap, models, dialect) {
-  if (queries.length === 0) {
-    throw new Error("buildBatchCountSql requires at least one query");
+function buildBatchSql(queries, modelMap, models, dialect) {
+  const keys = Object.keys(queries);
+  if (keys.length === 0) {
+    throw new Error("buildBatchSql requires at least one query");
   }
   if (dialect !== "postgres") {
-    throw new Error(
-      "Batch count queries are only supported for postgres dialect"
-    );
+    throw new Error("Batch queries are only supported for postgres dialect");
   }
-  const ctes = new Array(queries.length);
-  const selects = new Array(queries.length);
-  const allParams = [];
-  for (let i = 0; i < queries.length; i++) {
-    const query = queries[i];
-    const model = modelMap.get(query.model);
-    if (!model) {
-      throw new Error(
-        `Model '${query.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
-      );
-    }
-    const { sql: querySql, params: queryParams } = buildSQLWithCache(
-      model,
+  const { aliases, aliasesByKey } = buildAliasesForKeys(keys);
+  if (isAllCountQueries(queries, keys)) {
+    const merged = buildMergedCountBatchSql(
+      queries,
+      keys,
+      aliasesByKey,
+      modelMap,
       models,
-      "count",
-      query.args || {},
       dialect
     );
-    const { sql: reindexedSql, params: reindexedParams } = reindexParams(
-      querySql,
-      queryParams,
-      allParams.length
-    );
-    for (let p = 0; p < reindexedParams.length; p++) {
-      allParams.push(reindexedParams[p]);
-    }
-    const cteName = `count_${i}`;
-    const resultKey = `count_${i}`;
-    ctes[i] = `${cteName} AS (${reindexedSql})`;
-    selects[i] = `(SELECT * FROM ${cteName}) AS ${quoteIdent(resultKey)}`;
-  }
-  const sql = `WITH ${ctes.join(", ")} SELECT ${selects.join(", ")}`;
-  return { sql, params: allParams };
-}
-function looksLikeJsonString(s) {
-  const t = s.trim();
-  if (t.length === 0) return false;
-  const c0 = t.charCodeAt(0);
-  const cN = t.charCodeAt(t.length - 1);
-  if (c0 === 123 && cN === 125) return true;
-  if (c0 === 91 && cN === 93) return true;
-  if (t === "null" || t === "true" || t === "false") return true;
-  return false;
-}
-function parseJsonValue(value) {
-  if (typeof value !== "string") return value;
-  if (!looksLikeJsonString(value)) return value;
-  try {
-    return JSON.parse(value);
-  } catch (e) {
-    return value;
-  }
-}
-function parseCountValue(value) {
-  if (value === null || value === void 0) return 0;
-  if (typeof value === "number") return value;
-  if (typeof value === "bigint") {
-    const n = Number(value);
-    return Number.isSafeInteger(n) ? n : 0;
-  }
-  if (typeof value === "string") {
-    const n = Number.parseInt(value, 10);
-    return Number.isFinite(n) ? n : 0;
-  }
-  if (typeof value === "object") {
-    const obj = value;
-    const countKey = Object.prototype.hasOwnProperty.call(obj, "count") ? "count" : Object.prototype.hasOwnProperty.call(obj, "_count") ? "_count" : Object.keys(obj).find((k) => k.endsWith("_count"));
-    if (countKey !== void 0) {
-      const v = obj[countKey];
-      if (typeof v === "number") return v;
-      if (typeof v === "bigint") {
-        const n = Number(v);
-        return Number.isSafeInteger(n) ? n : 0;
-      }
-      if (typeof v === "string") {
-        const n = Number.parseInt(v, 10);
-        return Number.isFinite(n) ? n : 0;
-      }
-    }
-  }
-  return 0;
-}
-function parseBatchCountResults(row, count) {
-  const results = [];
-  for (let i = 0; i < count; i++) {
-    const key = `count_${i}`;
-    const value = row[key];
-    results.push(parseCountValue(value));
-  }
-  return results;
-}
-function parseBatchResults(row, keys, queries, aliases) {
-  const results = {};
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const columnKey = aliases && aliases[i] ? aliases[i] : key;
-    const rawValue = row[columnKey];
-    const query = queries[key];
-    switch (query.method) {
-      case "findMany": {
-        const parsed = parseJsonValue(rawValue);
-        results[key] = Array.isArray(parsed) ? parsed : [];
-        break;
-      }
-      case "findFirst":
-      case "findUnique": {
-        const parsed = parseJsonValue(rawValue);
-        results[key] = parsed != null ? parsed : null;
-        break;
-      }
-      case "count": {
-        results[key] = parseCountValue(rawValue);
-        break;
-      }
-      case "aggregate": {
-        const parsed = parseJsonValue(rawValue);
-        const obj = parsed != null ? parsed : {};
-        results[key] = transformQueryResults("aggregate", [obj]);
-        break;
-      }
-      case "groupBy": {
-        const parsed = parseJsonValue(rawValue);
-        const arr = Array.isArray(parsed) ? parsed : [];
-        results[key] = transformQueryResults("groupBy", arr);
-        break;
-      }
-      default:
-        results[key] = rawValue;
-    }
+    if (merged) return merged;
   }
-  return results;
+  const result = buildRegularBatchQueries(
+    queries,
+    keys,
+    aliases,
+    modelMap,
+    models,
+    dialect
+  );
+  return __spreadProps(__spreadValues({}, result), { keys, aliases });
 }
 
-// src/transaction.ts
-function isolationLevelToPostgresKeyword(level) {
-  switch (level) {
-    case "ReadCommitted":
-      return "read committed";
-    case "RepeatableRead":
-      return "repeatable read";
-    case "Serializable":
-      return "serializable";
-    default:
-      return void 0;
-  }
-}
-function createTransactionExecutor(deps) {
-  const { modelMap, allModels, dialect, executeRaw, postgresClient } = deps;
-  return {
-    execute(queries, options) {
-      return __async(this, null, function* () {
-        if (queries.length === 0) return [];
-        if (dialect !== "postgres") {
-          throw new Error("$transaction is only supported for postgres dialect");
-        }
-        if (!postgresClient) {
-          throw new Error("postgresClient is required for transactions");
-        }
-        const transactionCallback = (sql) => __async(null, null, function* () {
-          const results = [];
-          const isolationLevel = isolationLevelToPostgresKeyword(
-            options == null ? void 0 : options.isolationLevel
-          );
-          if (isolationLevel) {
-            yield sql.unsafe(
-              `SET TRANSACTION ISOLATION LEVEL ${isolationLevel.toUpperCase()}`
-            );
-          }
-          if (options == null ? void 0 : options.timeout) {
-            yield sql.unsafe(
-              `SET LOCAL statement_timeout = ${Math.floor(options.timeout)}`
-            );
-          }
-          for (const q of queries) {
-            const model = modelMap.get(q.model);
-            if (!model) {
-              throw new Error(
-                `Model '${q.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
-              );
-            }
-            const { sql: sqlStr, params } = buildSQLWithCache(
-              model,
-              allModels,
-              q.method,
-              q.args || {},
-              dialect
-            );
-            const rawResults = yield sql.unsafe(sqlStr, params);
-            results.push(transformQueryResults(q.method, rawResults));
-          }
-          return results;
-        });
-        return yield postgresClient.begin(transactionCallback);
-      });
-    }
-  };
-}
-var ACCELERATED_METHODS = /* @__PURE__ */ new Set([
-  "findMany",
-  "findFirst",
-  "findUnique",
-  "count",
-  "aggregate",
-  "groupBy"
-]);
+// src/index.ts
 function buildSQL(model, models, method, args, dialect) {
   return buildSQLWithCache(model, models, method, args, dialect);
 }
-function executePostgres(client, sql, params) {
-  return __async(this, null, function* () {
-    return yield client.unsafe(sql, params);
-  });
-}
-function shouldSqliteUseGet(method) {
-  return method === "count" || method === "findFirst" || method === "findUnique" || method === "aggregate";
-}
-function executeSqlite(db, method, sql, params) {
-  const stmt = db.prepare(sql);
-  if (shouldSqliteUseGet(method)) {
-    const row = stmt.get(...params);
-    if (row === void 0) return [];
-    return [row];
-  }
-  return stmt.all(...params);
-}
-function executeWithTiming(input) {
-  return __async(this, null, function* () {
-    var _a;
-    const startTime = Date.now();
-    const { sql, params } = buildSQL(
-      input.model,
-      input.allModels,
-      input.method,
-      input.args,
-      input.dialect
-    );
-    if (input.debug) {
-      console.log(`[${input.dialect}] ${input.modelName}.${input.method}`);
-      console.log("SQL:", sql);
-      console.log("Params:", params);
-    }
-    const results = yield input.executeQuery(input.method, sql, params);
-    const duration = Date.now() - startTime;
-    (_a = input.onQuery) == null ? void 0 : _a.call(input, {
-      model: input.modelName,
-      method: input.method,
-      sql,
-      params,
-      duration
-    });
-    return results;
-  });
-}
-function resolveModelName(ctx) {
-  return (ctx == null ? void 0 : ctx.name) || (ctx == null ? void 0 : ctx.$name);
-}
-function isAllowedModel(allowedModels, modelName) {
-  if (!allowedModels) return true;
-  return allowedModels.includes(modelName);
-}
-function getModelOrNull(modelMap, modelName) {
-  var _a;
-  return (_a = modelMap.get(modelName)) != null ? _a : null;
-}
-function fallbackToPrisma(ctx, modelName, method, args) {
-  return ctx.$parent[modelName][method](args);
-}
-function createExecuteQuery(client, dialect) {
-  return (method, sql, params) => __async(null, null, function* () {
-    if (dialect === "postgres") {
-      return yield executePostgres(client, sql, params);
-    }
-    return executeSqlite(client, method, sql, params);
-  });
-}
-function logAcceleratedError(debug, dialect, modelName, method, error) {
-  if (!debug) return;
-  console.error(`[${dialect}] ${modelName}.${method} failed:`, error);
-}
-function canAccelerate(deps, modelName, method) {
-  if (!ACCELERATED_METHODS.has(method)) return false;
-  if (!isAllowedModel(deps.allowedModels, modelName)) return false;
-  return deps.modelMap.has(modelName);
-}
-function runAccelerated(deps, modelName, method, model, args) {
-  return __async(this, null, function* () {
-    const results = yield executeWithTiming({
-      modelName,
-      method,
-      model,
-      allModels: deps.allModels,
-      args: args || {},
-      dialect: deps.dialect,
-      debug: deps.debug,
-      executeQuery: deps.executeQuery,
-      onQuery: deps.onQuery
-    });
-    return transformQueryResults(method, results);
-  });
-}
-function handleMethodCall(ctx, method, args, deps) {
-  return __async(this, null, function* () {
-    const modelName = resolveModelName(ctx);
-    if (!canAccelerate(deps, modelName, method)) {
-      return fallbackToPrisma(ctx, modelName, method, args);
-    }
-    const model = getModelOrNull(deps.modelMap, modelName);
-    if (!model) {
-      return fallbackToPrisma(ctx, modelName, method, args);
-    }
-    try {
-      return yield runAccelerated(deps, modelName, method, model, args);
-    } catch (error) {
-      logAcceleratedError(deps.debug, deps.dialect, modelName, method, error);
-      return fallbackToPrisma(ctx, modelName, method, args);
-    }
-  });
-}
-var DeferredQuery = class {
-  constructor(model, method, args) {
-    this.model = model;
-    this.method = method;
-    this.args = args;
-  }
-  then(onfulfilled, onrejected) {
-    throw new Error(
-      "Cannot await a batch query. Batch queries must not be awaited inside the $batch callback."
-    );
-  }
-};
-function createBatchProxy(modelMap, allowedModels) {
-  return new Proxy(
-    {},
-    {
-      get(_target, modelName) {
-        if (typeof modelName === "symbol") return void 0;
-        const model = modelMap.get(modelName);
-        if (!model) {
-          throw new Error(
-            `Model '${modelName}' not found. Available: ${[...modelMap.keys()].join(", ")}`
-          );
-        }
-        if (allowedModels && !allowedModels.includes(modelName)) {
-          throw new Error(
-            `Model '${modelName}' not allowed. Allowed: ${allowedModels.join(", ")}`
-          );
-        }
-        return new Proxy(
-          {},
-          {
-            get(_target2, method) {
-              if (!ACCELERATED_METHODS.has(method)) {
-                throw new Error(
-                  `Method '${method}' not supported in batch. Supported: ${[...ACCELERATED_METHODS].join(", ")}`
-                );
-              }
-              return (args) => {
-                return new DeferredQuery(
-                  modelName,
-                  method,
-                  args
-                );
-              };
-            }
-          }
-        );
-      }
-    }
-  );
-}
-function speedExtension(config) {
-  const {
-    postgres,
-    sqlite,
-    models: providedModels,
-    dmmf,
-    debug = false,
-    allowedModels,
-    onQuery
-  } = config;
-  if (!postgres && !sqlite) {
-    throw new Error("speedExtension requires either postgres or sqlite client");
-  }
-  if (postgres && sqlite) {
-    throw new Error(
-      "speedExtension cannot use both postgres and sqlite clients"
-    );
-  }
-  let models;
-  if (providedModels) {
-    models = providedModels;
-  } else if (dmmf) {
-    models = convertDMMFToModels(dmmf.datamodel);
-  } else {
-    throw new Error("speedExtension requires either models or dmmf parameter.");
-  }
-  if (!Array.isArray(models) || models.length === 0) {
-    throw new Error("speedExtension: models array is empty or invalid");
-  }
-  const dialect = postgres ? "postgres" : "sqlite";
-  const client = postgres || sqlite;
-  setGlobalDialect(dialect);
-  return (prisma) => {
-    const modelMap = new Map(models.map((m) => [m.name, m]));
-    const executeQuery = createExecuteQuery(client, dialect);
-    const deps = {
-      dialect,
-      debug,
-      onQuery,
-      allowedModels,
-      allModels: models,
-      modelMap,
-      executeQuery
-    };
-    const createMethodHandler = (method) => {
-      return function(args) {
-        return __async(this, null, function* () {
-          return handleMethodCall(this, method, args, deps);
-        });
-      };
-    };
-    const methodHandlers = {};
-    for (const method of ACCELERATED_METHODS) {
-      methodHandlers[method] = createMethodHandler(method);
-    }
-    const executeRaw = (sql, params) => __async(null, null, function* () {
-      if (dialect === "postgres") {
-        return yield client.unsafe(sql, params);
-      }
-      throw new Error("Raw execution for sqlite not supported in transactions");
-    });
-    const txExecutor = createTransactionExecutor({
-      modelMap,
-      allModels: models,
-      dialect,
-      executeRaw,
-      postgresClient: postgres
-    });
-    function batch(callback) {
-      return __async(this, null, function* () {
-        const batchProxy = createBatchProxy(modelMap, allowedModels);
-        const queries = yield callback(batchProxy);
-        const batchQueries = {};
-        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 || {}
-          };
-        }
-        const startTime = Date.now();
-        const { sql, params, keys, aliases } = buildBatchSql(
-          batchQueries,
-          modelMap,
-          models,
-          dialect
-        );
-        if (debug) {
-          console.log(`[${dialect}] $batch (${keys.length} queries)`);
-          console.log("SQL:", sql);
-          console.log("Params:", params);
-        }
-        const rows = yield executeQuery("findMany", sql, params);
-        const row = rows[0];
-        const results = parseBatchResults(row, keys, batchQueries, aliases);
-        const duration = Date.now() - startTime;
-        onQuery == null ? void 0 : onQuery({
-          model: "_batch",
-          method: "batch",
-          sql,
-          params,
-          duration
-        });
-        return results;
-      });
-    }
-    function transaction(queries, options) {
-      return __async(this, null, function* () {
-        const startTime = Date.now();
-        if (debug) {
-          console.log(`[${dialect}] $transaction (${queries.length} queries)`);
-        }
-        const results = yield txExecutor.execute(queries, options);
-        const duration = Date.now() - startTime;
-        onQuery == null ? void 0 : onQuery({
-          model: "_transaction",
-          method: "transaction",
-          sql: `TRANSACTION(${queries.length})`,
-          params: [],
-          duration
-        });
-        return results;
-      });
-    }
-    return prisma.$extends({
-      name: "prisma-sql-speed",
-      client: {
-        $original: prisma,
-        $batch: batch,
-        $transaction: transaction
-      },
-      model: {
-        $allModels: methodHandlers
-      }
-    });
-  };
-}
-function extendPrisma(prisma, config) {
-  const extension = speedExtension(config);
-  return extension(prisma);
-}
 function createToSQLFunction(models, dialect) {
   if (!models || !Array.isArray(models) || models.length === 0) {
     throw new Error("createToSQL requires non-empty models array");
@@ -6158,6 +6184,6 @@ function generateSQLByModel(directives) {
   return byModel;
 }
 
-export { buildBatchCountSql, buildBatchSql, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, extendPrisma, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel, getGlobalDialect, parseBatchCountResults, parseBatchResults, setGlobalDialect, speedExtension, transformQueryResults };
+export { buildSQL, createPrismaSQL, createToSQL, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map