prisma-sql 1.66.1 → 1.68.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,164 @@ 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"
+]);
+var _a;
+var DEBUG_PARAMS = typeof process !== "undefined" && ((_a = process.env) == null ? void 0 : _a.DEBUG_PARAMS) === "1";
 
 // src/builder/shared/validators/type-guards.ts
 function isNotNullish(value) {
@@ -517,12 +494,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 +517,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 +551,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 +658,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 +687,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,25 +987,14 @@ 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;
 }
 function getFieldIndices(model) {
-  var _a;
+  var _a3;
   let cached = FIELD_INDICES_CACHE.get(model);
   if (cached) return cached;
   const scalarFields = /* @__PURE__ */ new Map();
@@ -1061,7 +1013,7 @@ function getFieldIndices(model) {
     } else {
       scalarFields.set(field.name, field);
       scalarNames.push(field.name);
-      const fieldType = String((_a = field.type) != null ? _a : "").toLowerCase();
+      const fieldType = String((_a3 = field.type) != null ? _a3 : "").toLowerCase();
       if (fieldType === "json") {
         jsonFields.add(field.name);
       }
@@ -1126,13 +1078,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,23 +1136,14 @@ 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;
+  var _a3, _b;
   if (!isNotNullish(v)) return void 0;
   if (schemaParser.isDynamicParameter(v)) return v;
   if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
     throw new Error(`${name} must be an integer`);
   }
-  const min = (_a = opts.min) != null ? _a : 0;
+  const min = (_a3 = opts.min) != null ? _a3 : 0;
   const allowZero = (_b = opts.allowZero) != null ? _b : true;
   if (!allowZero && v === 0) {
     throw new Error(`${name} must be > 0`);
@@ -1220,11 +1156,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 +1165,79 @@ function scopeName(scope, dynamicName) {
 function addAutoScoped(params, value, scope) {
   if (schemaParser.isDynamicParameter(value)) {
     const dn = schemaParser.extractDynamicName(value);
+    if (DEBUG_PARAMS) {
+      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 +1248,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 +1291,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 +1323,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 +1361,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 +1408,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 +1460,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, {
@@ -1699,7 +1608,7 @@ function assertCursorAndOrderFieldsScalar(model, cursor, orderEntries) {
   }
 }
 function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
-  var _a;
+  var _a3;
   assertSafeTableRef(tableName);
   assertSafeAlias(alias);
   const d = dialect != null ? dialect : getGlobalDialect();
@@ -1714,6 +1623,33 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
   }
   if (cursorEntries.length === 0)
     throw new Error("cursor must have at least one field with defined value");
+  const orderEntries = normalizeAndValidateOrderBy(
+    orderBy,
+    model,
+    parseOrderByValue
+  );
+  if (cursorEntries.length === 1 && orderEntries.length === 0) {
+    const [field, value] = cursorEntries[0];
+    const ph = addAutoScoped(params, value, `cursor.${field}`);
+    const c = col(alias, field, model);
+    return {
+      cte: "",
+      condition: `${c} >= ${ph}`
+    };
+  }
+  if (cursorEntries.length === 1 && orderEntries.length === 1) {
+    const [cursorField, cursorValue] = cursorEntries[0];
+    const orderEntry = orderEntries[0];
+    if (orderEntry.field === cursorField) {
+      const ph = addAutoScoped(params, cursorValue, `cursor.${cursorField}`);
+      const c = col(alias, cursorField, model);
+      const op = orderEntry.direction === "asc" ? ">=" : "<=";
+      return {
+        cte: "",
+        condition: `${c} ${op} ${ph}`
+      };
+    }
+  }
   const { cteName, srcAlias } = buildCursorNames(alias);
   assertSafeAlias(cteName);
   assertSafeAlias(srcAlias);
@@ -1722,49 +1658,52 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
     model,
     parseValue: parseOrderByValue
   });
-  let orderEntries = normalizeAndValidateOrderBy(
+  let finalOrderEntries = normalizeAndValidateOrderBy(
     orderBy,
     model,
     parseOrderByValue
   );
-  if (orderEntries.length === 0) {
-    orderEntries = cursorEntries.map(([field]) => ({
+  if (finalOrderEntries.length === 0) {
+    finalOrderEntries = cursorEntries.map(([field]) => ({
       field,
       direction: "asc"
     }));
   } else {
-    orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
+    finalOrderEntries = ensureCursorFieldsInOrder(
+      finalOrderEntries,
+      cursorEntries
+    );
   }
-  assertCursorAndOrderFieldsScalar(model, cursor, orderEntries);
+  assertCursorAndOrderFieldsScalar(model, cursor, finalOrderEntries);
   const { whereSql: cursorWhereSql } = buildCursorFilterParts(
     cursor,
     srcAlias,
     params,
     model
   );
-  const cursorOrderBy = orderEntries.map(
+  const cursorOrderBy = finalOrderEntries.map(
     (e) => srcAlias + "." + quoteColumn(model, e.field) + " " + e.direction.toUpperCase()
   ).join(", ");
   const selectList = buildCursorCteSelectList(
     cursorEntries,
-    orderEntries,
+    finalOrderEntries,
     model
   );
   const cte = cteName + " AS (\n    SELECT " + selectList + " FROM " + tableName + " " + srcAlias + "\n    WHERE " + cursorWhereSql + "\n    ORDER BY " + cursorOrderBy + "\n    LIMIT 1\n  )";
   const existsExpr = "EXISTS (SELECT 1 FROM " + cteName + ")";
   const orClauses = [];
-  for (let level = 0; level < orderEntries.length; level++) {
+  for (let level = 0; level < finalOrderEntries.length; level++) {
     const andParts = [];
     for (let i = 0; i < level; i++) {
-      const e2 = orderEntries[i];
+      const e2 = finalOrderEntries[i];
       const c2 = col(alias, e2.field, model);
       const cursorField2 = cteName + "." + quoteColumn(model, e2.field);
       andParts.push(buildCursorEqualityExpr(c2, cursorField2));
     }
-    const e = orderEntries[level];
+    const e = finalOrderEntries[level];
     const c = col(alias, e.field, model);
     const cursorField = cteName + "." + quoteColumn(model, e.field);
-    const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
+    const nulls = (_a3 = e.nulls) != null ? _a3 : defaultNullsFor(d, e.direction);
     andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, cursorField));
     orClauses.push("(" + andParts.join(SQL_SEPARATORS.CONDITION_AND) + ")");
   }
@@ -1837,23 +1776,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 +1793,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 +1816,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 +1994,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 +2125,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 +2246,19 @@ 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 = [];
+var SCHEMA_MAP_CACHE = /* @__PURE__ */ new WeakMap();
+function getSchemaByName(schemas) {
+  let map = SCHEMA_MAP_CACHE.get(schemas);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    for (const m of schemas) map.set(m.name, m);
+    SCHEMA_MAP_CACHE.set(schemas, map);
+  }
+  return map;
+}
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
@@ -2395,21 +2289,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 +2308,6 @@ function buildListRelationFilters(args) {
     fieldName,
     value,
     ctx,
-    whereBuilder,
     relModel,
     relTable,
     relAlias,
@@ -2437,23 +2315,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 = [
     {
@@ -2586,7 +2458,8 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
       modelName: ctx.model.name
     });
   }
-  const relModel = ctx.schemaModels.find((m) => m.name === field.relatedModel);
+  const schemaMap = getSchemaByName(ctx.schemaModels);
+  const relModel = schemaMap.get(field.relatedModel);
   if (!isNotNullish(relModel)) {
     throw createError(
       `Related model '${field.relatedModel}' not found in schema. Available models: ${ctx.schemaModels.map((m) => m.name).join(", ")}`,
@@ -2625,18 +2498,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 +2512,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 +2597,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 +2733,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 +2789,9 @@ 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;
+var _a2;
+var IS_PRODUCTION2 = typeof process !== "undefined" && ((_a2 = process.env) == null ? void 0 : _a2.NODE_ENV) === "production";
 function assertSameLength(params, mappings) {
   if (params.length !== mappings.length) {
     throw new Error(
@@ -3021,6 +2851,11 @@ function validateMappings(mappings) {
   }
 }
 function validateState(params, mappings, index) {
+  if (IS_PRODUCTION2) {
+    assertSameLength(params, mappings);
+    assertValidNextIndex(index);
+    return;
+  }
   assertSameLength(params, mappings);
   assertValidNextIndex(index);
   if (mappings.length === 0) return;
@@ -3043,6 +2878,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 +2995,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 +3007,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;
+  var _a3, _b, _c, _d, _e;
   assertSafeAlias(options.alias);
   const dialect = options.dialect || getGlobalDialect();
-  const params = (_a = options.params) != null ? _a : createParamStore();
+  const params = (_a3 = options.params) != null ? _a3 : createParamStore(1, dialect);
   const ctx = {
     alias: options.alias,
     model: options.model,
@@ -3207,21 +3030,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;
@@ -3257,8 +3072,8 @@ function buildDefaultScalarFields(model, alias) {
   return out;
 }
 function getDefaultSelectCached(model, alias) {
-  var _a;
-  return (_a = DEFAULT_SELECT_CACHE.get(model)) == null ? void 0 : _a.get(alias);
+  var _a3;
+  return (_a3 = DEFAULT_SELECT_CACHE.get(model)) == null ? void 0 : _a3.get(alias);
 }
 function cacheDefaultSelect(model, alias, sql) {
   let cache = DEFAULT_SELECT_CACHE.get(model);
@@ -3343,7 +3158,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,19 +3168,10 @@ 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") {
+var RELATION_KEYS_CACHE = /* @__PURE__ */ new WeakMap();
+function computeRelationKeys(field, context) {
   const fkFields = normalizeKeyList(field.foreignKey);
   if (fkFields.length === 0) {
     throw new Error(
@@ -3383,11 +3189,13 @@ 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();
-  }
-});
+function resolveRelationKeys(field, context = "include") {
+  let cached = RELATION_KEYS_CACHE.get(field);
+  if (cached) return cached;
+  cached = computeRelationKeys(field, context);
+  RELATION_KEYS_CACHE.set(field, cached);
+  return cached;
+}
 
 // src/builder/shared/relation-extraction-utils.ts
 function extractRelationEntries(args, model) {
@@ -3412,12 +3220,23 @@ 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;
+var FIELD_BY_NAME_CACHE2 = /* @__PURE__ */ new WeakMap();
+function getFieldMap(model) {
+  let map = FIELD_BY_NAME_CACHE2.get(model);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    for (const f of model.fields) {
+      map.set(f.name, f);
+    }
+    FIELD_BY_NAME_CACHE2.set(model, map);
+  }
+  return map;
+}
 function buildIncludeScope(includePath) {
   if (includePath.length === 0) return "include";
   let scope = "include";
@@ -3437,7 +3256,8 @@ function getRelationTableReference(relModel, dialect) {
   );
 }
 function resolveRelationOrThrow(model, schemaByName, relName) {
-  const field = model.fields.find((f) => f.name === relName);
+  const fieldMap = getFieldMap(model);
+  const field = fieldMap.get(relName);
   if (!isNotNullish(field)) {
     throw new Error(
       `Unknown relation '${relName}' on model ${model.name}. Available relation fields: ${model.fields.filter((f) => f.isRelation).map((f) => f.name).join(", ")}`
@@ -3554,11 +3374,22 @@ function finalizeOrderByForInclude(args) {
 }
 function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
   let relSelect = buildRelationSelect(relArgs, relModel, relAlias);
-  const nestedIncludes = isPlainObject(relArgs) ? buildIncludeSqlInternal(relArgs, __spreadProps(__spreadValues({}, ctx), {
-    model: relModel,
-    parentAlias: relAlias,
-    depth: ctx.depth + 1
-  })) : [];
+  let nestedIncludes = [];
+  if (isPlainObject(relArgs)) {
+    const prevModel = ctx.model;
+    const prevParentAlias = ctx.parentAlias;
+    const prevDepth = ctx.depth;
+    ctx.model = relModel;
+    ctx.parentAlias = relAlias;
+    ctx.depth = prevDepth + 1;
+    try {
+      nestedIncludes = buildIncludeSqlInternal(relArgs, ctx);
+    } finally {
+      ctx.model = prevModel;
+      ctx.parentAlias = prevParentAlias;
+      ctx.depth = prevDepth;
+    }
+  }
   if (isNonEmptyArray(nestedIncludes)) {
     const emptyJson = ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
     const nestedSelects = nestedIncludes.map(
@@ -3702,9 +3533,9 @@ function hasNestedRelationInArgs(relArgs, relModel) {
   if (checkSource(relArgs.select)) return true;
   return false;
 }
-function canUseJoinInclude(dialect, isList2, takeVal, skipVal, depth, outerHasLimit, hasNestedIncludes2) {
+function canUseJoinInclude(dialect, isList, takeVal, skipVal, depth, outerHasLimit, hasNestedIncludes2) {
   if (dialect !== "postgres") return false;
-  if (!isList2) return false;
+  if (!isList) return false;
   if (depth > 0) return false;
   if (outerHasLimit) return false;
   if (hasNestedIncludes2) return false;
@@ -3799,7 +3630,7 @@ function buildJoinBasedPaginated(args) {
 function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const relTable = getRelationTableReference(relModel, ctx.dialect);
   const relAlias = ctx.aliasGen.next(relName);
-  const isList2 = typeof field.type === "string" && field.type.endsWith("[]");
+  const isList = typeof field.type === "string" && field.type.endsWith("[]");
   const joinPredicate = joinCondition(
     field,
     ctx.model,
@@ -3816,7 +3647,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   );
   const whereParts = buildWhereParts(whereInput, relModel, relAlias, ctx);
   const paginationConfig = extractRelationPaginationConfig(relArgs);
-  if (!isList2 && typeof paginationConfig.takeVal === "number" && paginationConfig.takeVal < 0) {
+  if (!isList && typeof paginationConfig.takeVal === "number" && paginationConfig.takeVal < 0) {
     throw new Error("Negative take is only supported for list relations");
   }
   const adjusted = maybeReverseNegativeTake(
@@ -3837,7 +3668,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     ctx.dialect,
     relModel
   );
-  if (!isList2) {
+  if (!isList) {
     const sql = buildOneToOneIncludeSql({
       relTable,
       relAlias,
@@ -3857,7 +3688,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const nestedIncludes = hasNestedRelationInArgs(relArgs, relModel);
   if (canUseJoinInclude(
     ctx.dialect,
-    isList2,
+    isList,
     adjusted.takeVal,
     paginationConfig.skipVal,
     depth,
@@ -3955,16 +3786,22 @@ function buildIncludeSqlInternal(args, ctx) {
         `Circular include detected: ${Array.from(ctx.visitSet).join(" -> ")} -> ${relationPath}. Relation '${relationPath}' creates an infinite loop.`
       );
     }
-    const nextIncludePath = [...ctx.includePath, relName];
-    const nextVisitSet = new Set(ctx.visitSet);
-    nextVisitSet.add(relationPath);
-    includes.push(
-      buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, __spreadProps(__spreadValues({}, ctx), {
-        includePath: nextIncludePath,
-        visitSet: nextVisitSet,
-        depth
-      }))
-    );
+    ctx.includePath.push(relName);
+    ctx.visitSet.add(relationPath);
+    try {
+      includes.push(
+        buildSingleInclude(
+          relName,
+          relArgs,
+          resolved.field,
+          resolved.relModel,
+          ctx
+        )
+      );
+    } finally {
+      ctx.includePath.pop();
+      ctx.visitSet.delete(relationPath);
+    }
   }
   return includes;
 }
@@ -4102,30 +3939,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 +3951,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 +4012,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() {
@@ -4282,10 +4085,19 @@ function canUseNestedFlatJoin(relArgs, depth) {
   }
   return true;
 }
-function canUseFlatJoinForAll(includeSpec) {
-  for (const value of Object.values(includeSpec)) {
+function canUseFlatJoinForAll(includeSpec, parentModel, schemas) {
+  const modelMap = new Map(schemas.map((m) => [m.name, m]));
+  for (const [relName, value] of Object.entries(includeSpec)) {
     if (value === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!field || !field.isRelation) continue;
     if (!canUseNestedFlatJoin(value, 0)) return false;
+    const relModel = modelMap.get(field.relatedModel);
+    if (!relModel) continue;
+    const nestedSpec = extractNestedIncludeSpec(value, relModel);
+    if (Object.keys(nestedSpec).length > 0) {
+      if (!canUseFlatJoinForAll(nestedSpec, relModel, schemas)) return false;
+    }
   }
   return true;
 }
@@ -4382,7 +4194,7 @@ function buildFlatJoinSql(spec) {
   if (Object.keys(includeSpec).length === 0) {
     return { sql: "", requiresReduction: false, includeSpec: {} };
   }
-  if (!canUseFlatJoinForAll(includeSpec)) {
+  if (!canUseFlatJoinForAll(includeSpec, model, schemas)) {
     return { sql: "", requiresReduction: false, includeSpec: {} };
   }
   const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
@@ -4428,48 +4240,247 @@ 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();
+
+// src/builder/select/array-agg.ts
+function canUseArrayAggForAll(includeSpec, parentModel, schemas) {
+  const modelMap = new Map(schemas.map((m) => [m.name, m]));
+  for (const [relName, value] of Object.entries(includeSpec)) {
+    if (value === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!field || !field.isRelation) continue;
+    if (isPlainObject(value) && hasChildPagination(value)) return false;
+    const relModel = modelMap.get(field.relatedModel);
+    if (!relModel) continue;
+    const nestedSpec = extractNestedIncludeSpec(value, relModel);
+    if (Object.keys(nestedSpec).length > 0) return false;
   }
-});
-function buildWhereSql(conditions) {
-  if (!isNonEmptyArray(conditions)) return "";
-  return " " + SQL_TEMPLATES.WHERE + " " + conditions.join(SQL_SEPARATORS.CONDITION_AND);
+  return true;
 }
-function buildJoinsSql(...joinGroups) {
-  const all = [];
-  for (const g of joinGroups) {
-    if (isNonEmptyArray(g)) {
-      for (const j of g) all.push(j);
-    }
+function getRelationModel2(parentModel, relationName, schemas) {
+  const field = parentModel.fields.find((f) => f.name === relationName);
+  if (!(field == null ? void 0 : field.isRelation) || !field.relatedModel) {
+    throw new Error(`Invalid relation ${relationName} on ${parentModel.name}`);
   }
-  return all.length > 0 ? " " + all.join(" ") : "";
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!relModel) {
+    throw new Error(`Related model ${field.relatedModel} not found`);
+  }
+  return relModel;
 }
-function buildSelectList(baseSelect, extraCols) {
-  const base = baseSelect.trim();
-  const extra = extraCols.trim();
-  if (!base) return extra;
-  if (!extra) return base;
-  return base + SQL_SEPARATORS.FIELD_LIST + extra;
+function buildSubqueryRawSelect2(model, alias) {
+  const cols = [];
+  for (const f of model.fields) {
+    if (f.isRelation) continue;
+    cols.push(`${alias}.${quoteColumn(model, f.name)}`);
+  }
+  return cols.length > 0 ? cols.join(SQL_SEPARATORS.FIELD_LIST) : "*";
 }
-function finalizeSql(sql, params, dialect) {
-  const snapshot = params.snapshot();
-  validateSelectQuery(sql);
-  validateParamConsistencyByDialect(sql, snapshot.params, dialect);
-  return {
-    sql,
-    params: [...snapshot.params],
-    paramMappings: [...snapshot.mappings]
-  };
+function readWhereInput2(relArgs) {
+  if (!isPlainObject(relArgs)) return {};
+  const obj = relArgs;
+  if (!("where" in obj)) return {};
+  const w = obj.where;
+  return isPlainObject(w) ? w : {};
+}
+function buildArrayAggRelation(args) {
+  const {
+    relationName,
+    relArgs,
+    field,
+    relModel,
+    parentModel,
+    parentAlias,
+    schemas,
+    dialect,
+    aliasCounter,
+    params
+  } = args;
+  const isList = typeof field.type === "string" && field.type.endsWith("[]");
+  const { childKeys: relKeyFields, parentKeys: parentKeyFields } = resolveRelationKeys(field, "include");
+  if (relKeyFields.length === 0) return null;
+  const innerAlias = `__aa_r${aliasCounter.count++}`;
+  const joinAlias = `__aa_j${aliasCounter.count++}`;
+  const indices = getFieldIndices(relModel);
+  const scalarSel = extractScalarSelection(relArgs, relModel);
+  const pkFields = getPrimaryKeyFields(relModel);
+  const selectedFields = scalarSel.includeAllScalars ? Array.from(indices.scalarFields.keys()) : [.../* @__PURE__ */ new Set([...pkFields, ...scalarSel.selectedScalarFields])];
+  const pkOrderExpr = pkFields.map((f) => `${innerAlias}.${quoteColumn(relModel, f)}`).join(SQL_SEPARATORS.FIELD_LIST);
+  const pkFilterExpr = `${innerAlias}.${quoteColumn(relModel, pkFields[0])}`;
+  const fkSelectParts = relKeyFields.map(
+    (f, i) => `${innerAlias}.${quoteColumn(relModel, f)} AS "__fk${i}"`
+  );
+  const aggParts = selectedFields.map((fieldName) => {
+    const f = indices.scalarFields.get(fieldName);
+    if (!f) return null;
+    const colRef = `${innerAlias}.${quoteColumn(relModel, fieldName)}`;
+    const alias = `"${relationName}.${f.name}"`;
+    return `array_agg(${colRef} ORDER BY ${pkOrderExpr}) FILTER (WHERE ${pkFilterExpr} IS NOT NULL) AS ${alias}`;
+  }).filter(Boolean);
+  const fkGroupByParts = relKeyFields.map(
+    (f) => `${innerAlias}.${quoteColumn(relModel, f)}`
+  );
+  const relTable = buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    relModel.tableName,
+    dialect
+  );
+  const whereInput = readWhereInput2(relArgs);
+  let whereJoinsSql = "";
+  let whereClauseSql = "";
+  if (Object.keys(whereInput).length > 0) {
+    const aliasGen = createAliasGenerator();
+    const whereResult = buildWhereClause(whereInput, {
+      alias: innerAlias,
+      schemaModels: schemas,
+      model: relModel,
+      params,
+      isSubquery: true,
+      aliasGen,
+      dialect
+    });
+    if (whereResult.joins.length > 0) {
+      whereJoinsSql = " " + whereResult.joins.join(" ");
+    }
+    if (isValidWhereClause(whereResult.clause)) {
+      whereClauseSql = ` ${SQL_TEMPLATES.WHERE} ${whereResult.clause}`;
+    }
+  }
+  const subquery = `SELECT ${fkSelectParts.join(SQL_SEPARATORS.FIELD_LIST)}${SQL_SEPARATORS.FIELD_LIST}${aggParts.join(SQL_SEPARATORS.FIELD_LIST)} FROM ${relTable} ${innerAlias}${whereJoinsSql}${whereClauseSql} GROUP BY ${fkGroupByParts.join(SQL_SEPARATORS.FIELD_LIST)}`;
+  const onParts = parentKeyFields.map(
+    (f, i) => `${joinAlias}."__fk${i}" = ${parentAlias}.${quoteColumn(parentModel, f)}`
+  );
+  const onCondition = onParts.length === 1 ? onParts[0] : `(${onParts.join(" AND ")})`;
+  const joinSql = `LEFT JOIN (${subquery}) ${joinAlias} ON ${onCondition}`;
+  const selectExprs = selectedFields.map((fieldName) => {
+    const f = indices.scalarFields.get(fieldName);
+    if (!f) return null;
+    return `${joinAlias}."${relationName}.${f.name}"`;
+  }).filter(Boolean);
+  return {
+    joinSql,
+    selectExprs,
+    relationName,
+    isList,
+    scalarFieldNames: selectedFields
+  };
+}
+function buildArrayAggSql(spec) {
+  const {
+    select,
+    from,
+    whereClause,
+    whereJoins,
+    orderBy,
+    dialect,
+    model,
+    schemas,
+    args,
+    params
+  } = spec;
+  const entries = extractRelationEntries(args, model);
+  const includeSpec = {};
+  for (const e of entries) {
+    includeSpec[e.name] = e.value;
+  }
+  if (Object.keys(includeSpec).length === 0) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  if (!canUseArrayAggForAll(includeSpec, model, schemas)) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
+  const baseWhere = whereClause && whereClause !== "1=1" ? `WHERE ${whereClause}` : "";
+  const baseOrderBy = orderBy ? `ORDER BY ${orderBy}` : "";
+  const subqueryScalarCols = buildSubqueryRawSelect2(model, from.alias);
+  let baseSubquery = `SELECT ${subqueryScalarCols} FROM ${from.table} ${from.alias}` + (baseJoins ? ` ${baseJoins}` : "") + (baseWhere ? ` ${baseWhere}` : "") + (baseOrderBy ? ` ${baseOrderBy}` : "");
+  baseSubquery = appendPagination(baseSubquery.trim(), spec);
+  const aliasCounter = { count: 0 };
+  const joins = [];
+  const arraySelectExprs = [];
+  for (const [relName, relValue] of Object.entries(includeSpec)) {
+    if (relValue === false) continue;
+    const field = model.fields.find((f) => f.name === relName);
+    if (!field || !isValidRelationField(field)) continue;
+    const relModel = getRelationModel2(model, relName, schemas);
+    const built = buildArrayAggRelation({
+      relationName: relName,
+      relArgs: relValue,
+      field,
+      relModel,
+      parentModel: model,
+      parentAlias: from.alias,
+      schemas,
+      dialect,
+      aliasCounter,
+      params
+    });
+    if (!built) continue;
+    joins.push(built.joinSql);
+    arraySelectExprs.push(...built.selectExprs);
+  }
+  if (joins.length === 0) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  const baseSelect = (select != null ? select : "").trim();
+  const allSelects = [baseSelect, ...arraySelectExprs].filter((s) => s && s.trim().length > 0).join(SQL_SEPARATORS.FIELD_LIST);
+  if (!allSelects) {
+    throw new Error("Array-agg SELECT requires at least one selected field");
+  }
+  const pkField = getPrimaryKeyField(model);
+  const pkOrder = `${from.alias}.${quoteColumn(model, pkField)} ASC`;
+  const sql = `
+    SELECT ${allSelects}
+    FROM (${baseSubquery}) ${from.alias}
+    ${joins.join(" ")}
+    ORDER BY ${pkOrder}
+  `.trim();
+  return { sql, requiresReduction: true, includeSpec, isArrayAgg: true };
+}
+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);
+}
+function buildJoinsSql(...joinGroups) {
+  const all = [];
+  for (const g of joinGroups) {
+    if (isNonEmptyArray(g)) {
+      for (const j of g) all.push(j);
+    }
+  }
+  return all.length > 0 ? " " + all.join(" ") : "";
+}
+function buildSelectList(baseSelect, extraCols) {
+  const base = baseSelect.trim();
+  const extra = extraCols.trim();
+  if (!base) return extra;
+  if (!extra) return base;
+  return base + SQL_SEPARATORS.FIELD_LIST + extra;
+}
+function finalizeSql(sql, params, dialect) {
+  const snapshot = params.snapshot();
+  validateSelectQuery(sql);
+  validateParamConsistencyByDialect(sql, snapshot.params, dialect);
+  return {
+    sql,
+    params: [...snapshot.params],
+    paramMappings: [...snapshot.mappings]
+  };
 }
 function unquoteIdent(s) {
   if (s.startsWith('"') && s.endsWith('"')) {
@@ -4527,47 +4538,45 @@ function buildOutputColumns(scalarNames, includeNames, hasCount) {
   }
   return formatted;
 }
-function buildWindowOrder(args) {
-  const { baseOrder, idField, fromAlias, model } = args;
-  const fromLower = String(fromAlias).toLowerCase();
-  const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase().replace(/\s+/g, " "));
-  const hasIdInOrder = orderFields.some((f) => {
-    return f.includes(`${fromLower}.id`) || f.includes(`${fromLower}."id"`);
-  });
-  if (hasIdInOrder) return baseOrder;
-  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 });
-          continue;
-        }
-        const obj = value;
-        entries.push({ field, direction: obj.direction, nulls: obj.nulls });
+function getOrderByEntries(spec) {
+  if (!isNotNullish(spec.args.orderBy)) return [];
+  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 });
+        continue;
       }
+      const obj = value;
+      entries.push({ field, direction: obj.direction, 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 entries;
+}
+function renderOrderBySql(entries, alias, dialect, model) {
+  if (entries.length === 0) return "";
+  const out = [];
+  for (const e of entries) {
+    const dir = e.direction.toUpperCase();
+    const c = col(alias, e.field, model);
+    if (dialect === "postgres") {
+      const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
+      out.push(c + " " + dir + nulls);
+    } else if (isNotNullish(e.nulls)) {
+      const isNullExpr = `(${c} IS NULL)`;
+      const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
+      out.push(isNullExpr + " " + nullRankDir);
+      out.push(c + " " + dir);
+    } else {
+      out.push(c + " " + dir);
+    }
   }
-  return [];
+  return out.join(SQL_SEPARATORS.ORDER_BY);
 }
-function buildFieldNameOrderBy(entries, alias) {
+function renderOrderBySimple(entries, alias) {
   if (entries.length === 0) return "";
   const out = [];
   for (const e of entries) {
@@ -4578,40 +4587,73 @@ function buildFieldNameOrderBy(entries, alias) {
       const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
       out.push(isNullExpr + " " + nullRankDir);
       out.push(c + " " + dir);
-      continue;
+    } else {
+      out.push(c + " " + dir);
     }
-    out.push(c + " " + dir);
   }
   return out.join(SQL_SEPARATORS.ORDER_BY);
 }
+function ensureIdTiebreakerEntries(entries, model) {
+  var _a3, _b;
+  const idField = (_b = (_a3 = model == null ? void 0 : model.fields) == null ? void 0 : _a3.find) == null ? void 0 : _b.call(
+    _a3,
+    (f) => f.name === "id" && !f.isRelation
+  );
+  if (!idField) return entries;
+  if (entries.some((e) => e.field === "id")) return entries;
+  return [...entries, { field: "id", direction: "asc" }];
+}
+function ensurePostgresDistinctOrderEntries(args) {
+  const { entries, distinct, model } = args;
+  const distinctEntries = [...distinct].map((f) => ({
+    field: f,
+    direction: "asc"
+  }));
+  const canKeepAsIs = entries.length >= distinctEntries.length && distinctEntries.every((de, i) => entries[i].field === de.field);
+  const merged = canKeepAsIs ? entries : [...distinctEntries, ...entries];
+  return ensureIdTiebreakerEntries(merged, model);
+}
+function extractDistinctOrderEntries(spec) {
+  const entries = getOrderByEntries(spec);
+  if (entries.length > 0) return entries;
+  if (isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct)) {
+    return [...spec.distinct].map((f) => ({
+      field: f,
+      direction: "asc"
+    }));
+  }
+  return [];
+}
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
-  var _a, _b;
-  const { includes, from, whereClause, whereJoins, orderBy, distinct, model } = spec;
+  var _a3, _b;
+  const { includes, from, whereClause, whereJoins, distinct, model } = spec;
   if (!isNotNullish(distinct) || !isNonEmptyArray(distinct)) {
     throw new Error("buildSqliteDistinctQuery requires distinct fields");
   }
   const scalarNames = parseSimpleScalarSelect(spec.select, from.alias);
   const includeNames = includes.map((i) => i.name);
-  const hasCount = Boolean((_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count);
+  const hasCount = Boolean((_b = (_a3 = spec.args) == null ? void 0 : _a3.select) == null ? void 0 : _b._count);
   const outerSelectCols = buildOutputColumns(
     scalarNames,
     includeNames,
     hasCount
   );
   const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
-  const fallbackOrder = [...distinct].map((f) => col(from.alias, f, model) + " ASC").join(SQL_SEPARATORS.FIELD_LIST);
-  const idField = model.fields.find(
-    (f) => f.name === "id" && !f.isRelation
-  );
-  const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
-  const windowOrder = buildWindowOrder({
-    baseOrder,
-    idField,
-    fromAlias: from.alias,
+  const baseEntries = getOrderByEntries(spec);
+  const fallbackEntries = [...distinct].map((f) => ({
+    field: f,
+    direction: "asc"
+  }));
+  const resolvedEntries = baseEntries.length > 0 ? baseEntries : fallbackEntries;
+  const windowEntries = ensureIdTiebreakerEntries(resolvedEntries, model);
+  const windowOrder = renderOrderBySql(
+    windowEntries,
+    from.alias,
+    "sqlite",
     model
-  });
+  );
   const outerEntries = extractDistinctOrderEntries(spec);
-  const outerOrder = buildFieldNameOrderBy(outerEntries, '"__tp_distinct"');
+  const outerOrder = renderOrderBySimple(outerEntries, '"__tp_distinct"');
   const joins = buildJoinsSql(whereJoins, countJoins);
   const conditions = [];
   if (whereClause && whereClause !== "1=1") conditions.push(whereClause);
@@ -4662,12 +4704,12 @@ function resolveCountSelect(countSelectRaw, model) {
   return null;
 }
 function buildIncludeColumns(spec) {
-  var _a, _b;
+  var _a3, _b;
   const { select, includes, dialect, model, schemas, from, params } = spec;
   const baseSelect = (select != null ? select : "").trim();
   let countCols = "";
   let countJoins = [];
-  const countSelectRaw = (_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count;
+  const countSelectRaw = (_b = (_a3 = spec.args) == null ? void 0 : _a3.select) == null ? void 0 : _b._count;
   if (countSelectRaw) {
     const resolvedCountSelect = resolveCountSelect(countSelectRaw, model);
     if (resolvedCountSelect && Object.keys(resolvedCountSelect).length > 0) {
@@ -4826,37 +4868,6 @@ function extractIncludeSpec(args) {
 function hasNestedIncludes(includeSpec) {
   return Object.keys(includeSpec).length > 0;
 }
-function splitOrderByTerms(orderBy) {
-  const raw = orderBy.trim();
-  if (raw.length === 0) return [];
-  return raw.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function hasIdInOrderBy(orderBy, fromAlias) {
-  const lower = orderBy.toLowerCase();
-  const aliasLower = fromAlias.toLowerCase();
-  return lower.includes(`${aliasLower}.id `) || lower.includes(`${aliasLower}."id"`);
-}
-function ensureIdTiebreakerOrderBy(orderBy, fromAlias, model) {
-  var _a, _b;
-  const idField = (_b = (_a = model == null ? void 0 : model.fields) == null ? void 0 : _a.find) == null ? void 0 : _b.call(
-    _a,
-    (f) => f.name === "id" && !f.isRelation
-  );
-  if (!idField) return orderBy;
-  if (hasIdInOrderBy(orderBy, fromAlias)) return orderBy;
-  const t = col(fromAlias, "id", model) + " ASC";
-  return isNonEmptyString(orderBy) ? orderBy + ", " + t : t;
-}
-function ensurePostgresDistinctOrderBy(args) {
-  const { orderBy, distinct, fromAlias, model } = args;
-  const distinctTerms = distinct.map((f) => col(fromAlias, f, model) + " ASC");
-  const existing = splitOrderByTerms(orderBy);
-  const canKeepAsIs = existing.length >= distinctTerms.length && distinctTerms.every(
-    (term, i) => existing[i].toLowerCase().startsWith(term.split(" ASC")[0].toLowerCase())
-  );
-  const merged = canKeepAsIs ? orderBy : [...distinctTerms, ...existing].join(SQL_SEPARATORS.ORDER_BY);
-  return ensureIdTiebreakerOrderBy(merged, fromAlias, model);
-}
 function constructFinalSql(spec) {
   const {
     select,
@@ -4871,7 +4882,6 @@ function constructFinalSql(spec) {
     params,
     dialect,
     model,
-    includes,
     schemas,
     pagination,
     args
@@ -4883,7 +4893,24 @@ function constructFinalSql(spec) {
   const includeSpec = extractIncludeSpec(args);
   const hasIncludes = hasNestedIncludes(includeSpec);
   const hasPagination = isNotNullish(pagination.take);
-  const shouldUseFlatJoin = dialect === "postgres" && hasPagination && hasIncludes && canUseFlatJoinForAll(includeSpec);
+  const takeValue = typeof pagination.take === "number" ? pagination.take : null;
+  const isLargeTake = takeValue !== null && takeValue > 50;
+  const shouldUseArrayAgg = dialect === "postgres" && hasIncludes && method === "findMany" && hasPagination && isLargeTake && canUseArrayAggForAll(includeSpec, model, schemas);
+  if (shouldUseArrayAgg) {
+    const aaResult = buildArrayAggSql(spec);
+    if (aaResult.sql) {
+      const baseSqlResult = finalizeSql(aaResult.sql, params, dialect);
+      return {
+        sql: baseSqlResult.sql,
+        params: baseSqlResult.params,
+        paramMappings: baseSqlResult.paramMappings,
+        requiresReduction: true,
+        includeSpec: aaResult.includeSpec,
+        isArrayAgg: true
+      };
+    }
+  }
+  const shouldUseFlatJoin = dialect === "postgres" && hasPagination && hasIncludes && canUseFlatJoinForAll(includeSpec, model, schemas);
   if (shouldUseFlatJoin) {
     const flatResult = buildFlatJoinSql(spec);
     if (flatResult.sql) {
@@ -4929,12 +4956,13 @@ function constructFinalSql(spec) {
   pushWhere(parts, conditions);
   let finalOrderBy = orderBy;
   if (dialect === "postgres" && isNonEmptyArray(distinct)) {
-    finalOrderBy = ensurePostgresDistinctOrderBy({
-      orderBy: orderBy || "",
+    const currentEntries = getOrderByEntries(spec);
+    const mergedEntries = ensurePostgresDistinctOrderEntries({
+      entries: currentEntries.length > 0 ? currentEntries : [],
       distinct: [...distinct],
-      fromAlias: from.alias,
       model
     });
+    finalOrderBy = renderOrderBySql(mergedEntries, from.alias, dialect, model);
   }
   if (isNonEmptyString(finalOrderBy))
     parts.push(SQL_TEMPLATES.ORDER_BY, finalOrderBy);
@@ -4942,24 +4970,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) {
@@ -4978,11 +4988,11 @@ function mapFirstOrderByByField(existing) {
   return m;
 }
 function buildPostgresDistinctOrderBy(distinctFields, existing) {
-  var _a;
+  var _a3;
   const firstByField = mapFirstOrderByByField(existing);
   const next = [];
   for (const f of distinctFields) {
-    next.push((_a = firstByField.get(f)) != null ? _a : { [f]: "asc" });
+    next.push((_a3 = firstByField.get(f)) != null ? _a3 : { [f]: "asc" });
   }
   const distinctSet = new Set(distinctFields);
   for (const obj of existing) {
@@ -5237,23 +5247,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 +5262,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 +5803,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, "_");
@@ -5848,10 +5818,10 @@ function isPrismaMethod(v) {
   return v === "findMany" || v === "findFirst" || v === "findUnique" || v === "aggregate" || v === "groupBy" || v === "count";
 }
 function resolveMethod(directive) {
-  var _a, _b;
+  var _a3, _b;
   const m = directive == null ? void 0 : directive.method;
   if (isPrismaMethod(m)) return m;
-  const pm = (_b = (_a = directive == null ? void 0 : directive.query) == null ? void 0 : _a.processed) == null ? void 0 : _b.method;
+  const pm = (_b = (_a3 = directive == null ? void 0 : directive.query) == null ? void 0 : _a3.processed) == null ? void 0 : _b.method;
   if (isPrismaMethod(pm)) return pm;
   return "findMany";
 }
@@ -6012,7 +5982,7 @@ function extractIncludeSpec2(processed, modelDef) {
   return includeSpec;
 }
 function buildAndNormalizeSql(args) {
-  var _a;
+  var _a3;
   const {
     method,
     processed,
@@ -6038,13 +6008,15 @@ function buildAndNormalizeSql(args) {
     sqlResult.paramMappings,
     dialect
   );
-  const includeSpec = (_a = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a : extractIncludeSpec2(processed, modelDef);
+  const includeSpec = (_a3 = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a3 : extractIncludeSpec2(processed, modelDef);
   const requiresReduction = sqlResult.requiresReduction === true;
+  const isArrayAgg = sqlResult.isArrayAgg === true;
   return {
     sql: normalized.sql,
     paramMappings: normalized.paramMappings,
     requiresReduction,
-    includeSpec
+    includeSpec,
+    isArrayAgg
   };
 }
 function finalizeDirective(args) {
@@ -6055,11 +6027,12 @@ function finalizeDirective(args) {
     normalizedMappings,
     dialect,
     requiresReduction,
-    includeSpec
+    includeSpec,
+    isArrayAgg
   } = args;
   const params = normalizedMappings.map((m) => {
-    var _a;
-    return (_a = m.value) != null ? _a : void 0;
+    var _a3;
+    return (_a3 = m.value) != null ? _a3 : void 0;
   });
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
   const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
@@ -6072,6 +6045,7 @@ function finalizeDirective(args) {
     paramMappings: normalizedMappings,
     requiresReduction,
     includeSpec,
+    isArrayAgg,
     originalDirective: directive
   };
 }
@@ -6105,22 +6079,10 @@ function generateSQL(directive) {
     normalizedMappings: built.paramMappings,
     dialect,
     requiresReduction: built.requiresReduction,
-    includeSpec: built.includeSpec
+    includeSpec: built.includeSpec,
+    isArrayAgg: built.isArrayAgg
   });
 }
-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,222 +6093,217 @@ 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);
-          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);
+var BoundedCache = class {
+  constructor(maxSize) {
+    this.map = /* @__PURE__ */ new Map();
+    this.ghost = /* @__PURE__ */ new Set();
+    this.smallHead = null;
+    this.smallTail = null;
+    this.smallSize = 0;
+    this.mainHead = null;
+    this.mainTail = null;
+    this.mainSize = 0;
+    this.maxSize = maxSize;
+    this.smallLimit = Math.max(1, Math.floor(maxSize * 0.1));
+    this.mainLimit = maxSize - this.smallLimit;
+    this.ghostLimit = this.mainLimit;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    node.freq = Math.min(node.freq + 1, 3);
+    return node.value;
+  }
+  set(key, value) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      return this;
+    }
+    if (this.ghost.has(key)) {
+      this.ghost.delete(key);
+      const node2 = this.createNode(key, value, "main");
+      this.map.set(key, node2);
+      this.pushMain(node2);
+      if (this.mainSize > this.mainLimit) this.evictMain();
+      return this;
+    }
+    const node = this.createNode(key, value, "small");
+    this.map.set(key, node);
+    this.pushSmall(node);
+    if (this.size > this.maxSize) {
+      if (this.smallSize > this.smallLimit) this.evictSmall();
+      else this.evictMain();
+    }
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.map.delete(key);
+    this.removeNode(node);
+    return true;
+  }
+  clear() {
+    this.map.clear();
+    this.ghost.clear();
+    this.smallHead = this.smallTail = null;
+    this.mainHead = this.mainTail = null;
+    this.smallSize = this.mainSize = 0;
+  }
+  keys() {
+    return withDispose(
+      (function* (self) {
+        for (const key of self.map.keys()) yield key;
+      })(this)
+    );
+  }
+  values() {
+    return withDispose(
+      (function* (self) {
+        for (const node of self.map.values()) yield node.value;
+      })(this)
+    );
+  }
+  entries() {
+    return withDispose(
+      (function* (self) {
+        for (const [key, node] of self.map.entries())
+          yield [key, node.value];
+      })(this)
+    );
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [key, node] of this.map.entries()) {
+      callbackfn.call(thisArg, node.value, key, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return "BoundedCache";
+  }
+  createNode(key, value, queue) {
+    return { key, value, freq: 0, queue, prev: null, next: null };
+  }
+  pushSmall(node) {
+    node.next = this.smallHead;
+    node.prev = null;
+    if (this.smallHead) this.smallHead.prev = node;
+    else this.smallTail = node;
+    this.smallHead = node;
+    this.smallSize++;
+  }
+  pushMain(node) {
+    node.next = this.mainHead;
+    node.prev = null;
+    if (this.mainHead) this.mainHead.prev = node;
+    else this.mainTail = node;
+    this.mainHead = node;
+    this.mainSize++;
+  }
+  popSmall() {
+    if (!this.smallTail) return null;
+    const node = this.smallTail;
+    this.smallTail = node.prev;
+    if (this.smallTail) this.smallTail.next = null;
+    else this.smallHead = null;
+    node.prev = null;
+    node.next = null;
+    this.smallSize--;
+    return node;
+  }
+  popMain() {
+    if (!this.mainTail) return null;
+    const node = this.mainTail;
+    this.mainTail = node.prev;
+    if (this.mainTail) this.mainTail.next = null;
+    else this.mainHead = null;
+    node.prev = null;
+    node.next = null;
+    this.mainSize--;
+    return node;
+  }
+  removeNode(node) {
+    this.unlinkNode(node);
+    if (node.queue === "small") {
+      if (node === this.smallHead) this.smallHead = node.next;
+      if (node === this.smallTail) this.smallTail = node.prev;
+      this.smallSize--;
+    } else {
+      if (node === this.mainHead) this.mainHead = node.next;
+      if (node === this.mainTail) this.mainTail = node.prev;
+      this.mainSize--;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  unlinkNode(node) {
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+  }
+  shouldPromoteFromSmall(node) {
+    return node.freq > 1;
+  }
+  shouldRetryInMain(node) {
+    return node.freq >= 1;
+  }
+  promoteToMain(node) {
+    node.queue = "main";
+    this.pushMain(node);
+  }
+  addToGhost(key) {
+    this.ghost.add(key);
+    if (this.ghost.size <= this.ghostLimit) return;
+    const firstGhost = this.ghost.values().next().value;
+    if (firstGhost !== void 0) this.ghost.delete(firstGhost);
+  }
+  evictFromCache(node) {
+    this.map.delete(node.key);
+  }
+  evictSmall() {
+    while (this.smallSize > 0) {
+      const node = this.popSmall();
+      if (!node) return;
+      if (this.shouldPromoteFromSmall(node)) {
+        this.promoteToMain(node);
+        if (this.mainSize > this.mainLimit) {
+          this.evictMain();
           return;
         }
+        continue;
       }
-    };
+      this.evictFromCache(node);
+      this.addToGhost(node.key);
+      return;
+    }
   }
-});
-
-// src/fast-path.ts
+  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) {
   const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
   if (!idField) return null;
@@ -6506,17 +6463,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}`;
@@ -6711,7 +6687,8 @@ function buildSQLFull(model, models, method, args, dialect) {
   return __spreadProps(__spreadValues({}, sqlResult), {
     paramMappings: result.paramMappings,
     requiresReduction: result.requiresReduction,
-    includeSpec: result.includeSpec
+    includeSpec: result.includeSpec,
+    isArrayAgg: result.isArrayAgg
   });
 }
 function buildSQLWithCache(model, models, method, args, dialect) {
@@ -6724,7 +6701,8 @@ function buildSQLWithCache(model, models, method, args, dialect) {
       params: [...cached.params],
       paramMappings: cached.paramMappings,
       requiresReduction: cached.requiresReduction,
-      includeSpec: cached.includeSpec
+      includeSpec: cached.includeSpec,
+      isArrayAgg: cached.isArrayAgg
     };
   }
   queryCacheStats.miss();
@@ -6742,77 +6720,104 @@ function buildSQLWithCache(model, models, method, args, dialect) {
     params: [...result.params],
     paramMappings: result.paramMappings,
     requiresReduction: result.requiresReduction,
-    includeSpec: result.includeSpec
+    includeSpec: result.includeSpec,
+    isArrayAgg: result.isArrayAgg
   });
   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 _a3, _b;
   if (method === "findFirst" || method === "findUnique") {
     if (Array.isArray(results)) {
-      return (_a = results[0]) != null ? _a : null;
+      return (_a3 = results[0]) != null ? _a3 : 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) {
@@ -7040,9 +7045,9 @@ function wrapQueryForMethod(method, cteName, resultAlias) {
   }
 }
 function isAllCountQueries(queries, keys) {
-  var _a;
+  var _a3;
   for (const key of keys) {
-    if (((_a = queries[key]) == null ? void 0 : _a.method) !== "count") return false;
+    if (((_a3 = queries[key]) == null ? void 0 : _a3.method) !== "count") return false;
   }
   return true;
 }
@@ -7281,8 +7286,8 @@ function buildMergedCountBatchSql(queries, keys, aliasesByKey, modelMap, models,
   const fromSql = rewrittenSubs.join(" CROSS JOIN ");
   const sql = `SELECT ${selectParts.join(", ")} FROM ${fromSql}`;
   const aliases = keys.map((k) => {
-    var _a;
-    return (_a = aliasesByKey.get(k)) != null ? _a : "";
+    var _a3;
+    return (_a3 = aliasesByKey.get(k)) != null ? _a3 : "";
   });
   return { sql, params: finalParams, keys, aliases };
 }
@@ -7459,12 +7464,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;
 }
@@ -7633,11 +7655,11 @@ function parseBatchValue(rawValue, method, modelName, modelMap) {
   }
 }
 function parseBatchResults(row, keys, queries, aliases, modelMap) {
-  var _a;
+  var _a3;
   const results = {};
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
-    const columnKey = (_a = aliases == null ? void 0 : aliases[i]) != null ? _a : key;
+    const columnKey = (_a3 = aliases == null ? void 0 : aliases[i]) != null ? _a3 : key;
     const rawValue = row[columnKey];
     const query = queries[key];
     results[key] = parseBatchValue(
@@ -7649,13 +7671,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 +7741,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,50 +7755,23 @@ 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) {
+function buildKey(row, fields) {
   if (fields.length === 0) return null;
   if (fields.length === 1) {
     const val = row[fields[0]];
-    if (val == null) return null;
-    const t = typeof val;
-    if (t === "string") return `s:${val}`;
-    if (t === "number") return Number.isFinite(val) ? `n:${val}` : null;
-    if (t === "boolean") return val ? "b:1" : "b:0";
-    if (t === "bigint") return `i:${val}`;
-    return `o:${val}`;
-  }
-  const parts = new Array(fields.length);
+    return val == null ? null : val;
+  }
+  let key = "";
   for (let i = 0; i < fields.length; i++) {
     const val = row[fields[i]];
     if (val == null) return null;
-    const t = typeof val;
-    if (t === "string") {
-      parts[i] = `s:${val}`;
-    } else if (t === "number") {
-      if (!Number.isFinite(val)) return null;
-      parts[i] = `n:${val}`;
-    } else if (t === "boolean") {
-      parts[i] = val ? "b:1" : "b:0";
-    } else if (t === "bigint") {
-      parts[i] = `i:${val}`;
-    } else {
-      parts[i] = `o:${val}`;
-    }
+    if (i > 0) key += "";
+    key += typeof val === "string" ? val : String(val);
   }
-  return parts.join("");
+  return key;
 }
-var init_key_utils = __esm({
-  "src/builder/shared/key-utils.ts"() {
-  }
-});
 
 // src/builder/select/reducer.ts
 function buildRelationScalarCols(relModel, relPath, includeAllScalars, selectedScalarFields) {
@@ -7795,6 +7787,14 @@ function buildRelationScalarCols(relModel, relPath, includeAllScalars, selectedS
   }
   return out;
 }
+function extractChildLimit(relArgs) {
+  if (!isPlainObject(relArgs)) return void 0;
+  const obj = relArgs;
+  if ("take" in obj && typeof obj.take === "number" && obj.take > 0) {
+    return obj.take;
+  }
+  return void 0;
+}
 function buildReducerConfig(parentModel, includeSpec, allModels, prefix = "", depth = 0) {
   if (depth > 10) {
     throw new Error(
@@ -7817,7 +7817,7 @@ function buildReducerConfig(parentModel, includeSpec, allModels, prefix = "", de
         `Related model '${field.relatedModel}' not found for relation '${incName}'`
       );
     }
-    const isList2 = typeof field.type === "string" && field.type.endsWith("[]");
+    const isList = typeof field.type === "string" && field.type.endsWith("[]");
     const primaryKeyFields = getPrimaryKeyFields(relatedModel);
     const scalarSel = extractScalarSelection(incValue, relatedModel);
     const relPath = prefix ? `${prefix}.${incName}` : incName;
@@ -7839,14 +7839,16 @@ function buildReducerConfig(parentModel, includeSpec, allModels, prefix = "", de
       scalarSel.includeAllScalars,
       scalarSel.selectedScalarFields
     );
+    const childLimit = isList ? extractChildLimit(incValue) : void 0;
     includedRelations.push({
       name: incName,
-      cardinality: isList2 ? "many" : "one",
+      cardinality: isList ? "many" : "one",
       relatedModel,
       primaryKeyFields,
       includeAllScalars: scalarSel.includeAllScalars,
       selectedScalarFields: scalarSel.selectedScalarFields,
       nestedIncludes,
+      childLimit,
       path: relPath,
       keyCols,
       scalarCols
@@ -7878,7 +7880,7 @@ function initNestedPlaceholders(obj, nested) {
   }
 }
 function materializeRelationObject(row, rel) {
-  const relKey = buildCompositeKey(row, rel.keyCols);
+  const relKey = buildKey(row, rel.keyCols);
   if (relKey == null) return null;
   const obj = {};
   for (const c of rel.scalarCols) {
@@ -7894,7 +7896,7 @@ function processNestedRelations(obj, rel, row, manyStore) {
   }
 }
 function processRelation(parentObj, rel, row, manyStore) {
-  const relKey = buildCompositeKey(row, rel.keyCols);
+  const relKey = buildKey(row, rel.keyCols);
   if (relKey == null) return;
   if (rel.cardinality === "one") {
     let current = parentObj[rel.name];
@@ -7908,6 +7910,9 @@ function processRelation(parentObj, rel, row, manyStore) {
     return;
   }
   const arr = parentObj[rel.name];
+  if (rel.childLimit && arr.length >= rel.childLimit) {
+    return;
+  }
   const idx = getIndexForParent(manyStore, parentObj, rel.path);
   const existing = idx.get(relKey);
   if (existing) {
@@ -7941,7 +7946,7 @@ function reduceFlatRows(rows, config) {
   const manyStore = /* @__PURE__ */ new WeakMap();
   for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
     const row = rows[rowIdx];
-    const parentKey = buildCompositeKey(row, parentKeyCols);
+    const parentKey = buildKey(row, parentKeyCols);
     if (parentKey == null) continue;
     let record = resultMap.get(parentKey);
     if (!record) {
@@ -7964,18 +7969,9 @@ 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
-function isList(field) {
+function isListField(field) {
   return typeof field.type === "string" && field.type.endsWith("[]");
 }
 function resolveRelation(model, relName, allModels) {
@@ -7985,47 +7981,6 @@ function resolveRelation(model, relName, allModels) {
   if (!relModel) return null;
   return { field, relModel };
 }
-function effectiveFanout(stats) {
-  return 1 + stats.coverage * (stats.avg - 1);
-}
-function estimateFlatRows(parentCount, relations, stats) {
-  var _a;
-  let rows = parentCount;
-  for (const rel of relations) {
-    const relStats = (_a = stats == null ? void 0 : stats[rel.modelName]) == null ? void 0 : _a[rel.relName];
-    const fanout = relStats ? effectiveFanout(relStats) : 10;
-    const next = rows * fanout;
-    if (next > MAX_ESTIMATED_ROWS) {
-      return MAX_ESTIMATED_ROWS;
-    }
-    rows = next;
-  }
-  return Math.ceil(rows);
-}
-function collectOneToManyRelations(entries, model, allModels) {
-  const out = [];
-  for (const entry of entries) {
-    const resolved = resolveRelation(model, entry.name, allModels);
-    if (!resolved) continue;
-    if (!isList(resolved.field)) continue;
-    out.push({
-      name: entry.name,
-      relArgs: entry.value,
-      field: resolved.field,
-      relModel: resolved.relModel,
-      hasPagination: hasChildPagination(entry.value)
-    });
-  }
-  return out;
-}
-function getParentCount(method, args) {
-  if (method === "findFirst" || method === "findUnique") return 1;
-  if ((args == null ? void 0 : args.take) !== void 0 && (args == null ? void 0 : args.take) !== null) {
-    const take = typeof args.take === "number" ? Math.abs(args.take) : null;
-    if (take !== null) return take;
-  }
-  return null;
-}
 function buildWhereInSegment(name, relArgs, field, relModel) {
   const keys = resolveRelationKeys(field, "whereIn");
   if (keys.childKeys.length !== 1) return null;
@@ -8035,7 +7990,7 @@ function buildWhereInSegment(name, relArgs, field, relModel) {
     childModelName: relModel.name,
     fkFieldName: keys.childKeys[0],
     parentKeyFieldName: keys.parentKeys[0],
-    isList: true
+    isList: isListField(field)
   };
 }
 function deepClone(obj) {
@@ -8069,85 +8024,154 @@ function removeRelationsFromArgs(args, names) {
   }
   return filtered;
 }
+function ensureParentKeysInSelect(args, segments) {
+  if (!(args == null ? void 0 : args.select)) return { args, injectedKeys: [] };
+  const injected = [];
+  const newSelect = __spreadValues({}, args.select);
+  for (const seg of segments) {
+    if (!newSelect[seg.parentKeyFieldName]) {
+      newSelect[seg.parentKeyFieldName] = true;
+      injected.push(seg.parentKeyFieldName);
+    }
+  }
+  if (injected.length === 0) return { args, injectedKeys: [] };
+  return { args: __spreadProps(__spreadValues({}, args), { select: newSelect }), injectedKeys: injected };
+}
 function planQueryStrategy(params) {
-  const { model, method, args, allModels, relationStats } = params;
+  const { model, args, allModels } = params;
+  const emptyPlan = {
+    filteredArgs: args,
+    whereInSegments: [],
+    injectedParentKeys: []
+  };
   const entries = extractRelationEntries(args, model);
   if (entries.length === 0) {
-    return { filteredArgs: args, whereInSegments: [] };
+    return emptyPlan;
   }
-  const oneToManyRels = collectOneToManyRelations(entries, model, allModels);
-  const unpaginatedOneToMany = oneToManyRels.filter((r) => !r.hasPagination);
-  if (unpaginatedOneToMany.length === 0) {
-    return { filteredArgs: args, whereInSegments: [] };
-  }
-  const parentCount = getParentCount(method, args);
   const whereInSegments = [];
   const toRemove = /* @__PURE__ */ new Set();
-  if (unpaginatedOneToMany.length > 1) {
-    for (const rel of unpaginatedOneToMany) {
-      const segment = buildWhereInSegment(
-        rel.name,
-        rel.relArgs,
-        rel.field,
-        rel.relModel
-      );
-      if (segment) {
-        whereInSegments.push(segment);
-        toRemove.add(rel.name);
-      }
+  for (const entry of entries) {
+    const resolved = resolveRelation(model, entry.name, allModels);
+    if (!resolved) continue;
+    if (isListField(resolved.field) && hasChildPagination(entry.value)) {
+      continue;
     }
-  } else if (unpaginatedOneToMany.length === 1) {
-    const rel = unpaginatedOneToMany[0];
-    if (parentCount === null) {
-      const segment = buildWhereInSegment(
-        rel.name,
-        rel.relArgs,
-        rel.field,
-        rel.relModel
-      );
-      if (segment) {
-        whereInSegments.push(segment);
-        toRemove.add(rel.name);
-      }
-    } else {
-      const estimated = estimateFlatRows(
-        parentCount,
-        [{ modelName: model.name, relName: rel.name, field: rel.field }],
-        relationStats
-      );
-      if (estimated > HARD_FANOUT_CAP) {
-        const segment = buildWhereInSegment(
-          rel.name,
-          rel.relArgs,
-          rel.field,
-          rel.relModel
-        );
-        if (segment) {
-          whereInSegments.push(segment);
-          toRemove.add(rel.name);
-        }
-      }
+    const segment = buildWhereInSegment(
+      entry.name,
+      entry.value,
+      resolved.field,
+      resolved.relModel
+    );
+    if (segment) {
+      whereInSegments.push(segment);
+      toRemove.add(entry.name);
     }
   }
   if (toRemove.size === 0) {
-    return { filteredArgs: args, whereInSegments: [] };
+    return emptyPlan;
   }
   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;
+  const { args: finalArgs, injectedKeys } = ensureParentKeysInSelect(
+    filteredArgs,
+    whereInSegments
+  );
+  return {
+    filteredArgs: finalArgs,
+    whereInSegments,
+    injectedParentKeys: injectedKeys
+  };
+}
+
+// src/builder/select/array-agg-reducer.ts
+function buildArrayAggReducerConfig(parentModel, includeSpec, allModels) {
+  const modelMap = new Map(allModels.map((m) => [m.name, m]));
+  const parentJsonSet = getJsonFieldSet(parentModel);
+  const parentScalarFields = getScalarFieldNames(parentModel);
+  const relations = [];
+  for (const [relName, relValue] of Object.entries(includeSpec)) {
+    if (relValue === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!field || !field.isRelation || !field.relatedModel) continue;
+    const relModel = modelMap.get(field.relatedModel);
+    if (!relModel) continue;
+    const isList = typeof field.type === "string" && field.type.endsWith("[]");
+    const indices = getFieldIndices(relModel);
+    const scalarSel = extractScalarSelection(relValue, relModel);
+    const pkFields = getPrimaryKeyFields(relModel);
+    const relJsonSet = getJsonFieldSet(relModel);
+    const selectedFields = scalarSel.includeAllScalars ? Array.from(indices.scalarFields.keys()) : [.../* @__PURE__ */ new Set([...pkFields, ...scalarSel.selectedScalarFields])];
+    const scalarCols = selectedFields.map((fieldName) => {
+      const f = indices.scalarFields.get(fieldName);
+      if (!f) return null;
+      return {
+        fieldName: f.name,
+        colName: `${relName}.${f.name}`,
+        isJson: relJsonSet.has(f.name)
+      };
+    }).filter(Boolean);
+    relations.push({
+      name: relName,
+      isList,
+      scalarFields: scalarCols,
+      pkFieldName: pkFields[0]
+    });
   }
-});
+  return {
+    parentModel,
+    parentScalarFields,
+    parentJsonSet,
+    relations
+  };
+}
+function reduceArrayAggRows(rows, config) {
+  var _a3;
+  if (rows.length === 0) return [];
+  const { parentScalarFields, parentJsonSet, relations } = config;
+  const results = new Array(rows.length);
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const record = {};
+    for (const fieldName of parentScalarFields) {
+      if (!(fieldName in row)) continue;
+      record[fieldName] = maybeParseJson(
+        row[fieldName],
+        parentJsonSet,
+        fieldName
+      );
+    }
+    for (const rel of relations) {
+      const firstCol = rel.scalarFields[0];
+      if (!firstCol) {
+        record[rel.name] = rel.isList ? [] : null;
+        continue;
+      }
+      const arr = row[firstCol.colName];
+      if (!Array.isArray(arr) || arr.length === 0) {
+        record[rel.name] = rel.isList ? [] : null;
+        continue;
+      }
+      const len = arr.length;
+      const children = new Array(len);
+      for (let j = 0; j < len; j++) {
+        const child = {};
+        for (const col2 of rel.scalarFields) {
+          const values = row[col2.colName];
+          child[col2.fieldName] = parseJsonIfNeeded(
+            col2.isJson,
+            Array.isArray(values) ? values[j] : null
+          );
+        }
+        children[j] = child;
+      }
+      record[rel.name] = rel.isList ? children : (_a3 = children[0]) != null ? _a3 : null;
+    }
+    results[i] = record;
+  }
+  return results;
+}
 
 // src/builder/shared/where-in-executor-base.ts
+var MAX_RECURSIVE_DEPTH = 10;
 function getParamLimit(dialect) {
   return dialect === "postgres" ? 32e3 : 900;
 }
@@ -8200,8 +8224,14 @@ function stitchResults(parentRows, segment, childRows, stripFk) {
     }
   }
 }
-function executeSegmentBase(segment, parentRows, allModels, modelMap, dialect, execute) {
+function executeSingleSegment(segment, parentRows, allModels, modelMap, dialect, execute, depth) {
   return __async(this, null, function* () {
+    if (depth > MAX_RECURSIVE_DEPTH) {
+      for (const parent of parentRows) {
+        parent[segment.relationName] = segment.isList ? [] : null;
+      }
+      return;
+    }
     const parentIds = parentRows.map((r) => r[segment.parentKeyFieldName]).filter((v) => v != null);
     if (parentIds.length === 0) {
       for (const parent of parentRows) {
@@ -8221,23 +8251,41 @@ function executeSegmentBase(segment, parentRows, allModels, modelMap, dialect, e
     }
     const allChildRows = [];
     let needsStripFk = false;
+    let nestedSegments = [];
     for (const chunk of chunks) {
       const childArgs = buildChildArgs(
         segment.relArgs,
         segment.fkFieldName,
         chunk
       );
-      const stripFk = ensureFkInSelect(childArgs, segment.fkFieldName);
+      const childPlan = planQueryStrategy({
+        model: childModel,
+        args: childArgs,
+        allModels});
+      if (nestedSegments.length === 0 && childPlan.whereInSegments.length > 0) {
+        nestedSegments = childPlan.whereInSegments;
+      }
+      const stripFk = ensureFkInSelect(
+        childPlan.filteredArgs,
+        segment.fkFieldName
+      );
       if (stripFk) needsStripFk = true;
       const result = buildSQL(
         childModel,
         allModels,
         "findMany",
-        childArgs,
+        childPlan.filteredArgs,
         dialect
       );
       let rows = yield execute(result.sql, result.params);
-      if (result.requiresReduction && result.includeSpec) {
+      if (result.isArrayAgg && result.includeSpec) {
+        const config = buildArrayAggReducerConfig(
+          childModel,
+          result.includeSpec,
+          allModels
+        );
+        rows = reduceArrayAggRows(rows, config);
+      } else if (result.requiresReduction && result.includeSpec) {
         const config = buildReducerConfig(
           childModel,
           result.includeSpec,
@@ -8249,229 +8297,260 @@ function executeSegmentBase(segment, parentRows, allModels, modelMap, dialect, e
         allChildRows.push(row);
       }
     }
+    if (nestedSegments.length > 0 && allChildRows.length > 0) {
+      for (const row of allChildRows) {
+        for (const nestedSeg of nestedSegments) {
+          row[nestedSeg.relationName] = nestedSeg.isList ? [] : null;
+        }
+      }
+      yield resolveSegmentsIntelligent(
+        nestedSegments,
+        allChildRows,
+        allModels,
+        modelMap,
+        dialect,
+        execute,
+        depth + 1
+      );
+    }
     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) {
+function resolveSegmentsIntelligent(segments, parentRows, allModels, modelMap, dialect, execute, depth) {
   return __async(this, null, function* () {
-    const { segments, parentRows, allModels, modelMap, dialect, execute } = params;
+    if (depth > MAX_RECURSIVE_DEPTH) return;
     if (segments.length === 0) return;
-    if (parentRows.length === 0) return;
-    for (const segment of segments) {
-      yield executeSegmentBase(
-        segment,
+    if (segments.length === 1) {
+      yield executeSingleSegment(
+        segments[0],
         parentRows,
         allModels,
         modelMap,
         dialect,
-        execute
+        execute,
+        depth
       );
+      return;
     }
+    yield Promise.all(
+      segments.map(
+        (seg) => executeSingleSegment(
+          seg,
+          parentRows,
+          allModels,
+          modelMap,
+          dialect,
+          execute,
+          depth
+        )
+      )
+    );
+  });
+}
+function executeSegmentBase(segment, parentRows, allModels, modelMap, dialect, execute, depth = 0) {
+  return __async(this, null, function* () {
+    yield executeSingleSegment(
+      segment,
+      parentRows,
+      allModels,
+      modelMap,
+      dialect,
+      execute,
+      depth
+    );
   });
 }
-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]);
-      }
-      if (rel.nestedIncludes) {
-        for (const nested of rel.nestedIncludes.includedRelations) {
-          child[nested.name] = nested.cardinality === "many" ? [] : null;
+// src/builder/where-in-executor.ts
+var ADAPTIVE_PARENT_THRESHOLD = 15;
+var ADAPTIVE_DEPTH_THRESHOLD = 2;
+function measureRelArgsDepth(relArgs) {
+  if (!relArgs || relArgs === true || typeof relArgs !== "object") return 0;
+  const args = relArgs;
+  const nested = args.include || args.select;
+  if (!nested || typeof nested !== "object") return 0;
+  let maxChildDepth = 0;
+  for (const val of Object.values(nested)) {
+    if (val === false) continue;
+    if (val === true) {
+      maxChildDepth = Math.max(maxChildDepth, 1);
+      continue;
+    }
+    if (val && typeof val === "object") {
+      maxChildDepth = Math.max(maxChildDepth, 1 + measureRelArgsDepth(val));
+    }
+  }
+  return maxChildDepth;
+}
+function measureSegmentNestingDepth(segments) {
+  let maxDepth = 0;
+  for (const seg of segments) {
+    const depth = 1 + measureRelArgsDepth(seg.relArgs);
+    maxDepth = Math.max(maxDepth, depth);
+  }
+  return maxDepth;
+}
+function shouldAdaptivelySwitch(actualParentCount, segments) {
+  if (actualParentCount > ADAPTIVE_PARENT_THRESHOLD) return false;
+  if (segments.length === 0) return false;
+  const depth = measureSegmentNestingDepth(segments);
+  return depth >= ADAPTIVE_DEPTH_THRESHOLD;
+}
+function executeCorrelatedFallback(parentRows, parentModel, allModels, dialect, execute, originalArgs, method, segments) {
+  return __async(this, null, function* () {
+    const pkField = getPrimaryKeyField(parentModel);
+    const pks = parentRows.map((r) => r[pkField]).filter(Boolean);
+    if (pks.length === 0) {
+      for (const parent of parentRows) {
+        for (const seg of segments) {
+          parent[seg.relationName] = seg.isList ? [] : null;
         }
       }
-      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;
-      }
-    };
-    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;
+    }
+    const fallbackArgs = __spreadValues({}, originalArgs);
+    delete fallbackArgs.take;
+    delete fallbackArgs.skip;
+    delete fallbackArgs.cursor;
+    fallbackArgs.where = { [pkField]: { in: pks } };
+    if (originalArgs.orderBy) {
+      fallbackArgs.orderBy = originalArgs.orderBy;
+    }
+    const result = buildSQL(
+      parentModel,
+      allModels,
+      method,
+      fallbackArgs,
+      dialect
+    );
+    let rows = yield execute(result.sql, result.params);
+    if (result.isArrayAgg && result.includeSpec) {
+      const config = buildArrayAggReducerConfig(
+        parentModel,
+        result.includeSpec,
+        allModels
+      );
+      rows = reduceArrayAggRows(rows, config);
+    } else if (result.requiresReduction && result.includeSpec) {
+      const config = buildReducerConfig(
+        parentModel,
+        result.includeSpec,
+        allModels
+      );
+      rows = reduceFlatRows(rows, config);
+    }
+    const rowsByPk = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      rowsByPk.set(row[pkField], row);
+    }
+    for (const parent of parentRows) {
+      const pk = parent[pkField];
+      const fullRow = rowsByPk.get(pk);
+      if (fullRow) {
+        for (const seg of segments) {
+          parent[seg.relationName] = fullRow[seg.relationName];
         }
-      };
-      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);
+      } else {
+        for (const seg of segments) {
+          parent[seg.relationName] = seg.isList ? [] : null;
         }
-        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) {
-  const coreReducer = createCoreReducer({
-    parentModel: config.parentModel,
-    includedRelations: config.includedRelations
+      }
+    }
   });
-  return {
-    processRow(row) {
-      coreReducer.processRow(row);
-    },
-    getResults() {
-      return coreReducer.getAllParents();
-    },
-    getParentMap() {
-      return coreReducer.getParentMap();
+}
+function executeWhereInSegments(params) {
+  return __async(this, null, function* () {
+    const {
+      segments,
+      parentRows,
+      parentModel,
+      allModels,
+      modelMap,
+      dialect,
+      execute,
+      originalArgs,
+      method
+    } = params;
+    if (originalArgs && method && parentModel && shouldAdaptivelySwitch(parentRows.length, segments)) {
+      yield executeCorrelatedFallback(
+        parentRows,
+        parentModel,
+        allModels,
+        dialect,
+        execute,
+        originalArgs,
+        method,
+        segments
+      );
+      return;
     }
-  };
+    if (segments.length === 1) {
+      yield executeSegmentBase(
+        segments[0],
+        parentRows,
+        allModels,
+        modelMap,
+        dialect,
+        execute,
+        0
+      );
+      return;
+    }
+    yield Promise.all(
+      segments.map(
+        (segment) => executeSegmentBase(
+          segment,
+          parentRows,
+          allModels,
+          modelMap,
+          dialect,
+          execute,
+          0
+        )
+      )
+    );
+  });
 }
-var init_streaming_reducer = __esm({
-  "src/builder/select/streaming-reducer.ts"() {
-    init_core_reducer();
-  }
-});
 
-// src/builder/select/streaming-progressive-reducer.ts
-function createProgressiveReducer(config) {
-  const coreReducer = createCoreReducer({
-    parentModel: config.parentModel,
-    includedRelations: config.includedRelations
-  });
-  const completedKeys = /* @__PURE__ */ new Set();
-  return {
-    processRow(row) {
-      coreReducer.processRow(row);
-    },
-    getCurrentParentKey(row) {
-      return coreReducer.processRow(row);
-    },
-    getCompletedParent(parentKey) {
-      if (completedKeys.has(parentKey)) return null;
-      const parent = coreReducer.getParent(parentKey);
-      if (!parent) return null;
-      completedKeys.add(parentKey);
-      return parent;
-    },
-    getRemainingParents() {
-      const remaining = [];
-      for (const [key, parent] of coreReducer.getParentMap()) {
-        if (!completedKeys.has(key)) {
-          remaining.push(parent);
-          completedKeys.add(key);
+// src/builder/select/streaming-where-in-executor.ts
+var MAX_RECURSIVE_DEPTH2 = 10;
+function buildParentKeyIndex(parentRows, parentKeyFieldName) {
+  const index = /* @__PURE__ */ new Map();
+  for (const parent of parentRows) {
+    const keyVal = parent[parentKeyFieldName];
+    if (keyVal == null) continue;
+    let arr = index.get(keyVal);
+    if (!arr) {
+      arr = [];
+      index.set(keyVal, arr);
+    }
+    arr.push(parent);
+  }
+  return index;
+}
+function stitchChildrenToParents(children, segment, parentKeyIndex) {
+  for (const child of children) {
+    const childKey = child[segment.fkFieldName];
+    const matchingParents = parentKeyIndex.get(childKey);
+    if (!matchingParents) continue;
+    for (const parent of matchingParents) {
+      if (segment.isList) {
+        if (!Array.isArray(parent[segment.relationName])) {
+          parent[segment.relationName] = [];
         }
+        parent[segment.relationName].push(child);
+      } else {
+        parent[segment.relationName] = child;
       }
-      return remaining;
     }
-  };
-}
-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 ensureFkInSelect2(childArgs, fkFieldName) {
+  if (!childArgs.select) return false;
+  if (childArgs.select[fkFieldName]) return false;
+  childArgs.select = __spreadProps(__spreadValues({}, childArgs.select), { [fkFieldName]: true });
+  return true;
+}
 function executeWhereInSegmentsStreaming(params) {
   return __async(this, null, function* () {
     const {
@@ -8482,9 +8561,7 @@ function executeWhereInSegmentsStreaming(params) {
       allModels,
       modelMap,
       dialect,
-      execute,
-      batchSize = 100,
-      maxConcurrency = 10
+      execute
     } = params;
     if (segments.length === 0) {
       throw new Error("executeWhereInSegmentsStreaming requires segments");
@@ -8492,100 +8569,157 @@ function executeWhereInSegmentsStreaming(params) {
     if (dialect !== "postgres") {
       throw new Error("Streaming WHERE IN requires postgres dialect");
     }
-    const parentMap = /* @__PURE__ */ new Map();
-    const batches = /* @__PURE__ */ new Map();
-    const inFlightMap = /* @__PURE__ */ new Map();
-    for (const seg of segments) {
-      batches.set(seg.relationName, []);
-    }
-    const pkField = getPrimaryKeyField(parentModel);
     const parentRows = yield execute(parentSql, parentParams);
+    if (parentRows.length === 0) return [];
     for (const row of parentRows) {
-      const pk = row[pkField];
-      parentMap.set(pk, __spreadValues({}, row));
       for (const seg of segments) {
         row[seg.relationName] = seg.isList ? [] : null;
       }
+    }
+    yield resolveSegments(
+      segments,
+      parentRows,
+      allModels,
+      modelMap,
+      dialect,
+      execute,
+      0
+    );
+    return parentRows;
+  });
+}
+function executeWithPreFetchedParents(params) {
+  return __async(this, null, function* () {
+    const {
+      segments,
+      parentRows,
+      parentModel,
+      allModels,
+      modelMap,
+      dialect,
+      execute
+    } = params;
+    if (segments.length === 0) return parentRows;
+    if (parentRows.length === 0) return [];
+    for (const row of parentRows) {
       for (const seg of segments) {
-        const batch = batches.get(seg.relationName);
-        const parentKey = row[seg.parentKeyFieldName];
-        batch.push(parentKey);
-        if (batch.length >= batchSize) {
-          const idsToFetch = [...batch];
-          batch.length = 0;
-          const promise = fetchAndAttachChildren(
-            seg,
-            idsToFetch,
-            parentMap,
-            allModels,
-            modelMap,
-            dialect,
-            execute
-          );
-          inFlightMap.set(promise, seg.relationName);
-          promise.finally(() => {
-            inFlightMap.delete(promise);
-          });
-          if (inFlightMap.size >= maxConcurrency) {
-            yield Promise.race(inFlightMap.keys());
-          }
-        }
+        row[seg.relationName] = seg.isList ? [] : null;
       }
     }
-    for (const seg of segments) {
-      const batch = batches.get(seg.relationName);
-      if (batch.length > 0) {
-        const promise = fetchAndAttachChildren(
+    yield resolveSegments(
+      segments,
+      parentRows,
+      allModels,
+      modelMap,
+      dialect,
+      execute,
+      0
+    );
+    return parentRows;
+  });
+}
+function resolveSegments(segments, parentRows, allModels, modelMap, dialect, execute, depth) {
+  return __async(this, null, function* () {
+    if (depth > MAX_RECURSIVE_DEPTH2) return;
+    if (segments.length === 0) return;
+    if (segments.length === 1) {
+      yield resolveSingleSegment(
+        segments[0],
+        parentRows,
+        allModels,
+        modelMap,
+        dialect,
+        execute,
+        depth
+      );
+      return;
+    }
+    yield Promise.all(
+      segments.map(
+        (seg) => resolveSingleSegment(
           seg,
-          batch,
-          parentMap,
+          parentRows,
           allModels,
           modelMap,
           dialect,
-          execute
-        );
-        inFlightMap.set(promise, seg.relationName);
-        promise.finally(() => {
-          inFlightMap.delete(promise);
-        });
-      }
-    }
-    yield Promise.all(inFlightMap.keys());
-    return Array.from(parentMap.values());
+          execute,
+          depth
+        )
+      )
+    );
   });
 }
-function fetchAndAttachChildren(segment, parentIds, parentMap, allModels, modelMap, dialect, execute) {
+function resolveSingleSegment(segment, parentRows, allModels, modelMap, dialect, execute, depth) {
   return __async(this, null, function* () {
     const childModel = modelMap.get(segment.childModelName);
-    if (!childModel) return;
+    if (!childModel) {
+      return;
+    }
+    const parentIds = parentRows.map((r) => r[segment.parentKeyFieldName]).filter((v) => v != null);
+    if (parentIds.length === 0) {
+      return;
+    }
+    const uniqueIds = [...new Set(parentIds)];
     const childArgs = buildChildArgs2(
       segment.relArgs,
       segment.fkFieldName,
-      parentIds
+      uniqueIds
     );
+    const needsStripFk = ensureFkInSelect2(childArgs, segment.fkFieldName);
+    const childPlan = planQueryStrategy({
+      model: childModel,
+      args: childArgs,
+      allModels});
     const result = buildSQL(
       childModel,
       allModels,
       "findMany",
-      childArgs,
+      childPlan.filteredArgs,
       dialect
     );
     let children = yield execute(result.sql, result.params);
-    if (result.requiresReduction && result.includeSpec) {
+    if (result.isArrayAgg && result.includeSpec) {
+      const config = buildArrayAggReducerConfig(
+        childModel,
+        result.includeSpec,
+        allModels
+      );
+      children = reduceArrayAggRows(children, config);
+    } else if (result.requiresReduction && result.includeSpec) {
       const config = buildReducerConfig(childModel, result.includeSpec, allModels);
       children = reduceFlatRows(children, config);
     }
-    for (const child of children) {
-      const fkValue = child[segment.fkFieldName];
-      const parent = parentMap.get(fkValue);
-      if (!parent) continue;
-      if (segment.isList) {
-        if (!Array.isArray(parent[segment.relationName])) {
-          parent[segment.relationName] = [];
+    if (childPlan.whereInSegments.length > 0 && children.length > 0) {
+      for (const child of children) {
+        for (const nestedSeg of childPlan.whereInSegments) {
+          child[nestedSeg.relationName] = nestedSeg.isList ? [] : null;
+        }
+      }
+      yield resolveSegments(
+        childPlan.whereInSegments,
+        children,
+        allModels,
+        modelMap,
+        dialect,
+        execute,
+        depth + 1
+      );
+      if (childPlan.injectedParentKeys.length > 0) {
+        for (const child of children) {
+          for (const key of childPlan.injectedParentKeys) {
+            delete child[key];
+          }
         }
-        parent[segment.relationName].push(child);
-      } else {
-        parent[segment.relationName] = child;
+      }
+    }
+    const parentKeyIndex = buildParentKeyIndex(
+      parentRows,
+      segment.parentKeyFieldName
+    );
+    stitchChildrenToParents(children, segment, parentKeyIndex);
+    if (needsStripFk) {
+      for (const child of children) {
+        delete child[segment.fkFieldName];
       }
     }
   });
@@ -8597,77 +8731,180 @@ 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;
-    }
+// src/builder/select/core-reducer.ts
+var getOrCreateRelationMap = (relationMaps, parent) => {
+  let relMap = relationMaps.get(parent);
+  if (!relMap) {
+    relMap = /* @__PURE__ */ new Map();
+    relationMaps.set(parent, relMap);
   }
-  return result;
-}
-function extractCountValue(row) {
-  if (!row || typeof row !== "object") return 0;
-  if ("_count._all" in row) {
-    return row["_count._all"];
+  return relMap;
+};
+var getOrCreateChildMap = (relMap, path) => {
+  let childMap = relMap.get(path);
+  if (!childMap) {
+    childMap = /* @__PURE__ */ new Map();
+    relMap.set(path, childMap);
   }
-  if ("_count" in row && row["_count"] && typeof row["_count"] === "object") {
-    const countObj = row["_count"];
-    if ("_all" in countObj) {
-      return countObj["_all"];
+  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;
     }
   }
-  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 child;
+};
+var attachChildToParent = (parent, child, rel) => {
+  if (rel.cardinality === "many") {
+    parent[rel.name].push(child);
+  } else {
+    parent[rel.name] = child;
+  }
+};
+function prepareRelations(relations) {
+  return relations.map((rel) => ({
+    rel,
+    prefixedPkFields: rel.primaryKeyFields.map((f) => `${rel.path}.${f}`),
+    nested: rel.nestedIncludes ? prepareRelations(rel.nestedIncludes.includedRelations) : null
+  }));
+}
+var createRelationProcessor = (relationMaps) => {
+  const processRelation2 = (parent, prepared, row) => {
+    const { rel, prefixedPkFields, nested } = prepared;
+    const childKey = buildKey(row, prefixedPkFields);
+    if (childKey == null) return;
+    const relMap = getOrCreateRelationMap(relationMaps, parent);
+    const childMap = getOrCreateChildMap(relMap, rel.path);
+    if (childMap.has(childKey)) {
+      if (nested) {
+        const existing = childMap.get(childKey);
+        for (const nestedPrepared of nested) {
+          processRelation2(existing, nestedPrepared, row);
+        }
       }
+      return;
     }
-  }
-  return 0;
+    const child = createChildObject(row, rel);
+    childMap.set(childKey, child);
+    attachChildToParent(parent, child, rel);
+    if (nested) {
+      for (const nestedPrepared of nested) {
+        processRelation2(child, nestedPrepared, row);
+      }
+    }
+  };
+  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 preparedRelations = prepareRelations(includedRelations);
+  const processRelation2 = createRelationProcessor(relationMaps);
+  const processRow = (row) => {
+    const parentKey = buildKey(row, parentPkFields);
+    if (parentKey == null) return null;
+    let parent;
+    if (parentMap.has(parentKey)) {
+      parent = parentMap.get(parentKey);
+    } else {
+      parent = createParentObject(row, scalarFields, jsonSet, includedRelations);
+      parentMap.set(parentKey, parent);
+    }
+    for (const prepared of preparedRelations) {
+      processRelation2(parent, prepared, row);
+    }
+    return parentKey;
+  };
+  return {
+    processRow,
+    getParent: (key) => {
+      var _a3;
+      return (_a3 = parentMap.get(key)) != null ? _a3 : null;
+    },
+    getAllParents: () => Array.from(parentMap.values()),
+    getParentMap: () => parentMap
+  };
+};
+
+// src/builder/select/streaming-reducer.ts
+function createStreamingReducer(config) {
+  const coreReducer = createCoreReducer({
+    parentModel: config.parentModel,
+    includedRelations: config.includedRelations
+  });
+  return {
+    processRow(row) {
+      coreReducer.processRow(row);
+    },
+    getResults() {
+      return coreReducer.getAllParents();
+    },
+    getParentMap() {
+      return coreReducer.getParentMap();
+    }
+  };
 }
-function getRowTransformer(method) {
-  if (method === "count") {
-    return extractCountValue;
-  }
-  if (method === "groupBy" || method === "aggregate") {
-    return transformAggregateRow;
-  }
-  return null;
+
+// src/builder/select/streaming-progressive-reducer.ts
+function createProgressiveReducer(config) {
+  const coreReducer = createCoreReducer({
+    parentModel: config.parentModel,
+    includedRelations: config.includedRelations
+  });
+  const completedKeys = /* @__PURE__ */ new Set();
+  return {
+    processRow(row) {
+      coreReducer.processRow(row);
+    },
+    getCurrentParentKey(row) {
+      return coreReducer.processRow(row);
+    },
+    getCompletedParent(parentKey) {
+      if (completedKeys.has(parentKey)) return null;
+      const parent = coreReducer.getParent(parentKey);
+      if (!parent) return null;
+      completedKeys.add(parentKey);
+      return parent;
+    },
+    getRemainingParents() {
+      const remaining = [];
+      for (const [key, parent] of coreReducer.getParentMap()) {
+        if (!completedKeys.has(key)) {
+          remaining.push(parent);
+          completedKeys.add(key);
+        }
+      }
+      return remaining;
+    }
+  };
 }
-var init_row_transformers = __esm({
-  "src/builder/select/row-transformers.ts"() {
-    init_constants();
-  }
-});
 
 // src/generated-runtime.ts
+var SQLITE_STMT_CACHE = /* @__PURE__ */ new WeakMap();
+var STMT_CACHE_LIMIT = 1e3;
 function getOrPrepareStatement(client, sql) {
   let cache = SQLITE_STMT_CACHE.get(client);
   if (!cache) {
@@ -8675,13 +8912,16 @@ function getOrPrepareStatement(client, sql) {
     SQLITE_STMT_CACHE.set(client, cache);
   }
   let stmt = cache.get(sql);
-  if (!stmt) {
-    stmt = client.prepare(sql);
+  if (stmt) {
+    cache.delete(sql);
     cache.set(sql, stmt);
-    if (cache.size > 1e3) {
-      const firstKey = cache.keys().next().value;
-      cache.delete(firstKey);
-    }
+    return stmt;
+  }
+  stmt = client.prepare(sql);
+  cache.set(sql, stmt);
+  if (cache.size > STMT_CACHE_LIMIT) {
+    const firstKey = cache.keys().next().value;
+    cache.delete(firstKey);
   }
   return stmt;
 }
@@ -8691,69 +8931,64 @@ function shouldSqliteUseGet(method) {
 function normalizeParams(params) {
   return params.map((p) => normalizeValue(p));
 }
-function executePostgresQuery(client, sql, params, method, requiresReduction, includeSpec, model, allModels) {
+function executePostgresQuery(client, sql, params, method, requiresReduction, includeSpec, model, allModels, isArrayAgg) {
   return __async(this, null, function* () {
     const normalizedParams = normalizeParams(params);
-    const query = client.unsafe(sql, normalizedParams);
-    if (requiresReduction && includeSpec && model) {
+    if (isArrayAgg && includeSpec) {
+      const config = buildArrayAggReducerConfig(model, includeSpec, allModels);
+      const results2 = [];
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        results2.push(row);
+      });
+      return reduceArrayAggRows(results2, config);
+    }
+    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) => {
+      const reducer = createStreamingReducer(config);
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
         reducer.processRow(row);
       });
       return reducer.getResults();
     }
-    if (method === "count") {
+    const needsTransform = method === "groupBy" || method === "aggregate" || method === "count";
+    if (!needsTransform) {
       const results2 = [];
-      yield query.forEach((row) => {
-        results2.push(extractCountValue(row));
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        results2.push(row);
       });
       return results2;
     }
-    if (method === "groupBy" || method === "aggregate") {
-      const results2 = [];
-      yield query.forEach((row) => {
-        results2.push(transformAggregateRow(row));
+    const rowTransformer = getRowTransformer(method);
+    const results = [];
+    if (rowTransformer) {
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        results.push(rowTransformer(row));
+      });
+    } else {
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        results.push(row);
       });
-      return results2;
     }
-    const results = [];
-    yield query.forEach((row) => {
-      results.push(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 +8998,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,28 +9101,8 @@ 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.buildArrayAggReducerConfig = buildArrayAggReducerConfig;
 exports.buildBatchCountSql = buildBatchCountSql;
 exports.buildBatchSql = buildBatchSql;
 exports.buildReducerConfig = buildReducerConfig;
@@ -8941,17 +9117,20 @@ exports.executeRaw = executeRaw;
 exports.executeSqliteQuery = executeSqliteQuery;
 exports.executeWhereInSegments = executeWhereInSegments;
 exports.executeWhereInSegmentsStreaming = executeWhereInSegmentsStreaming;
+exports.executeWithPreFetchedParents = executeWithPreFetchedParents;
 exports.extractCountValue = extractCountValue;
 exports.generateAllSQL = generateAllSQL;
 exports.generateSQL = generateSQL2;
 exports.generateSQLByModel = generateSQLByModel;
 exports.getOrPrepareStatement = getOrPrepareStatement;
+exports.getPrimaryKeyField = getPrimaryKeyField;
 exports.getRowTransformer = getRowTransformer;
 exports.normalizeParams = normalizeParams;
 exports.normalizeValue = normalizeValue;
 exports.parseBatchCountResults = parseBatchCountResults;
 exports.parseBatchResults = parseBatchResults;
 exports.planQueryStrategy = planQueryStrategy;
+exports.reduceArrayAggRows = reduceArrayAggRows;
 exports.reduceFlatRows = reduceFlatRows;
 exports.shouldSqliteUseGet = shouldSqliteUseGet;
 exports.transformAggregateRow = transformAggregateRow;