prisma-sql 1.67.0 → 1.68.0

package/dist/index.cjs

@@ -449,6 +449,8 @@ var AGGREGATE_PREFIXES = /* @__PURE__ */ new Set([
   "_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) {
@@ -992,7 +994,7 @@ 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();
@@ -1011,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);
       }
@@ -1135,13 +1137,13 @@ function getModelByName(schemas, name) {
   return schemas.find((m) => m.name === name);
 }
 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`);
@@ -1163,7 +1165,9 @@ function scopeName(scope, dynamicName) {
 function addAutoScoped(params, value, scope) {
   if (schemaParser.isDynamicParameter(value)) {
     const dn = schemaParser.extractDynamicName(value);
-    console.log(`[PARAM] ${scope} = ${JSON.stringify(value)}`);
+    if (DEBUG_PARAMS) {
+      console.log(`[PARAM] ${scope} = ${JSON.stringify(value)}`);
+    }
     return params.add(void 0, scopeName(scope, dn));
   }
   return params.add(value);
@@ -1604,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();
@@ -1619,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);
@@ -1627,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) + ")");
   }
@@ -2215,6 +2249,16 @@ function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
 
 // 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("[]");
 }
@@ -2414,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(", ")}`,
@@ -2745,6 +2790,8 @@ function createAliasGenerator(maxAliases = 1e4) {
   };
 }
 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(
@@ -2804,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;
@@ -2958,10 +3010,10 @@ function toPublicResult(clause, joins, params) {
 
 // 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(1, dialect);
+  const params = (_a3 = options.params) != null ? _a3 : createParamStore(1, dialect);
   const ctx = {
     alias: options.alias,
     model: options.model,
@@ -3020,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);
@@ -3118,7 +3170,8 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
 }
 
 // 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(
@@ -3136,6 +3189,13 @@ function resolveRelationKeys(field, context = "include") {
   const parentKeys = field.isForeignKeyLocal ? fkFields : refFields;
   return { childKeys, parentKeys };
 }
+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) {
@@ -3165,6 +3225,18 @@ function extractRelationEntries(args, model) {
 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";
@@ -3184,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(", ")}`
@@ -3301,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(
@@ -3449,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;
@@ -3546,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,
@@ -3563,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(
@@ -3584,7 +3668,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     ctx.dialect,
     relModel
   );
-  if (!isList2) {
+  if (!isList) {
     const sql = buildOneToOneIncludeSql({
       relTable,
       relAlias,
@@ -3604,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,
@@ -3702,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;
 }
@@ -3995,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;
 }
@@ -4095,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(" ") : "";
@@ -4141,6 +4240,217 @@ function buildFlatJoinSql(spec) {
   `.trim();
   return { sql, requiresReduction: true, includeSpec };
 }
+
+// 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;
+  }
+  return true;
+}
+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}`);
+  }
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!relModel) {
+    throw new Error(`Related model ${field.relatedModel} not found`);
+  }
+  return relModel;
+}
+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 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 "";
@@ -4228,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) {
@@ -4279,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);
@@ -4363,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) {
@@ -4527,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,
@@ -4572,7 +4882,6 @@ function constructFinalSql(spec) {
     params,
     dialect,
     model,
-    includes,
     schemas,
     pagination,
     args
@@ -4584,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) {
@@ -4630,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);
@@ -4661,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) {
@@ -5491,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";
 }
@@ -5655,7 +5982,7 @@ function extractIncludeSpec2(processed, modelDef) {
   return includeSpec;
 }
 function buildAndNormalizeSql(args) {
-  var _a;
+  var _a3;
   const {
     method,
     processed,
@@ -5681,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) {
@@ -5698,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);
@@ -5715,6 +6045,7 @@ function finalizeDirective(args) {
     paramMappings: normalizedMappings,
     requiresReduction,
     includeSpec,
+    isArrayAgg,
     originalDirective: directive
   };
 }
@@ -5748,7 +6079,8 @@ function generateSQL(directive) {
     normalizedMappings: built.paramMappings,
     dialect,
     requiresReduction: built.requiresReduction,
-    includeSpec: built.includeSpec
+    includeSpec: built.includeSpec,
+    isArrayAgg: built.isArrayAgg
   });
 }
 
@@ -6355,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) {
@@ -6368,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();
@@ -6386,7 +6720,8 @@ 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;
 }
@@ -6460,10 +6795,10 @@ function getRowTransformer(method) {
 
 // src/result-transformers.ts
 function transformQueryResults(method, results) {
-  var _a, _b;
+  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") {
@@ -6710,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;
 }
@@ -6951,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 };
 }
@@ -7320,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(
@@ -7422,37 +7757,20 @@ function createTransactionExecutor(deps) {
 }
 
 // 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;
 }
 
 // src/builder/select/reducer.ts
@@ -7469,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(
@@ -7491,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;
@@ -7513,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
@@ -7552,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) {
@@ -7568,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];
@@ -7582,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) {
@@ -7615,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) {
@@ -7640,9 +7971,7 @@ function reduceFlatRows(rows, config) {
 }
 
 // src/builder/select/segment-planner.ts
-var HARD_FANOUT_CAP = 5e3;
-var MAX_ESTIMATED_ROWS = Number.MAX_SAFE_INTEGER / 1e3;
-function isList(field) {
+function isListField(field) {
   return typeof field.type === "string" && field.type.endsWith("[]");
 }
 function resolveRelation(model, relName, allModels) {
@@ -7652,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;
@@ -7702,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) {
@@ -7736,74 +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: [] };
-  }
-  const oneToManyRels = collectOneToManyRelations(entries, model, allModels);
-  const unpaginatedOneToMany = oneToManyRels.filter((r) => !r.hasPagination);
-  if (unpaginatedOneToMany.length === 0) {
-    return { filteredArgs: args, whereInSegments: [] };
+    return emptyPlan;
   }
-  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
+    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 emptyPlan;
+  }
+  const filteredArgs = removeRelationsFromArgs(args, toRemove);
+  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
       );
-      if (segment) {
-        whereInSegments.push(segment);
-        toRemove.add(rel.name);
+    }
+    for (const rel of relations) {
+      const firstCol = rel.scalarFields[0];
+      if (!firstCol) {
+        record[rel.name] = rel.isList ? [] : null;
+        continue;
       }
-    } 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 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;
   }
-  if (toRemove.size === 0) {
-    return { filteredArgs: args, whereInSegments: [] };
-  }
-  const filteredArgs = removeRelationsFromArgs(args, toRemove);
-  return { filteredArgs, whereInSegments };
+  return results;
 }
 
 // src/builder/shared/where-in-executor-base.ts
+var MAX_RECURSIVE_DEPTH = 10;
 function getParamLimit(dialect) {
   return dialect === "postgres" ? 32e3 : 900;
 }
@@ -7856,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) {
@@ -7877,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,
@@ -7905,28 +8297,440 @@ 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);
   });
 }
+function resolveSegmentsIntelligent(segments, parentRows, allModels, modelMap, dialect, execute, depth) {
+  return __async(this, null, function* () {
+    if (depth > MAX_RECURSIVE_DEPTH) return;
+    if (segments.length === 0) return;
+    if (segments.length === 1) {
+      yield executeSingleSegment(
+        segments[0],
+        parentRows,
+        allModels,
+        modelMap,
+        dialect,
+        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
+    );
+  });
+}
 
 // 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;
+    }
+    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];
+        }
+      } else {
+        for (const seg of segments) {
+          parent[seg.relationName] = seg.isList ? [] : null;
+        }
+      }
+    }
+  });
+}
 function executeWhereInSegments(params) {
   return __async(this, null, function* () {
-    const { segments, parentRows, allModels, modelMap, dialect, execute } = params;
-    if (segments.length === 0) return;
-    if (parentRows.length === 0) return;
-    for (const segment of segments) {
+    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(
-        segment,
+        segments[0],
+        parentRows,
+        allModels,
+        modelMap,
+        dialect,
+        execute,
+        0
+      );
+      return;
+    }
+    yield Promise.all(
+      segments.map(
+        (segment) => executeSegmentBase(
+          segment,
+          parentRows,
+          allModels,
+          modelMap,
+          dialect,
+          execute,
+          0
+        )
+      )
+    );
+  });
+}
+
+// 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;
+      }
+    }
+  }
+}
+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 {
+      segments,
+      parentSql,
+      parentParams,
+      parentModel,
+      allModels,
+      modelMap,
+      dialect,
+      execute
+    } = params;
+    if (segments.length === 0) {
+      throw new Error("executeWhereInSegmentsStreaming requires segments");
+    }
+    if (dialect !== "postgres") {
+      throw new Error("Streaming WHERE IN requires postgres dialect");
+    }
+    const parentRows = yield execute(parentSql, parentParams);
+    if (parentRows.length === 0) return [];
+    for (const row of parentRows) {
+      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) {
+        row[seg.relationName] = seg.isList ? [] : null;
+      }
+    }
+    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
+        execute,
+        depth
+      );
+      return;
+    }
+    yield Promise.all(
+      segments.map(
+        (seg) => resolveSingleSegment(
+          seg,
+          parentRows,
+          allModels,
+          modelMap,
+          dialect,
+          execute,
+          depth
+        )
+      )
+    );
+  });
+}
+function resolveSingleSegment(segment, parentRows, allModels, modelMap, dialect, execute, depth) {
+  return __async(this, null, function* () {
+    const childModel = modelMap.get(segment.childModelName);
+    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,
+      uniqueIds
+    );
+    const needsStripFk = ensureFkInSelect2(childArgs, segment.fkFieldName);
+    const childPlan = planQueryStrategy({
+      model: childModel,
+      args: childArgs,
+      allModels});
+    const result = buildSQL(
+      childModel,
+      allModels,
+      "findMany",
+      childPlan.filteredArgs,
+      dialect
+    );
+    let children = yield execute(result.sql, result.params);
+    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);
+    }
+    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];
+          }
+        }
+      }
+    }
+    const parentKeyIndex = buildParentKeyIndex(
+      parentRows,
+      segment.parentKeyFieldName
+    );
+    stitchChildrenToParents(children, segment, parentKeyIndex);
+    if (needsStripFk) {
+      for (const child of children) {
+        delete child[segment.fkFieldName];
+      }
     }
   });
 }
+function buildChildArgs2(relArgs, fkFieldName, parentIds) {
+  const base = relArgs === true || typeof relArgs !== "object" || relArgs === null ? {} : __spreadValues({}, relArgs);
+  const existingWhere = base.where;
+  const inCondition = { [fkFieldName]: { in: parentIds } };
+  base.where = existingWhere ? { AND: [existingWhere, inCondition] } : inCondition;
+  return base;
+}
 
 // src/builder/select/core-reducer.ts
 var getOrCreateRelationMap = (relationMaps, parent) => {
@@ -7969,10 +8773,6 @@ var createChildObject = (row, rel) => {
   }
   return child;
 };
-var extractChildKey = (row, rel) => {
-  const cols = rel.primaryKeyFields.map((f) => `${rel.path}.${f}`);
-  return buildCompositeKey(row, cols);
-};
 var attachChildToParent = (parent, child, rel) => {
   if (rel.cardinality === "many") {
     parent[rel.name].push(child);
@@ -7980,17 +8780,25 @@ var attachChildToParent = (parent, child, rel) => {
     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, rel, row) => {
-    const childKey = extractChildKey(row, rel);
-    if (!childKey) return;
+  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)) {
-      const existing = childMap.get(childKey);
-      if (rel.nestedIncludes) {
-        for (const nested of rel.nestedIncludes.includedRelations) {
-          processRelation2(existing, nested, row);
+      if (nested) {
+        const existing = childMap.get(childKey);
+        for (const nestedPrepared of nested) {
+          processRelation2(existing, nestedPrepared, row);
         }
       }
       return;
@@ -7998,9 +8806,9 @@ var createRelationProcessor = (relationMaps) => {
     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);
+    if (nested) {
+      for (const nestedPrepared of nested) {
+        processRelation2(child, nestedPrepared, row);
       }
     }
   };
@@ -8013,31 +8821,28 @@ var createCoreReducer = (config) => {
   const jsonSet = getJsonFieldSet(config.parentModel);
   const parentPkFields = getPrimaryKeyFields(config.parentModel);
   const includedRelations = config.includedRelations;
-  const extractParentKey = (row) => buildCompositeKey(row, parentPkFields);
+  const preparedRelations = prepareRelations(includedRelations);
   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);
+    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 _a;
-      return (_a = parentMap.get(key)) != null ? _a : null;
+      var _a3;
+      return (_a3 = parentMap.get(key)) != null ? _a3 : null;
     },
     getAllParents: () => Array.from(parentMap.values()),
     getParentMap: () => parentMap
@@ -8097,135 +8902,9 @@ function createProgressiveReducer(config) {
   };
 }
 
-// src/builder/select/streaming-where-in-executor.ts
-function executeWhereInSegmentsStreaming(params) {
-  return __async(this, null, function* () {
-    const {
-      segments,
-      parentSql,
-      parentParams,
-      parentModel,
-      allModels,
-      modelMap,
-      dialect,
-      execute,
-      batchSize = 100,
-      maxConcurrency = 10
-    } = params;
-    if (segments.length === 0) {
-      throw new Error("executeWhereInSegmentsStreaming requires segments");
-    }
-    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);
-    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;
-      }
-      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());
-          }
-        }
-      }
-    }
-    for (const seg of segments) {
-      const batch = batches.get(seg.relationName);
-      if (batch.length > 0) {
-        const promise = fetchAndAttachChildren(
-          seg,
-          batch,
-          parentMap,
-          allModels,
-          modelMap,
-          dialect,
-          execute
-        );
-        inFlightMap.set(promise, seg.relationName);
-        promise.finally(() => {
-          inFlightMap.delete(promise);
-        });
-      }
-    }
-    yield Promise.all(inFlightMap.keys());
-    return Array.from(parentMap.values());
-  });
-}
-function fetchAndAttachChildren(segment, parentIds, parentMap, allModels, modelMap, dialect, execute) {
-  return __async(this, null, function* () {
-    const childModel = modelMap.get(segment.childModelName);
-    if (!childModel) return;
-    const childArgs = buildChildArgs2(
-      segment.relArgs,
-      segment.fkFieldName,
-      parentIds
-    );
-    const result = buildSQL(
-      childModel,
-      allModels,
-      "findMany",
-      childArgs,
-      dialect
-    );
-    let children = yield execute(result.sql, result.params);
-    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] = [];
-        }
-        parent[segment.relationName].push(child);
-      } else {
-        parent[segment.relationName] = child;
-      }
-    }
-  });
-}
-function buildChildArgs2(relArgs, fkFieldName, parentIds) {
-  const base = relArgs === true || typeof relArgs !== "object" || relArgs === null ? {} : __spreadValues({}, relArgs);
-  const existingWhere = base.where;
-  const inCondition = { [fkFieldName]: { in: parentIds } };
-  base.where = existingWhere ? { AND: [existingWhere, inCondition] } : inCondition;
-  return base;
-}
-
 // 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) {
@@ -8233,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;
 }
@@ -8249,22 +8931,44 @@ 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 rowTransformer = getRowTransformer(method);
+    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 reducer = createStreamingReducer(config);
       yield client.unsafe(sql, normalizedParams).forEach((row) => {
-        reducer.processRow(rowTransformer ? rowTransformer(row) : row);
+        reducer.processRow(row);
       });
       return reducer.getResults();
     }
+    const needsTransform = method === "groupBy" || method === "aggregate" || method === "count";
+    if (!needsTransform) {
+      const results2 = [];
+      yield client.unsafe(sql, normalizedParams).forEach((row) => {
+        results2.push(row);
+      });
+      return results2;
+    }
+    const rowTransformer = getRowTransformer(method);
     const results = [];
-    yield client.unsafe(sql, normalizedParams).forEach((row) => {
-      results.push(rowTransformer ? rowTransformer(row) : row);
-    });
+    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 results;
   });
 }
@@ -8398,6 +9102,7 @@ function generateSQLByModel(directives) {
   return byModel;
 }
 
+exports.buildArrayAggReducerConfig = buildArrayAggReducerConfig;
 exports.buildBatchCountSql = buildBatchCountSql;
 exports.buildBatchSql = buildBatchSql;
 exports.buildReducerConfig = buildReducerConfig;
@@ -8412,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;