prisma-sql 1.66.1 → 1.67.0

package/dist/index.cjs

@@ -5,7 +5,6 @@ var schemaParser = require('@dee-wan/schema-parser');
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -25,13 +24,6 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 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);
@@ -66,6 +58,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/utils/normalize-value.ts
+var MAX_DEPTH = 20;
 function normalizeValue(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
   if (depth > MAX_DEPTH) {
     throw new Error(`Max normalization depth exceeded (${MAX_DEPTH} levels)`);
@@ -119,14 +112,9 @@ function normalizeObjectValue(value, seen, depth) {
   seen.delete(obj);
   return out;
 }
-var MAX_DEPTH;
-var init_normalize_value = __esm({
-  "src/utils/normalize-value.ts"() {
-    MAX_DEPTH = 20;
-  }
-});
 
 // src/sql-builder-dialect.ts
+var globalDialect = "postgres";
 function setGlobalDialect(dialect) {
   if (dialect !== "postgres" && dialect !== "sqlite") {
     throw new Error(
@@ -305,175 +293,162 @@ function prepareArrayParam(value, dialect) {
   }
   return JSON.stringify(value.map((v) => normalizeValue(v)));
 }
-var globalDialect;
-var init_sql_builder_dialect = __esm({
-  "src/sql-builder-dialect.ts"() {
-    init_normalize_value();
-    globalDialect = "postgres";
-  }
-});
 
 // src/builder/shared/constants.ts
-var IS_PRODUCTION, SQL_SEPARATORS, ALIAS_FORBIDDEN_KEYWORDS, SQL_KEYWORDS, SQL_RESERVED_WORDS, DEFAULT_WHERE_CLAUSE, SPECIAL_FIELDS, SQL_TEMPLATES, SCHEMA_PREFIXES, Ops, LogicalOps, RelationFilters, Modes, Wildcards, REGEX_CACHE, LIMITS, AGGREGATE_PREFIXES;
-var init_constants = __esm({
-  "src/builder/shared/constants.ts"() {
-    IS_PRODUCTION = process.env.NODE_ENV === "production";
-    SQL_SEPARATORS = Object.freeze({
-      FIELD_LIST: ", ",
-      CONDITION_AND: " AND ",
-      CONDITION_OR: " OR ",
-      ORDER_BY: ", "
-    });
-    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"
-    ]);
-    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"
-    ]);
-    SQL_RESERVED_WORDS = SQL_KEYWORDS;
-    DEFAULT_WHERE_CLAUSE = "1=1";
-    SPECIAL_FIELDS = Object.freeze({
-      ID: "id"
-    });
-    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"
-    });
-    SCHEMA_PREFIXES = Object.freeze({
-      INTERNAL: "@",
-      COMMENT: "//"
-    });
-    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"
-    });
-    LogicalOps = Object.freeze({
-      AND: "AND",
-      OR: "OR",
-      NOT: "NOT"
-    });
-    RelationFilters = Object.freeze({
-      SOME: "some",
-      EVERY: "every",
-      NONE: "none"
-    });
-    Modes = Object.freeze({
-      INSENSITIVE: "insensitive",
-      DEFAULT: "default"
-    });
-    Wildcards = Object.freeze({
-      [Ops.CONTAINS]: (v) => `%${v}%`,
-      [Ops.STARTS_WITH]: (v) => `${v}%`,
-      [Ops.ENDS_WITH]: (v) => `%${v}`
-    });
-    REGEX_CACHE = {
-      PARAM_PLACEHOLDER: /\$(\d+)/g,
-      VALID_IDENTIFIER: /^[a-z_][a-z0-9_]*$/
-    };
-    LIMITS = Object.freeze({
-      MAX_QUERY_DEPTH: 50,
-      MAX_ARRAY_SIZE: 1e4,
-      MAX_STRING_LENGTH: 1e4,
-      MAX_HAVING_DEPTH: 50
-    });
-    AGGREGATE_PREFIXES = /* @__PURE__ */ new Set([
-      "_count",
-      "_sum",
-      "_avg",
-      "_min",
-      "_max"
-    ]);
-  }
+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
+});
+var AGGREGATE_PREFIXES = /* @__PURE__ */ new Set([
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+]);
 
 // src/builder/shared/validators/type-guards.ts
 function isNotNullish(value) {
@@ -517,12 +492,16 @@ function hasRequiredKeywords(sql) {
   const hasFrom = upper.includes("FROM");
   return hasSelect && hasFrom && upper.indexOf("SELECT") < upper.indexOf("FROM");
 }
-var init_type_guards = __esm({
-  "src/builder/shared/validators/type-guards.ts"() {
-  }
-});
 
 // 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)) {
@@ -536,20 +515,6 @@ function createError(message, ctx, code = "VALIDATION_ERROR") {
   }
   return new SqlBuilderError(parts.join("\n"), code, ctx);
 }
-var SqlBuilderError;
-var init_errors = __esm({
-  "src/builder/shared/errors.ts"() {
-    init_type_guards();
-    SqlBuilderError = class extends Error {
-      constructor(message, code, context) {
-        super(message);
-        this.name = "SqlBuilderError";
-        this.code = code;
-        this.context = context;
-      }
-    };
-  }
-});
 
 // src/builder/shared/validators/sql-validators.ts
 function isValidWhereClause(clause) {
@@ -584,6 +549,7 @@ function parseDollarNumber(sql, start) {
   if (!hasDigit || num <= 0) return { next: i, num: 0 };
   return { next: i, num };
 }
+var MAX_PARAMS = 32767;
 function scanDollarPlaceholders(sql, markUpTo) {
   if (markUpTo > MAX_PARAMS) {
     throw new Error(`Parameter count ${markUpTo} exceeds maximum ${MAX_PARAMS}`);
@@ -690,16 +656,10 @@ function needsQuoting(identifier) {
   if (SQL_KEYWORDS.has(identifier.toLowerCase())) return true;
   return false;
 }
-var MAX_PARAMS;
-var init_sql_validators = __esm({
-  "src/builder/shared/validators/sql-validators.ts"() {
-    init_constants();
-    init_type_guards();
-    MAX_PARAMS = 32767;
-  }
-});
 
 // src/builder/shared/sql-utils.ts
+var COL_EXPR_CACHE = /* @__PURE__ */ new WeakMap();
+var COL_WITH_ALIAS_CACHE = /* @__PURE__ */ new WeakMap();
 function containsControlChars(s) {
   for (let i = 0; i < s.length; i++) {
     const code = s.charCodeAt(i);
@@ -725,6 +685,7 @@ function isIdentCharCode(c) {
 function isIdentStartCharCode(c) {
   return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
 }
+var MAX_PARSE_ITERATIONS = 1e4;
 function parseQuotedPart(input, start) {
   const n = input.length;
   let i = start + 1;
@@ -1024,20 +985,9 @@ function normalizeKeyList(input) {
   const s = String(input).trim();
   return s.length > 0 ? [s] : [];
 }
-var COL_EXPR_CACHE, COL_WITH_ALIAS_CACHE, MAX_PARSE_ITERATIONS;
-var init_sql_utils = __esm({
-  "src/builder/shared/sql-utils.ts"() {
-    init_sql_validators();
-    init_type_guards();
-    init_model_field_cache();
-    init_constants();
-    COL_EXPR_CACHE = /* @__PURE__ */ new WeakMap();
-    COL_WITH_ALIAS_CACHE = /* @__PURE__ */ new WeakMap();
-    MAX_PARSE_ITERATIONS = 1e4;
-  }
-});
 
 // src/builder/shared/model-field-cache.ts
+var FIELD_INDICES_CACHE = /* @__PURE__ */ new WeakMap();
 function normalizeField(field) {
   return field;
 }
@@ -1126,13 +1076,6 @@ function maybeParseJson(value, jsonSet, fieldName) {
     return value;
   }
 }
-var FIELD_INDICES_CACHE;
-var init_model_field_cache = __esm({
-  "src/builder/shared/model-field-cache.ts"() {
-    init_sql_utils();
-    FIELD_INDICES_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // src/builder/joins.ts
 function isRelationField(fieldName, model) {
@@ -1191,15 +1134,6 @@ function joinCondition(field, parentModel, childModel, parentAlias, childAlias)
 function getModelByName(schemas, name) {
   return schemas.find((m) => m.name === name);
 }
-var init_joins = __esm({
-  "src/builder/joins.ts"() {
-    init_constants();
-    init_errors();
-    init_model_field_cache();
-    init_sql_utils();
-    init_type_guards();
-  }
-});
 function normalizeIntLike(name, v, opts = {}) {
   var _a, _b;
   if (!isNotNullish(v)) return void 0;
@@ -1220,11 +1154,6 @@ function normalizeIntLike(name, v, opts = {}) {
   }
   return v;
 }
-var init_int_like = __esm({
-  "src/builder/shared/int-like.ts"() {
-    init_type_guards();
-  }
-});
 function scopeName(scope, dynamicName) {
   const s = String(scope).trim();
   const dn = String(dynamicName).trim();
@@ -1234,16 +1163,77 @@ function scopeName(scope, dynamicName) {
 function addAutoScoped(params, value, scope) {
   if (schemaParser.isDynamicParameter(value)) {
     const dn = schemaParser.extractDynamicName(value);
+    console.log(`[PARAM] ${scope} = ${JSON.stringify(value)}`);
     return params.add(void 0, scopeName(scope, dn));
   }
   return params.add(value);
 }
-var init_dynamic_params = __esm({
-  "src/builder/shared/dynamic-params.ts"() {
-  }
-});
 
 // src/builder/shared/order-by-utils.ts
+var flipNulls = (v) => {
+  const s = String(v).toLowerCase();
+  if (s === "first") return "last";
+  if (s === "last") return "first";
+  return v;
+};
+var flipSortString = (v) => {
+  if (typeof v !== "string") return v;
+  const s = v.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return v;
+};
+var getNextSort = (sortRaw) => {
+  if (typeof sortRaw !== "string") return sortRaw;
+  const s = sortRaw.toLowerCase();
+  if (s === "asc") return "desc";
+  if (s === "desc") return "asc";
+  return sortRaw;
+};
+var flipObjectSort = (obj) => {
+  const out = __spreadValues({}, obj);
+  const hasSort = Object.prototype.hasOwnProperty.call(obj, "sort");
+  const hasDirection = Object.prototype.hasOwnProperty.call(obj, "direction");
+  if (hasSort) {
+    out.sort = getNextSort(obj.sort);
+  } else if (hasDirection) {
+    out.direction = getNextSort(obj.direction);
+  } else {
+    out.sort = getNextSort(obj.sort);
+  }
+  if (typeof obj.nulls === "string") {
+    out.nulls = flipNulls(obj.nulls);
+  }
+  return out;
+};
+var flipValue = (v) => {
+  if (typeof v === "string") return flipSortString(v);
+  if (isPlainObject(v)) return flipObjectSort(v);
+  return v;
+};
+var assertSingleFieldObject = (item) => {
+  if (!isPlainObject(item)) {
+    throw new Error("orderBy array entries must be objects");
+  }
+  const entries = Object.entries(item);
+  if (entries.length !== 1) {
+    throw new Error("orderBy array entries must have exactly one field");
+  }
+  return entries[0];
+};
+var flipOrderByArray = (orderBy) => {
+  return orderBy.map((item) => {
+    const [k, v] = assertSingleFieldObject(item);
+    return { [k]: flipValue(v) };
+  });
+};
+var flipOrderByObject = (orderBy) => {
+  const out = {};
+  for (const [k, v] of Object.entries(orderBy)) {
+    out[k] = flipValue(v);
+  }
+  return out;
+};
 function reverseOrderByInput(orderBy) {
   if (!isNotNullish(orderBy)) return orderBy;
   if (Array.isArray(orderBy)) {
@@ -1254,6 +1244,14 @@ function reverseOrderByInput(orderBy) {
   }
   throw new Error("orderBy must be an object or array of objects");
 }
+var normalizePairs = (pairs, parseValue) => {
+  return pairs.map(([field, rawValue]) => {
+    const parsed = parseValue(rawValue, field);
+    return {
+      [field]: parsed.nulls !== void 0 ? { direction: parsed.direction, nulls: parsed.nulls } : parsed.direction
+    };
+  });
+};
 function normalizeOrderByInput(orderBy, parseValue) {
   if (!isNotNullish(orderBy)) return [];
   if (Array.isArray(orderBy)) {
@@ -1289,85 +1287,6 @@ function normalizeAndValidateOrderBy(orderBy, model, parseValue) {
   }
   return entries;
 }
-var flipNulls, flipSortString, getNextSort, flipObjectSort, flipValue, assertSingleFieldObject, flipOrderByArray, flipOrderByObject, normalizePairs;
-var init_order_by_utils = __esm({
-  "src/builder/shared/order-by-utils.ts"() {
-    init_type_guards();
-    init_model_field_cache();
-    flipNulls = (v) => {
-      const s = String(v).toLowerCase();
-      if (s === "first") return "last";
-      if (s === "last") return "first";
-      return v;
-    };
-    flipSortString = (v) => {
-      if (typeof v !== "string") return v;
-      const s = v.toLowerCase();
-      if (s === "asc") return "desc";
-      if (s === "desc") return "asc";
-      return v;
-    };
-    getNextSort = (sortRaw) => {
-      if (typeof sortRaw !== "string") return sortRaw;
-      const s = sortRaw.toLowerCase();
-      if (s === "asc") return "desc";
-      if (s === "desc") return "asc";
-      return sortRaw;
-    };
-    flipObjectSort = (obj) => {
-      const out = __spreadValues({}, obj);
-      const hasSort = Object.prototype.hasOwnProperty.call(obj, "sort");
-      const hasDirection = Object.prototype.hasOwnProperty.call(obj, "direction");
-      if (hasSort) {
-        out.sort = getNextSort(obj.sort);
-      } else if (hasDirection) {
-        out.direction = getNextSort(obj.direction);
-      } else {
-        out.sort = getNextSort(obj.sort);
-      }
-      if (typeof obj.nulls === "string") {
-        out.nulls = flipNulls(obj.nulls);
-      }
-      return out;
-    };
-    flipValue = (v) => {
-      if (typeof v === "string") return flipSortString(v);
-      if (isPlainObject(v)) return flipObjectSort(v);
-      return v;
-    };
-    assertSingleFieldObject = (item) => {
-      if (!isPlainObject(item)) {
-        throw new Error("orderBy array entries must be objects");
-      }
-      const entries = Object.entries(item);
-      if (entries.length !== 1) {
-        throw new Error("orderBy array entries must have exactly one field");
-      }
-      return entries[0];
-    };
-    flipOrderByArray = (orderBy) => {
-      return orderBy.map((item) => {
-        const [k, v] = assertSingleFieldObject(item);
-        return { [k]: flipValue(v) };
-      });
-    };
-    flipOrderByObject = (orderBy) => {
-      const out = {};
-      for (const [k, v] of Object.entries(orderBy)) {
-        out[k] = flipValue(v);
-      }
-      return out;
-    };
-    normalizePairs = (pairs, parseValue) => {
-      return pairs.map(([field, rawValue]) => {
-        const parsed = parseValue(rawValue, field);
-        return {
-          [field]: parsed.nulls !== void 0 ? { direction: parsed.direction, nulls: parsed.nulls } : parsed.direction
-        };
-      });
-    };
-  }
-});
 
 // src/builder/shared/order-by-determinism.ts
 function findTiebreakerField(model) {
@@ -1400,15 +1319,9 @@ function ensureDeterministicOrderByInput(args) {
   if (hasTiebreaker(orderBy, parseValue, tiebreaker)) return orderBy;
   return addTiebreaker(orderBy, tiebreaker);
 }
-var init_order_by_determinism = __esm({
-  "src/builder/shared/order-by-determinism.ts"() {
-    init_model_field_cache();
-    init_type_guards();
-    init_order_by_utils();
-  }
-});
 
 // src/builder/shared/primary-key-utils.ts
+var FIELD_BY_NAME_CACHE = /* @__PURE__ */ new WeakMap();
 function normalizeField2(field) {
   return field;
 }
@@ -1444,13 +1357,6 @@ function getFieldByName(model, fieldName) {
   }
   return cache.get(fieldName);
 }
-var FIELD_BY_NAME_CACHE;
-var init_primary_key_utils = __esm({
-  "src/builder/shared/primary-key-utils.ts"() {
-    init_model_field_cache();
-    FIELD_BY_NAME_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // src/builder/shared/validators/field-assertions.ts
 function assertFieldExists(fieldName, model, context, path = []) {
@@ -1498,12 +1404,10 @@ function assertNumericField(model, fieldName, context) {
   }
   return field;
 }
-var init_field_assertions = __esm({
-  "src/builder/shared/validators/field-assertions.ts"() {
-    init_errors();
-    init_primary_key_utils();
-  }
-});
+
+// src/builder/pagination.ts
+var MAX_LIMIT_OFFSET = 2147483647;
+var ORDER_BY_ALLOWED_KEYS = /* @__PURE__ */ new Set(["sort", "nulls"]);
 function parseDirectionRaw(raw, errorLabel) {
   const s = String(raw).toLowerCase();
   if (s === "asc" || s === "desc") return s;
@@ -1552,6 +1456,7 @@ function normalizeNonNegativeInt(name, v) {
     throw new Error(`${name} normalization returned undefined`);
   return result;
 }
+var MIN_NEGATIVE_TAKE = -1e4;
 function normalizeIntAllowNegative(name, v) {
   if (schemaParser.isDynamicParameter(v)) return v;
   const result = normalizeIntLike(name, v, {
@@ -1837,23 +1742,6 @@ function getPaginationParams(method, args) {
   }
   return {};
 }
-var MAX_LIMIT_OFFSET, ORDER_BY_ALLOWED_KEYS, MIN_NEGATIVE_TAKE;
-var init_pagination = __esm({
-  "src/builder/pagination.ts"() {
-    init_constants();
-    init_sql_utils();
-    init_sql_builder_dialect();
-    init_type_guards();
-    init_int_like();
-    init_dynamic_params();
-    init_order_by_utils();
-    init_order_by_determinism();
-    init_field_assertions();
-    MAX_LIMIT_OFFSET = 2147483647;
-    ORDER_BY_ALLOWED_KEYS = /* @__PURE__ */ new Set(["sort", "nulls"]);
-    MIN_NEGATIVE_TAKE = -1e4;
-  }
-});
 
 // src/builder/shared/null-comparison.ts
 function buildNullComparison(expr, op, allowNull = false) {
@@ -1871,12 +1759,6 @@ function tryBuildNullComparison(expr, op, val, context) {
   }
   return clause;
 }
-var init_null_comparison = __esm({
-  "src/builder/shared/null-comparison.ts"() {
-    init_constants();
-    init_errors();
-  }
-});
 function buildInCondition(expr, op, val, params, dialect, context) {
   if (schemaParser.isDynamicParameter(val)) {
     const ph2 = params.addAuto(val);
@@ -1900,12 +1782,9 @@ function buildInCondition(expr, op, val, params, dialect, context) {
   const ph = params.add(paramValue);
   return op === "in" ? inArray(expr, ph, dialect) : notInArray(expr, ph, dialect);
 }
-var init_in_operator_builder = __esm({
-  "src/builder/shared/in-operator-builder.ts"() {
-    init_sql_builder_dialect();
-    init_errors();
-  }
-});
+
+// src/builder/where/operators-scalar.ts
+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
@@ -2081,18 +1960,6 @@ function handleComparisonOperator(expr, op, val, params) {
   const placeholder = params.addAuto(val);
   return `${expr} ${sqlOp} ${placeholder}`;
 }
-var MAX_NOT_DEPTH;
-var init_operators_scalar = __esm({
-  "src/builder/where/operators-scalar.ts"() {
-    init_sql_builder_dialect();
-    init_constants();
-    init_errors();
-    init_type_guards();
-    init_null_comparison();
-    init_in_operator_builder();
-    MAX_NOT_DEPTH = 50;
-  }
-});
 function buildArrayParam(val, params, dialect) {
   if (schemaParser.isDynamicParameter(val)) {
     return params.addAuto(val);
@@ -2224,17 +2091,11 @@ function handleArrayIsEmpty(expr, val, dialect) {
   }
   return val === true ? arrayIsEmpty(expr, dialect) : arrayIsNotEmpty(expr, dialect);
 }
-var init_operators_array = __esm({
-  "src/builder/where/operators-array.ts"() {
-    init_sql_builder_dialect();
-    init_constants();
-    init_errors();
-    init_type_guards();
-    init_null_comparison();
-  }
-});
 
 // 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++) {
@@ -2351,20 +2212,9 @@ function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
   const jsonText = jsonToText(expr, dialect);
   return caseInsensitiveLike(jsonText, placeholder, dialect);
 }
-var SAFE_JSON_PATH_SEGMENT, MAX_PATH_SEGMENT_LENGTH, MAX_PATH_SEGMENTS;
-var init_operators_json = __esm({
-  "src/builder/where/operators-json.ts"() {
-    init_sql_builder_dialect();
-    init_constants();
-    init_errors();
-    init_type_guards();
-    SAFE_JSON_PATH_SEGMENT = /^[a-zA-Z_]\w*$/;
-    MAX_PATH_SEGMENT_LENGTH = 255;
-    MAX_PATH_SEGMENTS = 100;
-  }
-});
 
 // src/builder/where/relations.ts
+var NO_JOINS = [];
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
@@ -2395,21 +2245,6 @@ 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 {
-    clause: whereClause,
-    joins: [leftJoinSql]
-  };
-}
 function processRelationFilter(key, wrap, args) {
   const { value, fieldName, ctx, relAlias, relModel, whereBuilder } = args;
   const raw = value[key];
@@ -2429,7 +2264,6 @@ function buildListRelationFilters(args) {
     fieldName,
     value,
     ctx,
-    whereBuilder,
     relModel,
     relTable,
     relAlias,
@@ -2437,23 +2271,17 @@ function buildListRelationFilters(args) {
   } = args;
   const noneValue = value[RelationFilters.NONE];
   if (noneValue !== void 0 && noneValue !== null) {
-    const sub = whereBuilder.build(noneValue, __spreadProps(__spreadValues({}, ctx), {
-      alias: relAlias,
-      model: relModel,
-      path: [...ctx.path, fieldName, RelationFilters.NONE],
-      isSubquery: true,
-      depth: ctx.depth + 1
-    }));
-    const optimized = tryOptimizeNoneFilter(
-      noneValue,
-      ctx,
-      relModel,
-      relTable,
-      relAlias,
-      join,
-      sub
-    );
-    if (optimized) return optimized;
+    const isEmptyFilter = isPlainObject(noneValue) && Object.keys(noneValue).length === 0;
+    if (isEmptyFilter && !ctx.isSubquery) {
+      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}.${quoteColumn(relModel, checkField.name)} IS NULL`;
+        return { clause: whereClause, joins: [leftJoinSql] };
+      }
+    }
   }
   const filters = [
     {
@@ -2625,18 +2453,6 @@ function buildTopLevelRelation(fieldName, value, ctx, whereBuilder) {
 function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
   return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
 }
-var NO_JOINS;
-var init_relations = __esm({
-  "src/builder/where/relations.ts"() {
-    init_joins();
-    init_constants();
-    init_errors();
-    init_sql_utils();
-    init_type_guards();
-    init_primary_key_utils();
-    NO_JOINS = [];
-  }
-});
 
 // src/builder/shared/array-utils.ts
 function deduplicatePreserveOrder(items) {
@@ -2651,12 +2467,28 @@ function deduplicatePreserveOrder(items) {
   }
   return out;
 }
-var init_array_utils = __esm({
-  "src/builder/shared/array-utils.ts"() {
-  }
-});
 
 // src/builder/where/builder.ts
+var MAX_QUERY_DEPTH = 50;
+var EMPTY_JOINS = [];
+var JSON_OPS = /* @__PURE__ */ new Set([
+  Ops.PATH,
+  Ops.STRING_CONTAINS,
+  Ops.STRING_STARTS_WITH,
+  Ops.STRING_ENDS_WITH
+]);
+var WhereBuilder = class {
+  build(where, ctx) {
+    if (!isPlainObject(where)) {
+      throw createError("where must be an object", {
+        path: ctx.path,
+        modelName: ctx.model.name
+      });
+    }
+    return buildWhereInternal(where, ctx, this);
+  }
+};
+var whereBuilderInstance = new WhereBuilder();
 function createResult(clause, joins = EMPTY_JOINS) {
   return { clause, joins };
 }
@@ -2720,16 +2552,9 @@ function buildWhereInternal(where, ctx, builder) {
       { path: ctx.path, modelName: ctx.model.name }
     );
   }
-  if (ctx.seenObjects.has(where)) {
-    throw createError("Circular reference detected in WHERE clause", {
-      path: ctx.path,
-      modelName: ctx.model.name
-    });
-  }
   if (!isPlainObject(where) || Object.keys(where).length === 0) {
     return createResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
   }
-  ctx.seenObjects.add(where);
   if (isSimpleWhere(where)) {
     const key = Object.keys(where)[0];
     const value = where[key];
@@ -2863,45 +2688,9 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
     dialect: ctx.dialect
   });
 }
-var MAX_QUERY_DEPTH, EMPTY_JOINS, JSON_OPS, WhereBuilder, whereBuilderInstance;
-var init_builder = __esm({
-  "src/builder/where/builder.ts"() {
-    init_joins();
-    init_operators_scalar();
-    init_operators_array();
-    init_operators_json();
-    init_relations();
-    init_constants();
-    init_errors();
-    init_sql_utils();
-    init_field_assertions();
-    init_sql_validators();
-    init_type_guards();
-    init_array_utils();
-    MAX_QUERY_DEPTH = 50;
-    EMPTY_JOINS = [];
-    JSON_OPS = /* @__PURE__ */ new Set([
-      Ops.PATH,
-      Ops.STRING_CONTAINS,
-      Ops.STRING_STARTS_WITH,
-      Ops.STRING_ENDS_WITH
-    ]);
-    WhereBuilder = class {
-      build(where, ctx) {
-        if (!isPlainObject(where)) {
-          throw createError("where must be an object", {
-            path: ctx.path,
-            modelName: ctx.model.name
-          });
-        }
-        return buildWhereInternal(where, ctx, this);
-      }
-    };
-    whereBuilderInstance = new WhereBuilder();
-  }
-});
 
 // src/builder/shared/alias-generator.ts
+var SAFE_IDENTIFIER_CACHE = /* @__PURE__ */ new Map();
 function toSafeSqlIdentifier(input) {
   const cached = SAFE_IDENTIFIER_CACHE.get(input);
   if (cached !== void 0) return cached;
@@ -2955,13 +2744,7 @@ function createAliasGenerator(maxAliases = 1e4) {
     }
   };
 }
-var SAFE_IDENTIFIER_CACHE;
-var init_alias_generator = __esm({
-  "src/builder/shared/alias-generator.ts"() {
-    init_constants();
-    SAFE_IDENTIFIER_CACHE = /* @__PURE__ */ new Map();
-  }
-});
+var MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
 function assertSameLength(params, mappings) {
   if (params.length !== mappings.length) {
     throw new Error(
@@ -3043,6 +2826,10 @@ function assertCanAddParam(currentIndex) {
     );
   }
 }
+var POSTGRES_POSITION_CACHE = new Array(500);
+for (let i = 0; i < 500; i++) {
+  POSTGRES_POSITION_CACHE[i] = `$${i + 1}`;
+}
 function formatPositionPostgres(position) {
   if (position <= 500) return POSTGRES_POSITION_CACHE[position - 1];
   return `$${position}`;
@@ -3156,17 +2943,6 @@ function createParamStoreFrom(existingParams, existingMappings, nextIndex, diale
     cachedIndex
   );
 }
-var MAX_PARAM_INDEX, POSTGRES_POSITION_CACHE;
-var init_param_store = __esm({
-  "src/builder/shared/param-store.ts"() {
-    init_normalize_value();
-    MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
-    POSTGRES_POSITION_CACHE = new Array(500);
-    for (let i = 0; i < 500; i++) {
-      POSTGRES_POSITION_CACHE[i] = `$${i + 1}`;
-    }
-  }
-});
 
 // src/builder/shared/state.ts
 function toPublicResult(clause, joins, params) {
@@ -3179,18 +2955,13 @@ function toPublicResult(clause, joins, params) {
     nextParamIndex: snapshot.index
   });
 }
-var init_state = __esm({
-  "src/builder/shared/state.ts"() {
-    init_constants();
-  }
-});
 
 // src/builder/where.ts
 function buildWhereClause(where, options) {
   var _a, _b, _c, _d, _e;
   assertSafeAlias(options.alias);
   const dialect = options.dialect || getGlobalDialect();
-  const params = (_a = options.params) != null ? _a : createParamStore();
+  const params = (_a = options.params) != null ? _a : createParamStore(1, dialect);
   const ctx = {
     alias: options.alias,
     model: options.model,
@@ -3207,21 +2978,13 @@ function buildWhereClause(where, options) {
   const publicResult = toPublicResult(result.clause, result.joins, params);
   return publicResult;
 }
-var init_where = __esm({
-  "src/builder/where.ts"() {
-    init_sql_builder_dialect();
-    init_builder();
-    init_alias_generator();
-    init_param_store();
-    init_state();
-    init_sql_utils();
-  }
-});
 
 // src/builder/select/fields.ts
+var DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
 function toSelectEntries(select) {
   const out = [];
   for (const [k, v] of Object.entries(select)) {
+    if (k === "_count") continue;
     if (v !== false && v !== void 0) out.push([k, v]);
   }
   return out;
@@ -3343,7 +3106,7 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
     const scalarNames = getScalarFieldSet(relModel);
     const relationNames = getRelationFieldSet(relModel);
     const entries = toSelectEntries(sel);
-    validateFieldKeys(entries, scalarNames, relationNames, false);
+    validateFieldKeys(entries, scalarNames, relationNames, true);
     return buildSelectedScalarParts(
       entries,
       scalarNames,
@@ -3353,16 +3116,6 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
   }
   return buildAllScalarParts(relModel, relAlias).join(SQL_SEPARATORS.FIELD_LIST);
 }
-var DEFAULT_SELECT_CACHE;
-var init_fields = __esm({
-  "src/builder/select/fields.ts"() {
-    init_constants();
-    init_model_field_cache();
-    init_sql_utils();
-    init_type_guards();
-    DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // src/builder/shared/relation-key-utils.ts
 function resolveRelationKeys(field, context = "include") {
@@ -3383,11 +3136,6 @@ function resolveRelationKeys(field, context = "include") {
   const parentKeys = field.isForeignKeyLocal ? fkFields : refFields;
   return { childKeys, parentKeys };
 }
-var init_relation_key_utils = __esm({
-  "src/builder/shared/relation-key-utils.ts"() {
-    init_sql_utils();
-  }
-});
 
 // src/builder/shared/relation-extraction-utils.ts
 function extractRelationEntries(args, model) {
@@ -3412,12 +3160,11 @@ function extractRelationEntries(args, model) {
   }
   return entries;
 }
-var init_relation_extraction_utils = __esm({
-  "src/builder/shared/relation-extraction-utils.ts"() {
-    init_model_field_cache();
-    init_type_guards();
-  }
-});
+
+// src/builder/select/includes.ts
+var MAX_INCLUDE_DEPTH = 5;
+var MAX_INCLUDES_PER_LEVEL = 10;
+var MAX_TOTAL_SUBQUERIES = 100;
 function buildIncludeScope(includePath) {
   if (includePath.length === 0) return "include";
   let scope = "include";
@@ -4102,30 +3849,6 @@ function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params
   }
   return { joins, jsonPairs: pairs.join(SQL_SEPARATORS.FIELD_LIST) };
 }
-var MAX_INCLUDE_DEPTH, MAX_INCLUDES_PER_LEVEL, MAX_TOTAL_SUBQUERIES;
-var init_includes = __esm({
-  "src/builder/select/includes.ts"() {
-    init_joins();
-    init_pagination();
-    init_where();
-    init_sql_builder_dialect();
-    init_fields();
-    init_alias_generator();
-    init_constants();
-    init_sql_utils();
-    init_sql_validators();
-    init_type_guards();
-    init_order_by_utils();
-    init_dynamic_params();
-    init_model_field_cache();
-    init_order_by_determinism();
-    init_relation_key_utils();
-    init_relation_extraction_utils();
-    MAX_INCLUDE_DEPTH = 5;
-    MAX_INCLUDES_PER_LEVEL = 10;
-    MAX_TOTAL_SUBQUERIES = 100;
-  }
-});
 
 // src/builder/shared/string-builder.ts
 function joinNonEmpty(parts, sep) {
@@ -4138,10 +3861,6 @@ function joinNonEmpty(parts, sep) {
   }
   return result;
 }
-var init_string_builder = __esm({
-  "src/builder/shared/string-builder.ts"() {
-  }
-});
 
 // src/builder/shared/relation-utils.ts
 function hasChildPagination(relArgs) {
@@ -4203,12 +3922,6 @@ function extractNestedIncludeSpec(relArgs, relModel) {
   }
   return out;
 }
-var init_relation_utils = __esm({
-  "src/builder/shared/relation-utils.ts"() {
-    init_model_field_cache();
-    init_type_guards();
-  }
-});
 
 // src/builder/select/flat-join.ts
 function createAliasCounter() {
@@ -4428,19 +4141,7 @@ function buildFlatJoinSql(spec) {
   `.trim();
   return { sql, requiresReduction: true, includeSpec };
 }
-var init_flat_join = __esm({
-  "src/builder/select/flat-join.ts"() {
-    init_constants();
-    init_sql_utils();
-    init_joins();
-    init_model_field_cache();
-    init_assembly();
-    init_type_guards();
-    init_primary_key_utils();
-    init_relation_extraction_utils();
-    init_relation_utils();
-  }
-});
+var SELECT_FIELD_REGEX = /^\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)\s*\.\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)(?:\s+AS\s+("(?:[^"]|"")+"|[a-z_][a-z0-9_]*))?\s*$/i;
 function buildWhereSql(conditions) {
   if (!isNonEmptyArray(conditions)) return "";
   return " " + SQL_TEMPLATES.WHERE + " " + conditions.join(SQL_SEPARATORS.CONDITION_AND);
@@ -4942,24 +4643,6 @@ function constructFinalSql(spec) {
   sql = appendPagination(sql, spec);
   return finalizeSql(sql, params, dialect);
 }
-var SELECT_FIELD_REGEX;
-var init_assembly = __esm({
-  "src/builder/select/assembly.ts"() {
-    init_constants();
-    init_sql_utils();
-    init_sql_validators();
-    init_type_guards();
-    init_dynamic_params();
-    init_sql_builder_dialect();
-    init_includes();
-    init_string_builder();
-    init_model_field_cache();
-    init_pagination();
-    init_order_by_utils();
-    init_flat_join();
-    SELECT_FIELD_REGEX = /^\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)\s*\.\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)(?:\s+AS\s+("(?:[^"]|"")+"|[a-z_][a-z0-9_]*))?\s*$/i;
-  }
-});
 
 // src/builder/select.ts
 function normalizeOrderByInput3(orderBy) {
@@ -5237,23 +4920,9 @@ function buildSelectSql(input) {
   });
   return constructFinalSql(spec);
 }
-var init_select = __esm({
-  "src/builder/select.ts"() {
-    init_sql_builder_dialect();
-    init_pagination();
-    init_assembly();
-    init_fields();
-    init_includes();
-    init_order_by_utils();
-    init_param_store();
-    init_sql_utils();
-    init_type_guards();
-    init_field_assertions();
-    init_model_field_cache();
-  }
-});
 
 // src/builder/shared/comparison-builder.ts
+var DEFAULT_EXCLUDE_KEYS = /* @__PURE__ */ new Set(["mode"]);
 function buildComparisons(expr, filter, params, dialect, builder, excludeKeys = DEFAULT_EXCLUDE_KEYS) {
   const out = [];
   for (const op in filter) {
@@ -5266,14 +4935,40 @@ function buildComparisons(expr, filter, params, dialect, builder, excludeKeys =
   }
   return out;
 }
-var DEFAULT_EXCLUDE_KEYS;
-var init_comparison_builder = __esm({
-  "src/builder/shared/comparison-builder.ts"() {
-    DEFAULT_EXCLUDE_KEYS = /* @__PURE__ */ new Set(["mode"]);
-  }
-});
 
 // src/builder/aggregates.ts
+var MAX_NOT_DEPTH2 = 50;
+var AGGREGATES = [
+  ["_sum", "SUM"],
+  ["_avg", "AVG"],
+  ["_min", "MIN"],
+  ["_max", "MAX"]
+];
+var COMPARISON_OPS = {
+  [Ops.EQUALS]: "=",
+  [Ops.NOT]: "<>",
+  [Ops.GT]: ">",
+  [Ops.GTE]: ">=",
+  [Ops.LT]: "<",
+  [Ops.LTE]: "<="
+};
+var HAVING_ALLOWED_OPS = /* @__PURE__ */ new Set([
+  Ops.EQUALS,
+  Ops.NOT,
+  Ops.GT,
+  Ops.GTE,
+  Ops.LT,
+  Ops.LTE,
+  Ops.IN,
+  Ops.NOT_IN
+]);
+var HAVING_FIELD_FIRST_AGG_KEYS = Object.freeze([
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+]);
 function hasAnyOwnKey(obj) {
   for (const k in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, k)) return true;
@@ -5781,58 +5476,6 @@ function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model
     paramMappings: sub.paramMappings
   };
 }
-var MAX_NOT_DEPTH2, AGGREGATES, COMPARISON_OPS, HAVING_ALLOWED_OPS, HAVING_FIELD_FIRST_AGG_KEYS;
-var init_aggregates = __esm({
-  "src/builder/aggregates.ts"() {
-    init_constants();
-    init_sql_utils();
-    init_param_store();
-    init_sql_validators();
-    init_type_guards();
-    init_sql_builder_dialect();
-    init_dynamic_params();
-    init_operators_scalar();
-    init_field_assertions();
-    init_comparison_builder();
-    init_pagination();
-    init_select();
-    init_primary_key_utils();
-    init_null_comparison();
-    init_in_operator_builder();
-    MAX_NOT_DEPTH2 = 50;
-    AGGREGATES = [
-      ["_sum", "SUM"],
-      ["_avg", "AVG"],
-      ["_min", "MIN"],
-      ["_max", "MAX"]
-    ];
-    COMPARISON_OPS = {
-      [Ops.EQUALS]: "=",
-      [Ops.NOT]: "<>",
-      [Ops.GT]: ">",
-      [Ops.GTE]: ">=",
-      [Ops.LT]: "<",
-      [Ops.LTE]: "<="
-    };
-    HAVING_ALLOWED_OPS = /* @__PURE__ */ new Set([
-      Ops.EQUALS,
-      Ops.NOT,
-      Ops.GT,
-      Ops.GTE,
-      Ops.LT,
-      Ops.LTE,
-      Ops.IN,
-      Ops.NOT_IN
-    ]);
-    HAVING_FIELD_FIRST_AGG_KEYS = Object.freeze([
-      "_count",
-      "_sum",
-      "_avg",
-      "_min",
-      "_max"
-    ]);
-  }
-});
 function safeAlias(input) {
   const raw = String(input).toLowerCase();
   const cleaned = raw.replace(/[^a-z0-9_]/g, "_");
@@ -6108,19 +5751,6 @@ function generateSQL(directive) {
     includeSpec: built.includeSpec
   });
 }
-var init_sql_generator = __esm({
-  "src/sql-generator.ts"() {
-    init_joins();
-    init_select();
-    init_aggregates();
-    init_sql_builder_dialect();
-    init_where();
-    init_sql_utils();
-    init_constants();
-    init_sql_validators();
-    init_type_guards();
-  }
-});
 
 // src/utils/s3-fifo.ts
 function withDispose(it) {
@@ -6131,220 +5761,215 @@ function withDispose(it) {
   }
   return it;
 }
-function createBoundedCache(maxSize) {
-  return new BoundedCache(maxSize);
-}
-var BoundedCache;
-var init_s3_fifo = __esm({
-  "src/utils/s3-fifo.ts"() {
-    BoundedCache = class {
-      constructor(maxSize) {
-        this.map = /* @__PURE__ */ new Map();
-        this.ghost = /* @__PURE__ */ new Set();
-        this.smallHead = null;
-        this.smallTail = null;
-        this.smallSize = 0;
-        this.mainHead = null;
-        this.mainTail = null;
-        this.mainSize = 0;
-        this.maxSize = maxSize;
-        this.smallLimit = Math.max(1, Math.floor(maxSize * 0.1));
-        this.mainLimit = maxSize - this.smallLimit;
-        this.ghostLimit = this.mainLimit;
-      }
-      get size() {
-        return this.map.size;
-      }
-      get(key) {
-        const node = this.map.get(key);
-        if (!node) return void 0;
-        node.freq = Math.min(node.freq + 1, 3);
-        return node.value;
-      }
-      set(key, value) {
-        const existing = this.map.get(key);
-        if (existing) {
-          existing.value = value;
-          return this;
-        }
-        if (this.ghost.has(key)) {
-          this.ghost.delete(key);
-          const node2 = this.createNode(key, value, "main");
-          this.map.set(key, node2);
-          this.pushMain(node2);
-          if (this.mainSize > this.mainLimit) this.evictMain();
-          return this;
-        }
-        const node = this.createNode(key, value, "small");
-        this.map.set(key, node);
-        this.pushSmall(node);
-        if (this.size > this.maxSize) {
-          if (this.smallSize > this.smallLimit) this.evictSmall();
-          else this.evictMain();
-        }
-        return this;
-      }
-      has(key) {
-        return this.map.has(key);
-      }
-      delete(key) {
-        const node = this.map.get(key);
-        if (!node) return false;
-        this.map.delete(key);
-        this.removeNode(node);
-        return true;
-      }
-      clear() {
-        this.map.clear();
-        this.ghost.clear();
-        this.smallHead = this.smallTail = null;
-        this.mainHead = this.mainTail = null;
-        this.smallSize = this.mainSize = 0;
-      }
-      keys() {
-        return withDispose(
-          (function* (self) {
-            for (const key of self.map.keys()) yield key;
-          })(this)
-        );
-      }
-      values() {
-        return withDispose(
-          (function* (self) {
-            for (const node of self.map.values()) yield node.value;
-          })(this)
-        );
-      }
-      entries() {
-        return withDispose(
-          (function* (self) {
-            for (const [key, node] of self.map.entries())
-              yield [key, node.value];
-          })(this)
-        );
-      }
-      forEach(callbackfn, thisArg) {
-        for (const [key, node] of this.map.entries()) {
-          callbackfn.call(thisArg, node.value, key, this);
-        }
-      }
-      [Symbol.iterator]() {
-        return this.entries();
-      }
-      get [Symbol.toStringTag]() {
-        return "BoundedCache";
-      }
-      createNode(key, value, queue) {
-        return { key, value, freq: 0, queue, prev: null, next: null };
-      }
-      pushSmall(node) {
-        node.next = this.smallHead;
-        node.prev = null;
-        if (this.smallHead) this.smallHead.prev = node;
-        else this.smallTail = node;
-        this.smallHead = node;
-        this.smallSize++;
-      }
-      pushMain(node) {
-        node.next = this.mainHead;
-        node.prev = null;
-        if (this.mainHead) this.mainHead.prev = node;
-        else this.mainTail = node;
-        this.mainHead = node;
-        this.mainSize++;
-      }
-      popSmall() {
-        if (!this.smallTail) return null;
-        const node = this.smallTail;
-        this.smallTail = node.prev;
-        if (this.smallTail) this.smallTail.next = null;
-        else this.smallHead = null;
-        node.prev = null;
-        node.next = null;
-        this.smallSize--;
-        return node;
-      }
-      popMain() {
-        if (!this.mainTail) return null;
-        const node = this.mainTail;
-        this.mainTail = node.prev;
-        if (this.mainTail) this.mainTail.next = null;
-        else this.mainHead = null;
-        node.prev = null;
-        node.next = null;
-        this.mainSize--;
-        return node;
-      }
-      removeNode(node) {
-        this.unlinkNode(node);
-        if (node.queue === "small") {
-          if (node === this.smallHead) this.smallHead = node.next;
-          if (node === this.smallTail) this.smallTail = node.prev;
-          this.smallSize--;
-        } else {
-          if (node === this.mainHead) this.mainHead = node.next;
-          if (node === this.mainTail) this.mainTail = node.prev;
-          this.mainSize--;
-        }
-        node.prev = null;
-        node.next = null;
-      }
-      unlinkNode(node) {
-        if (node.prev) node.prev.next = node.next;
-        if (node.next) node.next.prev = node.prev;
-      }
-      shouldPromoteFromSmall(node) {
-        return node.freq > 1;
-      }
-      shouldRetryInMain(node) {
-        return node.freq >= 1;
-      }
-      promoteToMain(node) {
-        node.queue = "main";
-        this.pushMain(node);
-      }
-      addToGhost(key) {
-        this.ghost.add(key);
-        if (this.ghost.size <= this.ghostLimit) return;
-        const firstGhost = this.ghost.values().next().value;
-        if (firstGhost !== void 0) this.ghost.delete(firstGhost);
-      }
-      evictFromCache(node) {
-        this.map.delete(node.key);
-      }
-      evictSmall() {
-        while (this.smallSize > 0) {
-          const node = this.popSmall();
-          if (!node) return;
-          if (this.shouldPromoteFromSmall(node)) {
-            this.promoteToMain(node);
-            if (this.mainSize > this.mainLimit) {
-              this.evictMain();
-              return;
-            }
-            continue;
-          }
-          this.evictFromCache(node);
-          this.addToGhost(node.key);
+var BoundedCache = class {
+  constructor(maxSize) {
+    this.map = /* @__PURE__ */ new Map();
+    this.ghost = /* @__PURE__ */ new Set();
+    this.smallHead = null;
+    this.smallTail = null;
+    this.smallSize = 0;
+    this.mainHead = null;
+    this.mainTail = null;
+    this.mainSize = 0;
+    this.maxSize = maxSize;
+    this.smallLimit = Math.max(1, Math.floor(maxSize * 0.1));
+    this.mainLimit = maxSize - this.smallLimit;
+    this.ghostLimit = this.mainLimit;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    node.freq = Math.min(node.freq + 1, 3);
+    return node.value;
+  }
+  set(key, value) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      return this;
+    }
+    if (this.ghost.has(key)) {
+      this.ghost.delete(key);
+      const node2 = this.createNode(key, value, "main");
+      this.map.set(key, node2);
+      this.pushMain(node2);
+      if (this.mainSize > this.mainLimit) this.evictMain();
+      return this;
+    }
+    const node = this.createNode(key, value, "small");
+    this.map.set(key, node);
+    this.pushSmall(node);
+    if (this.size > this.maxSize) {
+      if (this.smallSize > this.smallLimit) this.evictSmall();
+      else this.evictMain();
+    }
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.map.delete(key);
+    this.removeNode(node);
+    return true;
+  }
+  clear() {
+    this.map.clear();
+    this.ghost.clear();
+    this.smallHead = this.smallTail = null;
+    this.mainHead = this.mainTail = null;
+    this.smallSize = this.mainSize = 0;
+  }
+  keys() {
+    return withDispose(
+      (function* (self) {
+        for (const key of self.map.keys()) yield key;
+      })(this)
+    );
+  }
+  values() {
+    return withDispose(
+      (function* (self) {
+        for (const node of self.map.values()) yield node.value;
+      })(this)
+    );
+  }
+  entries() {
+    return withDispose(
+      (function* (self) {
+        for (const [key, node] of self.map.entries())
+          yield [key, node.value];
+      })(this)
+    );
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [key, node] of this.map.entries()) {
+      callbackfn.call(thisArg, node.value, key, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "BoundedCache";
+  }
+  createNode(key, value, queue) {
+    return { key, value, freq: 0, queue, prev: null, next: null };
+  }
+  pushSmall(node) {
+    node.next = this.smallHead;
+    node.prev = null;
+    if (this.smallHead) this.smallHead.prev = node;
+    else this.smallTail = node;
+    this.smallHead = node;
+    this.smallSize++;
+  }
+  pushMain(node) {
+    node.next = this.mainHead;
+    node.prev = null;
+    if (this.mainHead) this.mainHead.prev = node;
+    else this.mainTail = node;
+    this.mainHead = node;
+    this.mainSize++;
+  }
+  popSmall() {
+    if (!this.smallTail) return null;
+    const node = this.smallTail;
+    this.smallTail = node.prev;
+    if (this.smallTail) this.smallTail.next = null;
+    else this.smallHead = null;
+    node.prev = null;
+    node.next = null;
+    this.smallSize--;
+    return node;
+  }
+  popMain() {
+    if (!this.mainTail) return null;
+    const node = this.mainTail;
+    this.mainTail = node.prev;
+    if (this.mainTail) this.mainTail.next = null;
+    else this.mainHead = null;
+    node.prev = null;
+    node.next = null;
+    this.mainSize--;
+    return node;
+  }
+  removeNode(node) {
+    this.unlinkNode(node);
+    if (node.queue === "small") {
+      if (node === this.smallHead) this.smallHead = node.next;
+      if (node === this.smallTail) this.smallTail = node.prev;
+      this.smallSize--;
+    } else {
+      if (node === this.mainHead) this.mainHead = node.next;
+      if (node === this.mainTail) this.mainTail = node.prev;
+      this.mainSize--;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  unlinkNode(node) {
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+  }
+  shouldPromoteFromSmall(node) {
+    return node.freq > 1;
+  }
+  shouldRetryInMain(node) {
+    return node.freq >= 1;
+  }
+  promoteToMain(node) {
+    node.queue = "main";
+    this.pushMain(node);
+  }
+  addToGhost(key) {
+    this.ghost.add(key);
+    if (this.ghost.size <= this.ghostLimit) return;
+    const firstGhost = this.ghost.values().next().value;
+    if (firstGhost !== void 0) this.ghost.delete(firstGhost);
+  }
+  evictFromCache(node) {
+    this.map.delete(node.key);
+  }
+  evictSmall() {
+    while (this.smallSize > 0) {
+      const node = this.popSmall();
+      if (!node) return;
+      if (this.shouldPromoteFromSmall(node)) {
+        this.promoteToMain(node);
+        if (this.mainSize > this.mainLimit) {
+          this.evictMain();
           return;
         }
+        continue;
       }
-      evictMain() {
-        while (this.mainSize > 0) {
-          const node = this.popMain();
-          if (!node) return;
-          if (this.shouldRetryInMain(node)) {
-            node.freq--;
-            this.pushMain(node);
-            continue;
-          }
-          this.evictFromCache(node);
-          return;
-        }
+      this.evictFromCache(node);
+      this.addToGhost(node.key);
+      return;
+    }
+  }
+  evictMain() {
+    while (this.mainSize > 0) {
+      const node = this.popMain();
+      if (!node) return;
+      if (this.shouldRetryInMain(node)) {
+        node.freq--;
+        this.pushMain(node);
+        continue;
       }
-    };
+      this.evictFromCache(node);
+      return;
+    }
   }
-});
+};
+function createBoundedCache(maxSize) {
+  return new BoundedCache(maxSize);
+}
 
 // src/fast-path.ts
 function getIdField(model) {
@@ -6506,17 +6131,36 @@ function tryFastPath(model, method, args, dialect) {
   }
   return null;
 }
-var init_fast_path = __esm({
-  "src/fast-path.ts"() {
-    init_sql_utils();
-    init_constants();
-    init_type_guards();
-    init_normalize_value();
-    init_query_cache();
-  }
-});
 
 // 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}`;
@@ -6746,73 +6390,99 @@ function buildSQLWithCache(model, models, method, args, dialect) {
   });
   return result;
 }
-var _hits, _misses, QueryCacheStats, queryCache, queryCacheStats;
-var init_query_cache = __esm({
-  "src/query-cache.ts"() {
-    init_where();
-    init_select();
-    init_aggregates();
-    init_sql_utils();
-    init_constants();
-    init_s3_fifo();
-    init_fast_path();
-    QueryCacheStats = class {
-      constructor() {
-        __privateAdd(this, _hits, 0);
-        __privateAdd(this, _misses, 0);
-      }
-      hit() {
-        __privateWrapper(this, _hits)._++;
-      }
-      miss() {
-        __privateWrapper(this, _misses)._++;
+
+// src/builder/select/row-transformers.ts
+function transformAggregateRow(row) {
+  if (!row || typeof row !== "object") return row;
+  const result = {};
+  for (const key in row) {
+    if (!Object.prototype.hasOwnProperty.call(row, key)) continue;
+    let value = row[key];
+    if (typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value)) {
+      value = value.includes(".") ? parseFloat(value) : parseInt(value, 10);
+    }
+    const dotIndex = key.indexOf(".");
+    if (dotIndex === -1) {
+      result[key] = value;
+      continue;
+    }
+    const prefix = key.slice(0, dotIndex);
+    const suffix = key.slice(dotIndex + 1);
+    if (AGGREGATE_PREFIXES.has(prefix)) {
+      if (!result[prefix]) {
+        result[prefix] = {};
       }
-      reset() {
-        __privateSet(this, _hits, 0);
-        __privateSet(this, _misses, 0);
+      result[prefix][suffix] = value;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function extractCountValue(row) {
+  if (!row || typeof row !== "object") return 0;
+  if ("_count._all" in row) {
+    const value = row["_count._all"];
+    if (typeof value === "string") return parseInt(value, 10);
+    return value;
+  }
+  if ("_count" in row && row["_count"] && typeof row["_count"] === "object") {
+    const countObj = row["_count"];
+    if ("_all" in countObj) {
+      const value = countObj["_all"];
+      if (typeof value === "string") return parseInt(value, 10);
+      return value;
+    }
+  }
+  const keys = Object.keys(row);
+  for (const key of keys) {
+    if (key.includes("count") || key.includes("COUNT")) {
+      const value = row[key];
+      if (typeof value === "number" || typeof value === "bigint") {
+        return value;
       }
-      get snapshot() {
-        return Object.freeze({
-          hits: __privateGet(this, _hits),
-          misses: __privateGet(this, _misses),
-          size: queryCache.size
-        });
+      if (typeof value === "string") {
+        return parseInt(value, 10);
       }
-    };
-    _hits = new WeakMap();
-    _misses = new WeakMap();
-    queryCache = createBoundedCache(1e3);
-    queryCacheStats = new QueryCacheStats();
+    }
   }
-});
+  return 0;
+}
+function getRowTransformer(method) {
+  if (method === "count") {
+    return extractCountValue;
+  }
+  if (method === "groupBy" || method === "aggregate") {
+    return transformAggregateRow;
+  }
+  return null;
+}
 
 // src/result-transformers.ts
 function transformQueryResults(method, results) {
-  var _a;
+  var _a, _b;
   if (method === "findFirst" || method === "findUnique") {
     if (Array.isArray(results)) {
       return (_a = results[0]) != null ? _a : null;
     }
   }
+  if (method === "aggregate") {
+    if (Array.isArray(results)) {
+      return (_b = results[0]) != null ? _b : null;
+    }
+  }
   if (method === "count") {
     if (Array.isArray(results) && results.length > 0) {
-      const row = results[0];
-      if (typeof row === "number" || typeof row === "bigint") {
-        return row;
-      }
-      if (row && typeof row === "object" && "_count._all" in row) {
-        return row["_count._all"];
+      const first = results[0];
+      if (typeof first === "number" || typeof first === "bigint") {
+        return first;
       }
-      return row;
+      return extractCountValue(first);
     }
     return 0;
   }
   return results;
 }
-var init_result_transformers = __esm({
-  "src/result-transformers.ts"() {
-  }
-});
 
 // src/batch.ts
 function quoteBatchIdent(id) {
@@ -7459,12 +7129,29 @@ function parseCountValue(value) {
   }
   return 0;
 }
-function parseBatchCountResults(row, count) {
+function parseBatchCountResults(row, queryCount) {
   const results = [];
-  for (let i = 0; i < count; i++) {
-    const key = `count_${i}`;
+  for (let i = 0; i < queryCount; i++) {
+    const key = `_count_${i}`;
     const value = row[key];
-    results.push(parseCountValue(value));
+    if (value === null || value === void 0) {
+      results.push(0);
+      continue;
+    }
+    if (typeof value === "number") {
+      results.push(value);
+      continue;
+    }
+    if (typeof value === "bigint") {
+      results.push(Number(value));
+      continue;
+    }
+    if (typeof value === "string") {
+      const parsed = parseInt(value, 10);
+      results.push(isNaN(parsed) ? 0 : parsed);
+      continue;
+    }
+    results.push(0);
   }
   return results;
 }
@@ -7649,13 +7336,6 @@ function parseBatchResults(row, keys, queries, aliases, modelMap) {
   }
   return results;
 }
-var init_batch = __esm({
-  "src/batch.ts"() {
-    init_query_cache();
-    init_result_transformers();
-    init_sql_utils();
-  }
-});
 
 // src/transaction.ts
 function isolationLevelToPostgresKeyword(level) {
@@ -7726,7 +7406,11 @@ function createTransactionExecutor(deps) {
               q.args || {},
               dialect
             );
-            const rawResults = yield sql.unsafe(sqlStr, params);
+            let rawResults = yield sql.unsafe(sqlStr, params);
+            const rowTransformer = getRowTransformer(q.method);
+            if (rowTransformer && Array.isArray(rawResults)) {
+              rawResults = rawResults.map(rowTransformer);
+            }
             results.push(transformQueryResults(q.method, rawResults));
           }
           return results;
@@ -7736,12 +7420,6 @@ function createTransactionExecutor(deps) {
     }
   };
 }
-var init_transaction = __esm({
-  "src/transaction.ts"() {
-    init_query_cache();
-    init_result_transformers();
-  }
-});
 
 // src/builder/shared/key-utils.ts
 function buildCompositeKey(row, fields) {
@@ -7776,10 +7454,6 @@ function buildCompositeKey(row, fields) {
   }
   return parts.join("");
 }
-var init_key_utils = __esm({
-  "src/builder/shared/key-utils.ts"() {
-  }
-});
 
 // src/builder/select/reducer.ts
 function buildRelationScalarCols(relModel, relPath, includeAllScalars, selectedScalarFields) {
@@ -7964,17 +7638,10 @@ function reduceFlatRows(rows, config) {
   }
   return Array.from(resultMap.values());
 }
-var init_reducer = __esm({
-  "src/builder/select/reducer.ts"() {
-    init_model_field_cache();
-    init_primary_key_utils();
-    init_key_utils();
-    init_model_field_cache();
-    init_relation_utils();
-  }
-});
 
 // src/builder/select/segment-planner.ts
+var HARD_FANOUT_CAP = 5e3;
+var MAX_ESTIMATED_ROWS = Number.MAX_SAFE_INTEGER / 1e3;
 function isList(field) {
   return typeof field.type === "string" && field.type.endsWith("[]");
 }
@@ -8135,17 +7802,6 @@ function planQueryStrategy(params) {
   const filteredArgs = removeRelationsFromArgs(args, toRemove);
   return { filteredArgs, whereInSegments };
 }
-var HARD_FANOUT_CAP, MAX_ESTIMATED_ROWS;
-var init_segment_planner = __esm({
-  "src/builder/select/segment-planner.ts"() {
-    init_type_guards();
-    init_relation_extraction_utils();
-    init_relation_key_utils();
-    init_relation_utils();
-    HARD_FANOUT_CAP = 5e3;
-    MAX_ESTIMATED_ROWS = Number.MAX_SAFE_INTEGER / 1e3;
-  }
-});
 
 // src/builder/shared/where-in-executor-base.ts
 function getParamLimit(dialect) {
@@ -8252,13 +7908,6 @@ function executeSegmentBase(segment, parentRows, allModels, modelMap, dialect, e
     stitchResults(parentRows, segment, allChildRows, needsStripFk);
   });
 }
-var init_where_in_executor_base = __esm({
-  "src/builder/shared/where-in-executor-base.ts"() {
-    init_src();
-    init_reducer();
-    init_type_guards();
-  }
-});
 
 // src/builder/where-in-executor.ts
 function executeWhereInSegments(params) {
@@ -8278,135 +7927,122 @@ function executeWhereInSegments(params) {
     }
   });
 }
-var init_where_in_executor = __esm({
-  "src/builder/where-in-executor.ts"() {
-    init_where_in_executor_base();
-  }
-});
 
 // src/builder/select/core-reducer.ts
-var getOrCreateRelationMap, getOrCreateChildMap, createParentObject, createChildObject, extractChildKey, attachChildToParent, createRelationProcessor, createCoreReducer;
-var init_core_reducer = __esm({
-  "src/builder/select/core-reducer.ts"() {
-    init_primary_key_utils();
-    init_key_utils();
-    init_model_field_cache();
-    getOrCreateRelationMap = (relationMaps, parent) => {
-      let relMap = relationMaps.get(parent);
-      if (!relMap) {
-        relMap = /* @__PURE__ */ new Map();
-        relationMaps.set(parent, relMap);
-      }
-      return relMap;
-    };
-    getOrCreateChildMap = (relMap, path) => {
-      let childMap = relMap.get(path);
-      if (!childMap) {
-        childMap = /* @__PURE__ */ new Map();
-        relMap.set(path, childMap);
-      }
-      return childMap;
-    };
-    createParentObject = (row, scalarFields, jsonSet, includedRelations) => {
-      const parent = {};
-      for (const field of scalarFields) {
-        if (!(field.name in row)) continue;
-        parent[field.name] = maybeParseJson(row[field.name], jsonSet, field.name);
-      }
-      for (const rel of includedRelations) {
-        parent[rel.name] = rel.cardinality === "many" ? [] : null;
-      }
-      return parent;
-    };
-    createChildObject = (row, rel) => {
-      const child = {};
-      for (const spec of rel.scalarCols) {
-        if (!(spec.colName in row)) continue;
-        child[spec.fieldName] = parseJsonIfNeeded(spec.isJson, row[spec.colName]);
-      }
+var getOrCreateRelationMap = (relationMaps, parent) => {
+  let relMap = relationMaps.get(parent);
+  if (!relMap) {
+    relMap = /* @__PURE__ */ new Map();
+    relationMaps.set(parent, relMap);
+  }
+  return relMap;
+};
+var getOrCreateChildMap = (relMap, path) => {
+  let childMap = relMap.get(path);
+  if (!childMap) {
+    childMap = /* @__PURE__ */ new Map();
+    relMap.set(path, childMap);
+  }
+  return childMap;
+};
+var createParentObject = (row, scalarFields, jsonSet, includedRelations) => {
+  const parent = {};
+  for (const field of scalarFields) {
+    if (!(field.name in row)) continue;
+    parent[field.name] = maybeParseJson(row[field.name], jsonSet, field.name);
+  }
+  for (const rel of includedRelations) {
+    parent[rel.name] = rel.cardinality === "many" ? [] : null;
+  }
+  return parent;
+};
+var createChildObject = (row, rel) => {
+  const child = {};
+  for (const spec of rel.scalarCols) {
+    if (!(spec.colName in row)) continue;
+    child[spec.fieldName] = parseJsonIfNeeded(spec.isJson, row[spec.colName]);
+  }
+  if (rel.nestedIncludes) {
+    for (const nested of rel.nestedIncludes.includedRelations) {
+      child[nested.name] = nested.cardinality === "many" ? [] : null;
+    }
+  }
+  return child;
+};
+var extractChildKey = (row, rel) => {
+  const cols = rel.primaryKeyFields.map((f) => `${rel.path}.${f}`);
+  return buildCompositeKey(row, cols);
+};
+var attachChildToParent = (parent, child, rel) => {
+  if (rel.cardinality === "many") {
+    parent[rel.name].push(child);
+  } else {
+    parent[rel.name] = child;
+  }
+};
+var createRelationProcessor = (relationMaps) => {
+  const processRelation2 = (parent, rel, row) => {
+    const childKey = extractChildKey(row, rel);
+    if (!childKey) return;
+    const relMap = getOrCreateRelationMap(relationMaps, parent);
+    const childMap = getOrCreateChildMap(relMap, rel.path);
+    if (childMap.has(childKey)) {
+      const existing = childMap.get(childKey);
       if (rel.nestedIncludes) {
         for (const nested of rel.nestedIncludes.includedRelations) {
-          child[nested.name] = nested.cardinality === "many" ? [] : null;
+          processRelation2(existing, nested, row);
         }
       }
-      return child;
-    };
-    extractChildKey = (row, rel) => {
-      const cols = rel.primaryKeyFields.map((f) => `${rel.path}.${f}`);
-      return buildCompositeKey(row, cols);
-    };
-    attachChildToParent = (parent, child, rel) => {
-      if (rel.cardinality === "many") {
-        parent[rel.name].push(child);
-      } else {
-        parent[rel.name] = child;
+      return;
+    }
+    const child = createChildObject(row, rel);
+    childMap.set(childKey, child);
+    attachChildToParent(parent, child, rel);
+    if (rel.nestedIncludes) {
+      for (const nested of rel.nestedIncludes.includedRelations) {
+        processRelation2(child, nested, row);
       }
-    };
-    createRelationProcessor = (relationMaps) => {
-      const processRelation2 = (parent, rel, row) => {
-        const childKey = extractChildKey(row, rel);
-        if (!childKey) return;
-        const relMap = getOrCreateRelationMap(relationMaps, parent);
-        const childMap = getOrCreateChildMap(relMap, rel.path);
-        if (childMap.has(childKey)) {
-          const existing = childMap.get(childKey);
-          if (rel.nestedIncludes) {
-            for (const nested of rel.nestedIncludes.includedRelations) {
-              processRelation2(existing, nested, row);
-            }
-          }
-          return;
-        }
-        const child = createChildObject(row, rel);
-        childMap.set(childKey, child);
-        attachChildToParent(parent, child, rel);
-        if (rel.nestedIncludes) {
-          for (const nested of rel.nestedIncludes.includedRelations) {
-            processRelation2(child, nested, row);
-          }
-        }
-      };
-      return processRelation2;
-    };
-    createCoreReducer = (config) => {
-      const parentMap = /* @__PURE__ */ new Map();
-      const relationMaps = /* @__PURE__ */ new WeakMap();
-      const scalarFields = config.parentModel.fields.filter((f) => !f.isRelation);
-      const jsonSet = getJsonFieldSet(config.parentModel);
-      const parentPkFields = getPrimaryKeyFields(config.parentModel);
-      const includedRelations = config.includedRelations;
-      const extractParentKey = (row) => buildCompositeKey(row, parentPkFields);
-      const processRelation2 = createRelationProcessor(relationMaps);
-      const processRow = (row) => {
-        const parentKey = extractParentKey(row);
-        if (!parentKey) return null;
-        const parent = parentMap.has(parentKey) ? parentMap.get(parentKey) : (() => {
-          const newParent = createParentObject(
-            row,
-            scalarFields,
-            jsonSet,
-            includedRelations
-          );
-          parentMap.set(parentKey, newParent);
-          return newParent;
-        })();
-        for (const rel of includedRelations) {
-          processRelation2(parent, rel, row);
-        }
-        return parentKey;
-      };
-      return {
-        processRow,
-        getParent: (key) => {
-          var _a;
-          return (_a = parentMap.get(key)) != null ? _a : null;
-        },
-        getAllParents: () => Array.from(parentMap.values()),
-        getParentMap: () => parentMap
-      };
-    };
-  }
-});
+    }
+  };
+  return processRelation2;
+};
+var createCoreReducer = (config) => {
+  const parentMap = /* @__PURE__ */ new Map();
+  const relationMaps = /* @__PURE__ */ new WeakMap();
+  const scalarFields = config.parentModel.fields.filter((f) => !f.isRelation);
+  const jsonSet = getJsonFieldSet(config.parentModel);
+  const parentPkFields = getPrimaryKeyFields(config.parentModel);
+  const includedRelations = config.includedRelations;
+  const extractParentKey = (row) => buildCompositeKey(row, parentPkFields);
+  const processRelation2 = createRelationProcessor(relationMaps);
+  const processRow = (row) => {
+    const parentKey = extractParentKey(row);
+    if (!parentKey) return null;
+    const parent = parentMap.has(parentKey) ? parentMap.get(parentKey) : (() => {
+      const newParent = createParentObject(
+        row,
+        scalarFields,
+        jsonSet,
+        includedRelations
+      );
+      parentMap.set(parentKey, newParent);
+      return newParent;
+    })();
+    for (const rel of includedRelations) {
+      processRelation2(parent, rel, row);
+    }
+    return parentKey;
+  };
+  return {
+    processRow,
+    getParent: (key) => {
+      var _a;
+      return (_a = parentMap.get(key)) != null ? _a : null;
+    },
+    getAllParents: () => Array.from(parentMap.values()),
+    getParentMap: () => parentMap
+  };
+};
 
 // src/builder/select/streaming-reducer.ts
 function createStreamingReducer(config) {
@@ -8426,11 +8062,6 @@ function createStreamingReducer(config) {
     }
   };
 }
-var init_streaming_reducer = __esm({
-  "src/builder/select/streaming-reducer.ts"() {
-    init_core_reducer();
-  }
-});
 
 // src/builder/select/streaming-progressive-reducer.ts
 function createProgressiveReducer(config) {
@@ -8465,11 +8096,6 @@ function createProgressiveReducer(config) {
     }
   };
 }
-var init_streaming_progressive_reducer = __esm({
-  "src/builder/select/streaming-progressive-reducer.ts"() {
-    init_core_reducer();
-  }
-});
 
 // src/builder/select/streaming-where-in-executor.ts
 function executeWhereInSegmentsStreaming(params) {
@@ -8597,77 +8223,9 @@ function buildChildArgs2(relArgs, fkFieldName, parentIds) {
   base.where = existingWhere ? { AND: [existingWhere, inCondition] } : inCondition;
   return base;
 }
-var init_streaming_where_in_executor = __esm({
-  "src/builder/select/streaming-where-in-executor.ts"() {
-    init_primary_key_utils();
-    init_src();
-    init_reducer();
-  }
-});
-
-// src/builder/select/row-transformers.ts
-function transformAggregateRow(row) {
-  if (!row || typeof row !== "object") return row;
-  const result = {};
-  for (const key in row) {
-    if (!Object.prototype.hasOwnProperty.call(row, key)) continue;
-    const value = row[key];
-    const dotIndex = key.indexOf(".");
-    if (dotIndex === -1) {
-      result[key] = value;
-      continue;
-    }
-    const prefix = key.slice(0, dotIndex);
-    const suffix = key.slice(dotIndex + 1);
-    if (AGGREGATE_PREFIXES.has(prefix)) {
-      if (!result[prefix]) {
-        result[prefix] = {};
-      }
-      result[prefix][suffix] = value;
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function extractCountValue(row) {
-  if (!row || typeof row !== "object") return 0;
-  if ("_count._all" in row) {
-    return row["_count._all"];
-  }
-  if ("_count" in row && row["_count"] && typeof row["_count"] === "object") {
-    const countObj = row["_count"];
-    if ("_all" in countObj) {
-      return countObj["_all"];
-    }
-  }
-  const keys = Object.keys(row);
-  for (const key of keys) {
-    if (key.includes("count") || key.includes("COUNT")) {
-      const value = row[key];
-      if (typeof value === "number" || typeof value === "bigint") {
-        return value;
-      }
-    }
-  }
-  return 0;
-}
-function getRowTransformer(method) {
-  if (method === "count") {
-    return extractCountValue;
-  }
-  if (method === "groupBy" || method === "aggregate") {
-    return transformAggregateRow;
-  }
-  return null;
-}
-var init_row_transformers = __esm({
-  "src/builder/select/row-transformers.ts"() {
-    init_constants();
-  }
-});
 
 // src/generated-runtime.ts
+var SQLITE_STMT_CACHE = /* @__PURE__ */ new WeakMap();
 function getOrPrepareStatement(client, sql) {
   let cache = SQLITE_STMT_CACHE.get(client);
   if (!cache) {
@@ -8694,66 +8252,39 @@ function normalizeParams(params) {
 function executePostgresQuery(client, sql, params, method, requiresReduction, includeSpec, model, allModels) {
   return __async(this, null, function* () {
     const normalizedParams = normalizeParams(params);
-    const query = client.unsafe(sql, normalizedParams);
-    if (requiresReduction && includeSpec && model) {
+    const rowTransformer = getRowTransformer(method);
+    if (requiresReduction && includeSpec) {
       const config = buildReducerConfig(model, includeSpec, allModels);
-      const { createStreamingReducer: createStreamingReducer2 } = yield Promise.resolve().then(() => (init_src(), src_exports));
-      const reducer = createStreamingReducer2(config);
-      yield query.forEach((row) => {
-        reducer.processRow(row);
+      const reducer = createStreamingReducer(config);
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        reducer.processRow(rowTransformer ? rowTransformer(row) : row);
       });
       return reducer.getResults();
     }
-    if (method === "count") {
-      const results2 = [];
-      yield query.forEach((row) => {
-        results2.push(extractCountValue(row));
-      });
-      return results2;
-    }
-    if (method === "groupBy" || method === "aggregate") {
-      const results2 = [];
-      yield query.forEach((row) => {
-        results2.push(transformAggregateRow(row));
-      });
-      return results2;
-    }
     const results = [];
-    yield query.forEach((row) => {
-      results.push(row);
+    yield client.unsafe(sql, normalizedParams).forEach((row) => {
+      results.push(rowTransformer ? rowTransformer(row) : row);
     });
     return results;
   });
 }
 function executeSqliteQuery(client, sql, params, method, requiresReduction, includeSpec, model, allModels) {
   const normalizedParams = normalizeParams(params);
-  const stmt = getOrPrepareStatement(client, sql);
-  if (shouldSqliteUseGet(method)) {
-    const row = stmt.get(...normalizedParams);
-    if (row === void 0) {
-      return method === "count" ? [0] : [];
-    }
-    if (method === "count") {
-      return [extractCountValue(row)];
-    }
-    if (method === "aggregate") {
-      return [transformAggregateRow(row)];
-    }
-    return [row];
-  }
-  const rows = stmt.all(...normalizedParams);
-  if (method === "count") {
-    if (rows.length === 0) return [0];
-    return [extractCountValue(rows[0])];
-  }
-  if (method === "groupBy" || method === "aggregate") {
-    return rows.map((row) => transformAggregateRow(row));
-  }
-  if (requiresReduction && includeSpec && model) {
+  const shouldTransform = method === "groupBy" || method === "aggregate" || method === "count";
+  if (requiresReduction && includeSpec) {
     const config = buildReducerConfig(model, includeSpec, allModels);
-    return reduceFlatRows(rows, config);
+    const stmt2 = getOrPrepareStatement(client, sql);
+    const useGet2 = shouldSqliteUseGet(method);
+    const rawResults2 = useGet2 ? stmt2.get(...normalizedParams) : stmt2.all(...normalizedParams);
+    const results2 = Array.isArray(rawResults2) ? rawResults2 : [rawResults2];
+    const transformed = shouldTransform ? results2.map(transformAggregateRow) : results2;
+    return reduceFlatRows(transformed, config);
   }
-  return rows;
+  const stmt = getOrPrepareStatement(client, sql);
+  const useGet = shouldSqliteUseGet(method);
+  const rawResults = useGet ? stmt.get(...normalizedParams) : stmt.all(...normalizedParams);
+  const results = Array.isArray(rawResults) ? rawResults : [rawResults];
+  return shouldTransform ? results.map(transformAggregateRow) : results;
 }
 function executeRaw(client, sql, params, dialect) {
   return __async(this, null, function* () {
@@ -8763,47 +8294,8 @@ function executeRaw(client, sql, params, dialect) {
     throw new Error("Raw execution for sqlite not supported in transactions");
   });
 }
-var SQLITE_STMT_CACHE;
-var init_generated_runtime = __esm({
-  "src/generated-runtime.ts"() {
-    init_src();
-    SQLITE_STMT_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  buildBatchCountSql: () => buildBatchCountSql,
-  buildBatchSql: () => buildBatchSql,
-  buildReducerConfig: () => buildReducerConfig,
-  buildSQL: () => buildSQL,
-  createPrismaSQL: () => createPrismaSQL,
-  createProgressiveReducer: () => createProgressiveReducer,
-  createStreamingReducer: () => createStreamingReducer,
-  createToSQL: () => createToSQL,
-  createTransactionExecutor: () => createTransactionExecutor,
-  executePostgresQuery: () => executePostgresQuery,
-  executeRaw: () => executeRaw,
-  executeSqliteQuery: () => executeSqliteQuery,
-  executeWhereInSegments: () => executeWhereInSegments,
-  executeWhereInSegmentsStreaming: () => executeWhereInSegmentsStreaming,
-  extractCountValue: () => extractCountValue,
-  generateAllSQL: () => generateAllSQL,
-  generateSQL: () => generateSQL2,
-  generateSQLByModel: () => generateSQLByModel,
-  getOrPrepareStatement: () => getOrPrepareStatement,
-  getRowTransformer: () => getRowTransformer,
-  normalizeParams: () => normalizeParams,
-  normalizeValue: () => normalizeValue,
-  parseBatchCountResults: () => parseBatchCountResults,
-  parseBatchResults: () => parseBatchResults,
-  planQueryStrategy: () => planQueryStrategy,
-  reduceFlatRows: () => reduceFlatRows,
-  shouldSqliteUseGet: () => shouldSqliteUseGet,
-  transformAggregateRow: () => transformAggregateRow,
-  transformQueryResults: () => transformQueryResults
-});
 function buildSQL(model, models, method, args, dialect) {
   return buildSQLWithCache(model, models, method, args, dialect);
 }
@@ -8905,27 +8397,6 @@ function generateSQLByModel(directives) {
   }
   return byModel;
 }
-var init_src = __esm({
-  "src/index.ts"() {
-    init_sql_builder_dialect();
-    init_sql_generator();
-    init_query_cache();
-    init_batch();
-    init_transaction();
-    init_result_transformers();
-    init_reducer();
-    init_segment_planner();
-    init_where_in_executor();
-    init_reducer();
-    init_normalize_value();
-    init_streaming_reducer();
-    init_streaming_progressive_reducer();
-    init_streaming_where_in_executor();
-    init_row_transformers();
-    init_generated_runtime();
-  }
-});
-init_src();
 
 exports.buildBatchCountSql = buildBatchCountSql;
 exports.buildBatchSql = buildBatchSql;