prisma-sql 1.64.0 → 1.65.0

package/dist/generator.js

@@ -69,7 +69,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.64.0",
+      version: "1.65.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -760,81 +760,6 @@ function needsQuoting(identifier) {
   return false;
 }
 
-// src/builder/shared/model-field-cache.ts
-var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
-function quoteIdent(id) {
-  if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error("quoteIdent: identifier is required and cannot be empty");
-  }
-  for (let i = 0; i < id.length; i++) {
-    const code = id.charCodeAt(i);
-    if (code >= 0 && code <= 31 || code === 127) {
-      throw new Error(
-        `quoteIdent: identifier contains invalid characters: ${JSON.stringify(id)}`
-      );
-    }
-  }
-  if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
-  }
-  return id;
-}
-function ensureFullCache(model) {
-  let cache = MODEL_CACHE.get(model);
-  if (!cache) {
-    const fieldInfo = /* @__PURE__ */ new Map();
-    const scalarFields = /* @__PURE__ */ new Set();
-    const relationFields = /* @__PURE__ */ new Set();
-    const columnMap = /* @__PURE__ */ new Map();
-    const fieldByName = /* @__PURE__ */ new Map();
-    const quotedColumns = /* @__PURE__ */ new Map();
-    for (const f of model.fields) {
-      const info = {
-        name: f.name,
-        dbName: f.dbName || f.name,
-        type: f.type,
-        isRelation: !!f.isRelation,
-        isRequired: !!f.isRequired
-      };
-      fieldInfo.set(f.name, info);
-      fieldByName.set(f.name, f);
-      if (info.isRelation) {
-        relationFields.add(f.name);
-      } else {
-        scalarFields.add(f.name);
-        const dbName = info.dbName;
-        columnMap.set(f.name, dbName);
-        quotedColumns.set(f.name, quoteIdent(dbName));
-      }
-    }
-    cache = {
-      fieldInfo,
-      scalarFields,
-      relationFields,
-      columnMap,
-      fieldByName,
-      quotedColumns
-    };
-    MODEL_CACHE.set(model, cache);
-  }
-  return cache;
-}
-function getFieldInfo(model, fieldName) {
-  return ensureFullCache(model).fieldInfo.get(fieldName);
-}
-function getScalarFieldSet(model) {
-  return ensureFullCache(model).scalarFields;
-}
-function getRelationFieldSet(model) {
-  return ensureFullCache(model).relationFields;
-}
-function getColumnMap(model) {
-  return ensureFullCache(model).columnMap;
-}
-function getQuotedColumn(model, fieldName) {
-  return ensureFullCache(model).quotedColumns.get(fieldName);
-}
-
 // src/builder/shared/sql-utils.ts
 function containsControlChars(s) {
   for (let i = 0; i < s.length; i++) {
@@ -1136,6 +1061,70 @@ function normalizeKeyList(input) {
   return s.length > 0 ? [s] : [];
 }
 
+// src/builder/shared/model-field-cache.ts
+var SCALAR_FIELD_CACHE = /* @__PURE__ */ new WeakMap();
+var RELATION_FIELD_CACHE = /* @__PURE__ */ new WeakMap();
+var COLUMN_MAP_CACHE = /* @__PURE__ */ new WeakMap();
+var QUOTED_COLUMN_CACHE = /* @__PURE__ */ new WeakMap();
+var FIELD_BY_NAME_CACHE = /* @__PURE__ */ new WeakMap();
+function getScalarFieldSet(model) {
+  let cached = SCALAR_FIELD_CACHE.get(model);
+  if (cached) return cached;
+  const set = /* @__PURE__ */ new Set();
+  for (const f of model.fields) {
+    if (!f.isRelation) set.add(f.name);
+  }
+  SCALAR_FIELD_CACHE.set(model, set);
+  return set;
+}
+function getRelationFieldSet(model) {
+  let cached = RELATION_FIELD_CACHE.get(model);
+  if (cached) return cached;
+  const set = /* @__PURE__ */ new Set();
+  for (const f of model.fields) {
+    if (f.isRelation) set.add(f.name);
+  }
+  RELATION_FIELD_CACHE.set(model, set);
+  return set;
+}
+function getColumnMap(model) {
+  let cached = COLUMN_MAP_CACHE.get(model);
+  if (cached) return cached;
+  const map = /* @__PURE__ */ new Map();
+  for (const f of model.fields) {
+    if (f.dbName && f.dbName !== f.name) {
+      map.set(f.name, f.dbName);
+    }
+  }
+  COLUMN_MAP_CACHE.set(model, map);
+  return map;
+}
+function getQuotedColumn(model, fieldName) {
+  let cache = QUOTED_COLUMN_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    QUOTED_COLUMN_CACHE.set(model, cache);
+  }
+  const cached = cache.get(fieldName);
+  if (cached !== void 0) return cached;
+  const columnMap = getColumnMap(model);
+  const columnName = columnMap.get(fieldName) || fieldName;
+  const quoted = quote(columnName);
+  cache.set(fieldName, quoted);
+  return quoted;
+}
+function getFieldByName(model, fieldName) {
+  let cache = FIELD_BY_NAME_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    for (const field of model.fields) {
+      cache.set(field.name, field);
+    }
+    FIELD_BY_NAME_CACHE.set(model, cache);
+  }
+  return cache.get(fieldName);
+}
+
 // src/builder/joins.ts
 function isRelationField(fieldName, model) {
   return getRelationFieldSet(model).has(fieldName);
@@ -1249,11 +1238,18 @@ var getNextSort = (sortRaw) => {
   return sortRaw;
 };
 var flipObjectSort = (obj) => {
-  const sortRaw = obj.sort;
-  const out = __spreadProps(__spreadValues({}, obj), { sort: getNextSort(sortRaw) });
-  const nullsRaw = obj.nulls;
-  if (typeof nullsRaw === "string") {
-    out.nulls = flipNulls(nullsRaw);
+  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;
 };
@@ -1299,7 +1295,7 @@ var normalizePairs = (pairs, parseValue) => {
   return pairs.map(([field, rawValue]) => {
     const parsed = parseValue(rawValue, field);
     return {
-      [field]: parsed.nulls !== void 0 ? { sort: parsed.direction, nulls: parsed.nulls } : parsed.direction
+      [field]: parsed.nulls !== void 0 ? { direction: parsed.direction, nulls: parsed.nulls } : parsed.direction
     };
   });
 };
@@ -1348,37 +1344,113 @@ function ensureDeterministicOrderByInput(args) {
 }
 
 // src/builder/shared/validators/field-assertions.ts
-var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
-function assertScalarField(model, fieldName, context) {
-  const field = getFieldInfo(model, fieldName);
+function assertFieldExists(fieldName, model, path) {
+  const field = getFieldByName(model, fieldName);
   if (!field) {
     throw createError(
-      `${context} references unknown field '${fieldName}' on model ${model.name}`,
+      `Field '${fieldName}' does not exist on model ${model.name}`,
       {
         field: fieldName,
         modelName: model.name,
-        availableFields: model.fields.map((f) => f.name)
+        path
       }
     );
   }
+  return field;
+}
+function assertScalarField(model, fieldName, context) {
+  const field = getFieldByName(model, fieldName);
+  if (!field) {
+    throw new Error(
+      `${context}: field '${fieldName}' does not exist on model '${model.name}'`
+    );
+  }
   if (field.isRelation) {
-    throw createError(
-      `${context} does not support relation field '${fieldName}'`,
-      { field: fieldName, modelName: model.name }
+    throw new Error(
+      `${context}: field '${fieldName}' is a relation field, expected scalar field`
     );
   }
-  return field;
 }
 function assertNumericField(model, fieldName, context) {
-  const field = assertScalarField(model, fieldName, context);
-  const baseType = field.type.replace(/\[\]|\?/g, "");
-  if (!NUMERIC_TYPES.has(baseType)) {
+  assertScalarField(model, fieldName, context);
+  const field = getFieldByName(model, fieldName);
+  if (!field) return;
+  const numericTypes = /* @__PURE__ */ new Set([
+    "Int",
+    "BigInt",
+    "Float",
+    "Decimal",
+    "Int?",
+    "BigInt?",
+    "Float?",
+    "Decimal?"
+  ]);
+  if (!numericTypes.has(field.type)) {
+    throw new Error(
+      `${context}: field '${fieldName}' must be numeric (Int, BigInt, Float, Decimal), got '${field.type}'`
+    );
+  }
+}
+function assertValidOperator(fieldName, operator, fieldType, path, modelName) {
+  const stringOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "in",
+    "notIn",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "mode",
+    "search"
+  ]);
+  const numericOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "in",
+    "notIn",
+    "lt",
+    "lte",
+    "gt",
+    "gte"
+  ]);
+  const jsonOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "path",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ]);
+  const isString = fieldType === "String" || fieldType === "String?";
+  const isNumeric = ["Int", "BigInt", "Float", "Decimal"].some(
+    (t) => fieldType === t || fieldType === `${t}?`
+  );
+  const isJson = fieldType === "Json" || fieldType === "Json?";
+  if (isString && !stringOps.has(operator)) {
     throw createError(
-      `${context} requires numeric field, got '${field.type}'`,
-      { field: fieldName, modelName: model.name }
+      `Operator '${operator}' is not valid for String field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
+    );
+  }
+  if (isNumeric && !numericOps.has(operator)) {
+    throw createError(
+      `Operator '${operator}' is not valid for numeric field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
+    );
+  }
+  if (isJson && !jsonOps.has(operator)) {
+    throw createError(
+      `Operator '${operator}' is not valid for Json field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
     );
   }
-  return field;
 }
 
 // src/builder/pagination.ts
@@ -1892,6 +1964,14 @@ function handleInOperator(expr, op, val, params, dialect) {
   if (val.length === 0) {
     return op === Ops.IN ? "0=1" : "1=1";
   }
+  if (dialect === "sqlite" && val.length <= 30) {
+    const placeholders = [];
+    for (const item of val) {
+      placeholders.push(params.add(item));
+    }
+    const list = placeholders.join(", ");
+    return op === Ops.IN ? `${expr} IN (${list})` : `${expr} NOT IN (${list})`;
+  }
   const paramValue = prepareArrayParam(val, dialect);
   const placeholder = params.add(paramValue);
   return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
@@ -2427,57 +2507,6 @@ function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
   return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
 }
 
-// src/builder/shared/validators/field-validators.ts
-function assertFieldExists(name, model, path) {
-  const field = model.fields.find((f) => f.name === name);
-  if (!isNotNullish(field)) {
-    throw createError(`Field '${name}' does not exist on '${model.name}'`, {
-      field: name,
-      path,
-      modelName: model.name,
-      availableFields: model.fields.map((f) => f.name)
-    });
-  }
-  return field;
-}
-function assertValidOperator(fieldName, op, fieldType, path, modelName) {
-  if (!isNotNullish(fieldType)) return;
-  const ARRAY_OPS = /* @__PURE__ */ new Set([
-    Ops.HAS,
-    Ops.HAS_SOME,
-    Ops.HAS_EVERY,
-    Ops.IS_EMPTY
-  ]);
-  const JSON_OPS2 = /* @__PURE__ */ new Set([
-    Ops.PATH,
-    Ops.STRING_CONTAINS,
-    Ops.STRING_STARTS_WITH,
-    Ops.STRING_ENDS_WITH
-  ]);
-  const isArrayOp = ARRAY_OPS.has(op);
-  const isFieldArray = isArrayType(fieldType);
-  const arrayOpMismatch = isArrayOp && !isFieldArray;
-  if (arrayOpMismatch) {
-    throw createError(`'${op}' requires array field, got '${fieldType}'`, {
-      operator: op,
-      field: fieldName,
-      path,
-      modelName
-    });
-  }
-  const isJsonOp = JSON_OPS2.has(op);
-  const isFieldJson = isJsonType(fieldType);
-  const jsonOpMismatch = isJsonOp && !isFieldJson;
-  if (jsonOpMismatch) {
-    throw createError(`'${op}' requires JSON field, got '${fieldType}'`, {
-      operator: op,
-      field: fieldName,
-      path,
-      modelName
-    });
-  }
-}
-
 // src/builder/where/builder.ts
 var MAX_QUERY_DEPTH = 50;
 var EMPTY_JOINS = Object.freeze([]);
@@ -2534,6 +2563,23 @@ function buildRelationFilter(fieldName, value, ctx, builder) {
   }
   return buildTopLevelRelation(fieldName, value, ctx2, builder);
 }
+function buildSimpleEquality(expr, value, ctx) {
+  if (value === null) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+  const placeholder = ctx.params.addAuto(value);
+  return `${expr} = ${placeholder}`;
+}
+function isSimpleWhere(where) {
+  const keys = Object.keys(where);
+  if (keys.length !== 1) return false;
+  const key = keys[0];
+  const value = where[key];
+  if (value === null) return true;
+  if (value === void 0) return false;
+  if (typeof value === "string") return true;
+  if (typeof value === "number") return true;
+  if (typeof value === "boolean") return true;
+  return false;
+}
 function buildWhereEntry(key, value, ctx, builder) {
   const op = asLogicalOperator(key);
   if (op) return buildLogical(op, value, ctx, builder);
@@ -2560,6 +2606,14 @@ function buildWhereInternal(where, ctx, builder) {
   if (isEmptyWhere(where)) {
     return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
   }
+  if (isSimpleWhere(where)) {
+    const key = Object.keys(where)[0];
+    const value = where[key];
+    assertFieldExists(key, ctx.model, ctx.path);
+    const expr = col(ctx.alias, key, ctx.model);
+    const clause = buildSimpleEquality(expr, value, ctx);
+    return freezeResult(clause, EMPTY_JOINS);
+  }
   const allJoins = [];
   const clauses = [];
   for (const key in where) {
@@ -2686,10 +2740,16 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
 }
 
 // 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;
   const raw = String(input);
   const n = raw.length;
-  if (n === 0) return "_t";
+  if (n === 0) {
+    SAFE_IDENTIFIER_CACHE.set(input, "_t");
+    return "_t";
+  }
   let out = "";
   for (let i = 0; i < n; i++) {
     const c = raw.charCodeAt(i);
@@ -2701,7 +2761,11 @@ function toSafeSqlIdentifier(input) {
   const c0 = out.charCodeAt(0);
   const startsOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
   const lowered = (startsOk ? out : `_${out}`).toLowerCase();
-  return ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
+  const result = ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
+  if (SAFE_IDENTIFIER_CACHE.size < 1e3) {
+    SAFE_IDENTIFIER_CACHE.set(input, result);
+  }
+  return result;
 }
 function createAliasGenerator(maxAliases = 1e4) {
   let counter = 0;
@@ -2812,9 +2876,17 @@ function assertCanAddParam(currentIndex) {
     );
   }
 }
-function formatPosition(position) {
+var POSTGRES_POSITION_CACHE = new Array(100);
+for (let i = 0; i < 100; i++) {
+  POSTGRES_POSITION_CACHE[i] = `$${i + 1}`;
+}
+function formatPositionPostgres(position) {
+  if (position <= 100) return POSTGRES_POSITION_CACHE[position - 1];
   return `$${position}`;
 }
+function formatPositionSqlite(_position) {
+  return "?";
+}
 function validateDynamicName(dynamicName) {
   const dn = dynamicName.trim();
   if (dn.length === 0) {
@@ -2822,13 +2894,14 @@ function validateDynamicName(dynamicName) {
   }
   return dn;
 }
-function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
+function createStoreInternal(startIndex, dialect, initialParams = [], initialMappings = []) {
   let index = startIndex;
   const params = initialParams.length > 0 ? initialParams.slice() : [];
   const mappings = initialMappings.length > 0 ? initialMappings.slice() : [];
   const dynamicNameToIndex = buildDynamicNameIndex(mappings);
   let dirty = true;
   let cachedSnapshot = null;
+  const formatPosition = dialect === "sqlite" ? formatPositionSqlite : formatPositionPostgres;
   function addDynamic(dynamicName) {
     const dn = validateDynamicName(dynamicName);
     const existing = dynamicNameToIndex.get(dn);
@@ -2878,10 +2951,13 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     snapshot,
     get index() {
       return index;
+    },
+    get dialect() {
+      return dialect;
     }
   };
 }
-function createParamStore(startIndex = 1) {
+function createParamStore(startIndex = 1, dialect = "postgres") {
   if (!Number.isInteger(startIndex) || startIndex < 1) {
     throw new Error(`Start index must be integer >= 1, got ${startIndex}`);
   }
@@ -2890,12 +2966,13 @@ function createParamStore(startIndex = 1) {
       `Start index too high (${startIndex}), risk of overflow at MAX_SAFE_INTEGER`
     );
   }
-  return createStoreInternal(startIndex);
+  return createStoreInternal(startIndex, dialect);
 }
-function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
+function createParamStoreFrom(existingParams, existingMappings, nextIndex, dialect = "postgres") {
   validateState(existingParams, existingMappings, nextIndex);
   return createStoreInternal(
     nextIndex,
+    dialect,
     existingParams.slice(),
     existingMappings.slice()
   );
@@ -2936,6 +3013,7 @@ function buildWhereClause(where, options) {
 }
 
 // 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)) {
@@ -2983,13 +3061,29 @@ 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);
+}
+function cacheDefaultSelect(model, alias, sql) {
+  let cache = DEFAULT_SELECT_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    DEFAULT_SELECT_CACHE.set(model, cache);
+  }
+  cache.set(alias, sql);
+}
 function buildSelectFields(args, model, alias) {
   const scalarSet = getScalarFieldSet(model);
   const relationSet = getRelationFieldSet(model);
   if (!isNotNullish(args.select)) {
-    return buildDefaultScalarFields(model, alias).join(
+    const cached = getDefaultSelectCached(model, alias);
+    if (cached) return cached;
+    const result = buildDefaultScalarFields(model, alias).join(
       SQL_SEPARATORS.FIELD_LIST
     );
+    cacheDefaultSelect(model, alias, result);
+    return result;
   }
   const entries = toSelectEntries(args.select);
   validateSelectKeys(entries, scalarSet, relationSet);
@@ -3067,8 +3161,6 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
   }
   return buildAllScalarParts(relModel, relAlias).join(SQL_SEPARATORS.FIELD_LIST);
 }
-
-// src/builder/select/includes.ts
 var MAX_INCLUDE_DEPTH = 10;
 var MAX_TOTAL_SUBQUERIES = 100;
 var MAX_TOTAL_INCLUDES = 50;
@@ -3256,8 +3348,12 @@ function buildWhereParts(whereInput, relModel, relAlias, ctx) {
     dialect: ctx.dialect
   });
   const joins = whereResult.joins.join(" ");
-  const whereClause = isValidWhereClause(whereResult.clause) ? ` ${SQL_TEMPLATES.AND} ${whereResult.clause}` : "";
-  return { joins, whereClause };
+  const hasClause = isValidWhereClause(whereResult.clause);
+  return {
+    joins,
+    whereClause: hasClause ? ` ${SQL_TEMPLATES.AND} ${whereResult.clause}` : "",
+    rawClause: hasClause ? whereResult.clause : ""
+  };
 }
 function limitOneSql(sql, params, skipVal, scope) {
   if (isNotNullish(skipVal)) {
@@ -3302,8 +3398,10 @@ function buildListIncludeSpec(args) {
   const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
   const noTake = !isNotNullish(args.takeVal);
   const noSkip = !isNotNullish(args.skipVal);
+  const emptyJson = args.ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
   if (args.ctx.dialect === "postgres" && noTake && noSkip) {
-    const selectExpr2 = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+    const rawAgg = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+    const selectExpr2 = `COALESCE(${rawAgg}, ${emptyJson})`;
     const sql2 = buildBaseSql({
       selectExpr: selectExpr2,
       relTable: args.relTable,
@@ -3333,10 +3431,154 @@ function buildListIncludeSpec(args) {
     args.skipVal,
     scopeBase
   );
-  const selectExpr = jsonAgg("row", args.ctx.dialect);
+  const agg = jsonAgg("row", args.ctx.dialect);
+  const selectExpr = `COALESCE(${agg}, ${emptyJson})`;
   const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${SQL_TEMPLATES.AS} ${rowAlias}`;
   return Object.freeze({ name: args.relName, sql, isOneToOne: false });
 }
+function resolveIncludeKeyPairs(field) {
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (fkFields.length === 0) {
+    throw new Error(
+      `Relation '${field.name}' is missing foreignKey for join-based include`
+    );
+  }
+  const refs = normalizeKeyList(field.references);
+  const refFields = refs.length > 0 ? refs : fkFields.length === 1 ? ["id"] : [];
+  if (refFields.length !== fkFields.length) {
+    throw new Error(
+      `Relation '${field.name}' references count doesn't match foreignKey count`
+    );
+  }
+  return {
+    relKeyFields: field.isForeignKeyLocal ? refFields : fkFields,
+    parentKeyFields: field.isForeignKeyLocal ? fkFields : refFields
+  };
+}
+function buildFkSelectList(relAlias, relModel, relKeyFields) {
+  return relKeyFields.map((f, i) => `${relAlias}.${quoteColumn(relModel, f)} AS "__fk${i}"`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildFkGroupByUnqualified(relKeyFields) {
+  return relKeyFields.map((_, i) => `"__fk${i}"`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildJoinOnCondition(joinAlias, parentAlias, parentModel, parentKeyFields) {
+  const parts = parentKeyFields.map(
+    (f, i) => `${joinAlias}."__fk${i}" = ${parentAlias}.${quoteColumn(parentModel, f)}`
+  );
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function buildPartitionBy(relAlias, relModel, relKeyFields) {
+  return relKeyFields.map((f) => `${relAlias}.${quoteColumn(relModel, f)}`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function hasNestedRelationInArgs(relArgs, relModel) {
+  if (!isPlainObject(relArgs)) return false;
+  const relationSet = getRelationFieldSet(relModel);
+  const checkSource = (src) => {
+    if (!isPlainObject(src)) return false;
+    for (const k of Object.keys(src)) {
+      if (relationSet.has(k) && src[k] !== false)
+        return true;
+    }
+    return false;
+  };
+  if (checkSource(relArgs.include)) return true;
+  if (checkSource(relArgs.select)) return true;
+  return false;
+}
+function canUseJoinInclude(dialect, isList, takeVal, skipVal, depth, outerHasLimit, hasNestedIncludes2) {
+  if (dialect !== "postgres") return false;
+  if (!isList) return false;
+  if (depth > 0) return false;
+  if (outerHasLimit) return false;
+  if (hasNestedIncludes2) return false;
+  if (isDynamicParameter(takeVal) || isDynamicParameter(skipVal)) return false;
+  return true;
+}
+function buildJoinBasedNonPaginated(args) {
+  const { relKeyFields, parentKeyFields } = resolveIncludeKeyPairs(args.field);
+  const joinAlias = args.ctx.aliasGen.next(`__inc_${args.relName}`);
+  const fkSelect = buildFkSelectList(args.relAlias, args.relModel, relKeyFields);
+  const fkGroupBy = buildPartitionBy(args.relAlias, args.relModel, relKeyFields);
+  const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  const aggExpr = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+  const joinsPart = args.whereJoins ? ` ${args.whereJoins}` : "";
+  const wherePart = args.rawWhereClause ? ` ${SQL_TEMPLATES.WHERE} ${args.rawWhereClause}` : "";
+  const subquery = `SELECT ${fkSelect}${SQL_SEPARATORS.FIELD_LIST}${aggExpr} AS __agg FROM ${args.relTable} ${args.relAlias}${joinsPart}${wherePart} GROUP BY ${fkGroupBy}`;
+  const onCondition = buildJoinOnCondition(
+    joinAlias,
+    args.ctx.parentAlias,
+    args.ctx.model,
+    parentKeyFields
+  );
+  const joinSql = `LEFT JOIN (${subquery}) ${joinAlias} ON ${onCondition}`;
+  const selectExpr = `COALESCE(${joinAlias}.__agg, '[]'::json) AS ${quote(args.relName)}`;
+  return Object.freeze({
+    name: args.relName,
+    sql: "",
+    isOneToOne: false,
+    joinSql,
+    selectExpr
+  });
+}
+function buildJoinBasedPaginated(args) {
+  const { relKeyFields, parentKeyFields } = resolveIncludeKeyPairs(args.field);
+  const joinAlias = args.ctx.aliasGen.next(`__inc_${args.relName}`);
+  const rankedAlias = args.ctx.aliasGen.next(`__ranked_${args.relName}`);
+  const fkSelect = buildFkSelectList(args.relAlias, args.relModel, relKeyFields);
+  const partitionBy = buildPartitionBy(
+    args.relAlias,
+    args.relModel,
+    relKeyFields
+  );
+  const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  const orderExpr = args.orderBySql || `${args.relAlias}.${quoteColumn(args.relModel, "id")} ASC`;
+  const joinsPart = args.whereJoins ? ` ${args.whereJoins}` : "";
+  const wherePart = args.rawWhereClause ? ` ${SQL_TEMPLATES.WHERE} ${args.rawWhereClause}` : "";
+  const innerSql = `SELECT ${fkSelect}${SQL_SEPARATORS.FIELD_LIST}${rowExpr} AS __row${SQL_SEPARATORS.FIELD_LIST}ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY ${orderExpr}) AS __rn FROM ${args.relTable} ${args.relAlias}${joinsPart}${wherePart}`;
+  const scopeBase = buildIncludeScope(args.ctx.includePath);
+  const rnFilterParts = [];
+  if (isNotNullish(args.skipVal) && args.skipVal > 0) {
+    const skipPh = addAutoScoped(
+      args.ctx.params,
+      args.skipVal,
+      `${scopeBase}.skip`
+    );
+    rnFilterParts.push(`__rn > ${skipPh}`);
+    if (isNotNullish(args.takeVal)) {
+      const takePh = addAutoScoped(
+        args.ctx.params,
+        args.takeVal,
+        `${scopeBase}.take`
+      );
+      rnFilterParts.push(`__rn <= (${skipPh} + ${takePh})`);
+    }
+  } else if (isNotNullish(args.takeVal)) {
+    const takePh = addAutoScoped(
+      args.ctx.params,
+      args.takeVal,
+      `${scopeBase}.take`
+    );
+    rnFilterParts.push(`__rn <= ${takePh}`);
+  }
+  const rnFilter = rnFilterParts.length > 0 ? ` ${SQL_TEMPLATES.WHERE} ${rnFilterParts.join(SQL_SEPARATORS.CONDITION_AND)}` : "";
+  const fkGroupByOuter = buildFkGroupByUnqualified(relKeyFields);
+  const outerSql = `SELECT ${fkGroupByOuter}${SQL_SEPARATORS.FIELD_LIST}json_agg(__row ORDER BY __rn) AS __agg FROM (${innerSql}) ${rankedAlias}${rnFilter} GROUP BY ${fkGroupByOuter}`;
+  const onCondition = buildJoinOnCondition(
+    joinAlias,
+    args.ctx.parentAlias,
+    args.ctx.model,
+    parentKeyFields
+  );
+  const joinSql = `LEFT JOIN (${outerSql}) ${joinAlias} ON ${onCondition}`;
+  const selectExpr = `COALESCE(${joinAlias}.__agg, '[]'::json) AS ${quote(args.relName)}`;
+  return Object.freeze({
+    name: args.relName,
+    sql: "",
+    isOneToOne: false,
+    joinSql,
+    selectExpr
+  });
+}
 function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const relTable = getRelationTableReference(relModel, ctx.dialect);
   const relAlias = ctx.aliasGen.next(relName);
@@ -3393,6 +3635,48 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     });
     return Object.freeze({ name: relName, sql, isOneToOne: true });
   }
+  const depth = ctx.depth || 0;
+  const outerHasLimit = ctx.outerHasLimit === true;
+  const nestedIncludes = hasNestedRelationInArgs(relArgs, relModel);
+  if (canUseJoinInclude(
+    ctx.dialect,
+    isList,
+    adjusted.takeVal,
+    paginationConfig.skipVal,
+    depth,
+    outerHasLimit,
+    nestedIncludes
+  )) {
+    const hasTakeOrSkip = isNotNullish(adjusted.takeVal) || isNotNullish(paginationConfig.skipVal);
+    if (!hasTakeOrSkip) {
+      return buildJoinBasedNonPaginated({
+        relName,
+        relTable,
+        relAlias,
+        relModel,
+        field,
+        whereJoins: whereParts.joins,
+        rawWhereClause: whereParts.rawClause,
+        orderBySql,
+        relSelect,
+        ctx
+      });
+    }
+    return buildJoinBasedPaginated({
+      relName,
+      relTable,
+      relAlias,
+      relModel,
+      field,
+      whereJoins: whereParts.joins,
+      rawWhereClause: whereParts.rawClause,
+      orderBySql,
+      relSelect,
+      takeVal: adjusted.takeVal,
+      skipVal: paginationConfig.skipVal,
+      ctx
+    });
+  }
   return buildListIncludeSpec({
     relName,
     relTable,
@@ -3462,14 +3746,14 @@ function buildIncludeSqlInternal(args, ctx) {
       buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, __spreadProps(__spreadValues({}, ctx), {
         includePath: nextIncludePath,
         visitPath: currentPath,
-        depth: depth + 1,
+        depth,
         stats
       }))
     );
   }
   return includes;
 }
-function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
+function buildIncludeSql(args, model, schemas, parentAlias, params, dialect, outerHasLimit = true) {
   const aliasGen = createAliasGenerator();
   const stats = {
     totalIncludes: 0,
@@ -3489,7 +3773,8 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     includePath: [],
     visitPath: [],
     depth: 0,
-    stats
+    stats,
+    outerHasLimit
   });
 }
 function resolveCountRelationOrThrow(relName, model, schemaByName) {
@@ -3527,7 +3812,7 @@ function resolveCountRelationOrThrow(relName, model, schemaByName) {
 function defaultReferencesForCount(fkCount) {
   if (fkCount === 1) return ["id"];
   throw new Error(
-    "Relation count for composite keys requires explicit references matching foreignKey length"
+    "Relation count for composite keys requires explicit references matching..."
   );
 }
 function resolveCountKeyPairs(field) {
@@ -3636,6 +3921,307 @@ function joinNonEmpty(parts, sep) {
   }
   return result;
 }
+
+// src/builder/select/flat-join.ts
+function getPrimaryKeyField(model) {
+  const scalarSet = getScalarFieldSet(model);
+  for (const f of model.fields) {
+    if (f.isId && !f.isRelation && scalarSet.has(f.name)) {
+      return f.name;
+    }
+  }
+  if (scalarSet.has("id")) return "id";
+  throw new Error(
+    `Model ${model.name} has no primary key field. Models must have either a field with isId=true or a field named 'id'.`
+  );
+}
+function findPrimaryKeyFields(model) {
+  const pkFields = model.fields.filter((f) => f.isId && !f.isRelation);
+  if (pkFields.length > 0) return pkFields.map((f) => f.name);
+  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (idField) return ["id"];
+  throw new Error(`Model ${model.name} has no primary key field`);
+}
+function getRelationModel(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 extractIncludeSpecFromArgs(args, model) {
+  const includeSpec = {};
+  const relationSet = getRelationFieldSet(model);
+  if (args.include && isPlainObject(args.include)) {
+    for (const [key, value] of Object.entries(args.include)) {
+      if (value !== false) includeSpec[key] = value;
+    }
+  }
+  if (args.select && isPlainObject(args.select)) {
+    for (const [key, value] of Object.entries(args.select)) {
+      if (!relationSet.has(key)) continue;
+      if (value === false) continue;
+      if (value === true) {
+        includeSpec[key] = true;
+        continue;
+      }
+      if (isPlainObject(value)) {
+        const v = value;
+        if (isPlainObject(v.include) || isPlainObject(v.select)) {
+          includeSpec[key] = value;
+        }
+      }
+    }
+  }
+  return includeSpec;
+}
+function hasChildPagination(relArgs) {
+  if (!isPlainObject(relArgs)) return false;
+  const args = relArgs;
+  if (args.take !== void 0 && args.take !== null) return true;
+  if (args.skip !== void 0 && args.skip !== null) return true;
+  return false;
+}
+function extractNestedIncludeSpec(relArgs, relModel) {
+  const relationSet = getRelationFieldSet(relModel);
+  const out = {};
+  if (!isPlainObject(relArgs)) return out;
+  const obj = relArgs;
+  if (isPlainObject(obj.include)) {
+    for (const [k, v] of Object.entries(
+      obj.include
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      out[k] = v;
+    }
+  }
+  if (isPlainObject(obj.select)) {
+    for (const [k, v] of Object.entries(
+      obj.select
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      if (v === true) {
+        out[k] = true;
+        continue;
+      }
+      if (isPlainObject(v)) {
+        const vv = v;
+        if (isPlainObject(vv.include) || isPlainObject(vv.select)) {
+          out[k] = v;
+        }
+      }
+    }
+  }
+  return out;
+}
+function extractSelectedScalarFields(relArgs, relModel) {
+  const scalarFields = relModel.fields.filter((f) => !f.isRelation).map((f) => f.name);
+  const scalarSet = new Set(scalarFields);
+  if (relArgs === true || !isPlainObject(relArgs)) {
+    return { includeAllScalars: true, selected: scalarFields };
+  }
+  const obj = relArgs;
+  if (!isPlainObject(obj.select)) {
+    return { includeAllScalars: true, selected: scalarFields };
+  }
+  const sel = obj.select;
+  const selected = [];
+  for (const [k, v] of Object.entries(sel)) {
+    if (!scalarSet.has(k)) continue;
+    if (v === true) selected.push(k);
+  }
+  return { includeAllScalars: false, selected };
+}
+function uniqPreserveOrder(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const it of items) {
+    if (seen.has(it)) continue;
+    seen.add(it);
+    out.push(it);
+  }
+  return out;
+}
+function buildChildColumns(args) {
+  const { relModel, relationName, childAlias, prefix, relArgs } = args;
+  const fullPrefix = prefix ? `${prefix}.${relationName}` : relationName;
+  const pkFields = findPrimaryKeyFields(relModel);
+  const scalarSelection = extractSelectedScalarFields(relArgs, relModel);
+  const selectedScalar = scalarSelection.selected;
+  const required = uniqPreserveOrder([...pkFields, ...selectedScalar]);
+  const columns = [];
+  for (const fieldName of required) {
+    const field = relModel.fields.find(
+      (f) => f.name === fieldName && !f.isRelation
+    );
+    if (!field) continue;
+    const colName = field.dbName || field.name;
+    const quotedCol = quote(colName);
+    columns.push(`${childAlias}.${quotedCol} AS "${fullPrefix}.${field.name}"`);
+  }
+  return columns;
+}
+function canUseNestedFlatJoin(relArgs, depth) {
+  if (depth > 10) return false;
+  if (!isPlainObject(relArgs)) return true;
+  if (hasChildPagination(relArgs)) return false;
+  const obj = relArgs;
+  if (obj.include && isPlainObject(obj.include)) {
+    for (const childValue of Object.values(
+      obj.include
+    )) {
+      if (childValue !== false && !canUseNestedFlatJoin(childValue, depth + 1))
+        return false;
+    }
+  }
+  if (obj.select && isPlainObject(obj.select)) {
+    for (const childValue of Object.values(
+      obj.select
+    )) {
+      if (childValue !== false && !canUseNestedFlatJoin(childValue, depth + 1))
+        return false;
+    }
+  }
+  return true;
+}
+function canUseFlatJoinForAll(includeSpec) {
+  for (const value of Object.values(includeSpec)) {
+    if (value === false) continue;
+    if (!canUseNestedFlatJoin(value, 0)) return false;
+  }
+  return true;
+}
+function buildNestedJoins(parentModel, parentAlias, includeSpec, schemas, dialect, prefix, aliasCounter, depth = 0) {
+  if (depth > 10) {
+    throw new Error(
+      `Nested joins exceeded maximum depth of 10 at prefix '${prefix}'`
+    );
+  }
+  const joins = [];
+  const selects = [];
+  const orderBy = [];
+  for (const [relName, relValue] of Object.entries(includeSpec)) {
+    if (relValue === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!isValidRelationField(field)) continue;
+    const relModel = getRelationModel(parentModel, relName, schemas);
+    const relTable = buildTableReference(
+      SQL_TEMPLATES.PUBLIC_SCHEMA,
+      relModel.tableName,
+      dialect
+    );
+    const childAlias = `fj_${aliasCounter.count++}`;
+    const joinCond = joinCondition(
+      field,
+      parentModel,
+      relModel,
+      parentAlias,
+      childAlias
+    );
+    joins.push(`LEFT JOIN ${relTable} ${childAlias} ON ${joinCond}`);
+    selects.push(
+      ...buildChildColumns({
+        relModel,
+        relationName: relName,
+        childAlias,
+        prefix,
+        relArgs: relValue
+      })
+    );
+    const childPkFields = findPrimaryKeyFields(relModel);
+    for (const pkField of childPkFields) {
+      orderBy.push(
+        `${childAlias}.${quoteColumn(relModel, pkField)} ASC NULLS LAST`
+      );
+    }
+    const nested = extractNestedIncludeSpec(relValue, relModel);
+    if (Object.keys(nested).length > 0) {
+      const nestedPrefix = prefix ? `${prefix}.${relName}` : relName;
+      const deeper = buildNestedJoins(
+        relModel,
+        childAlias,
+        nested,
+        schemas,
+        dialect,
+        nestedPrefix,
+        aliasCounter,
+        depth + 1
+      );
+      joins.push(...deeper.joins);
+      selects.push(...deeper.selects);
+      orderBy.push(...deeper.orderBy);
+    }
+  }
+  return { joins, selects, orderBy };
+}
+function buildFlatJoinSql(spec) {
+  const {
+    select,
+    from,
+    whereClause,
+    whereJoins,
+    orderBy,
+    dialect,
+    model,
+    schemas,
+    args
+  } = spec;
+  const includeSpec = extractIncludeSpecFromArgs(args, model);
+  if (Object.keys(includeSpec).length === 0) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  if (!canUseFlatJoinForAll(includeSpec)) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
+  const baseWhere = whereClause && whereClause !== "1=1" ? `WHERE ${whereClause}` : "";
+  const baseOrderBy = orderBy ? `ORDER BY ${orderBy}` : "";
+  let baseSubquery = `
+    SELECT * FROM ${from.table} ${from.alias}
+    ${baseJoins}
+    ${baseWhere}
+    ${baseOrderBy}
+  `.trim();
+  baseSubquery = appendPagination(baseSubquery, spec);
+  const aliasCounter = { count: 0 };
+  const built = buildNestedJoins(
+    model,
+    from.alias,
+    includeSpec,
+    schemas,
+    dialect,
+    "",
+    aliasCounter,
+    0
+  );
+  if (built.joins.length === 0) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  const baseSelect = (select != null ? select : "").trim();
+  const allSelects = [baseSelect, ...built.selects].filter((s) => s && s.trim().length > 0).join(SQL_SEPARATORS.FIELD_LIST);
+  if (!allSelects) {
+    throw new Error("Flat-join SELECT requires at least one selected field");
+  }
+  const pkField = getPrimaryKeyField(model);
+  const orderByParts = [];
+  if (orderBy) orderByParts.push(orderBy);
+  orderByParts.push(`${from.alias}.${quoteColumn(model, pkField)} ASC`);
+  orderByParts.push(...built.orderBy);
+  const finalOrderBy = orderByParts.join(", ");
+  const sql = `
+    SELECT ${allSelects}
+    FROM (${baseSubquery}) ${from.alias}
+    ${built.joins.join(" ")}
+    ORDER BY ${finalOrderBy}
+  `.trim();
+  return { sql, requiresReduction: true, includeSpec };
+}
 function buildWhereSql(conditions) {
   if (!isNonEmptyArray(conditions)) return "";
   return " " + SQL_TEMPLATES.WHERE + " " + conditions.join(SQL_SEPARATORS.CONDITION_AND);
@@ -3670,9 +4256,6 @@ function finalizeSql(sql, params, dialect) {
     paramMappings: snapshot.mappings
   };
 }
-function isIdent(s) {
-  return /^[A-Za-z_]\w*$/.test(s);
-}
 function skipSpaces(s, i) {
   while (i < s.length) {
     const c = s.charCodeAt(i);
@@ -3766,11 +4349,6 @@ function parseSelectField(p, fromAlias) {
   i = skipSpaces(p, i);
   const a = readIdentOrQuoted(p, i);
   const actualAlias = a.text.toLowerCase();
-  if (!isIdent(a.text)) {
-    throw new Error(
-      `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
-    );
-  }
   if (actualAlias !== fromLower) {
     throw new Error(`Expected alias '${fromAlias}', got '${a.text}' in: ${p}`);
   }
@@ -3839,10 +4417,10 @@ function extractDistinctOrderEntries(spec) {
         const value = item[field];
         if (typeof value === "string") {
           entries.push({ field, direction: value });
-        } else {
-          const obj = value;
-          entries.push({ field, direction: obj.sort, nulls: obj.nulls });
+          continue;
         }
+        const obj = value;
+        entries.push({ field, direction: obj.direction, nulls: obj.nulls });
       }
     }
     if (entries.length > 0) return entries;
@@ -3976,19 +4554,43 @@ function buildIncludeColumns(spec) {
   const hasIncludes = isNonEmptyArray(includes);
   const hasCountCols = isNonEmptyString(countCols);
   if (!hasIncludes && !hasCountCols) {
-    return { includeCols: "", selectWithIncludes: baseSelect, countJoins: [] };
+    return {
+      includeCols: "",
+      selectWithIncludes: baseSelect,
+      countJoins: [],
+      includeJoins: []
+    };
   }
   const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
-  const includeCols = hasIncludes ? includes.map((inc) => {
-    const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
-    return expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name);
-  }).join(SQL_SEPARATORS.FIELD_LIST) : "";
-  const allCols = joinNonEmpty(
-    [includeCols, countCols],
+  const correlatedParts = [];
+  const joinIncludeJoins = [];
+  const joinIncludeSelects = [];
+  if (hasIncludes) {
+    for (const inc of includes) {
+      if (inc.joinSql && inc.selectExpr) {
+        joinIncludeJoins.push(inc.joinSql);
+        joinIncludeSelects.push(inc.selectExpr);
+      } else {
+        const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
+        correlatedParts.push(
+          expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name)
+        );
+      }
+    }
+  }
+  const correlatedCols = correlatedParts.join(SQL_SEPARATORS.FIELD_LIST);
+  const joinSelectCols = joinIncludeSelects.join(SQL_SEPARATORS.FIELD_LIST);
+  const allIncludeCols = joinNonEmpty(
+    [correlatedCols, joinSelectCols, countCols],
     SQL_SEPARATORS.FIELD_LIST
   );
-  const selectWithIncludes = buildSelectList(baseSelect, allCols);
-  return { includeCols: allCols, selectWithIncludes, countJoins };
+  const selectWithIncludes = buildSelectList(baseSelect, allIncludeCols);
+  return {
+    includeCols: allIncludeCols,
+    selectWithIncludes,
+    countJoins,
+    includeJoins: joinIncludeJoins
+  };
 }
 function appendPagination(sql, spec) {
   const { method, pagination, params } = spec;
@@ -4026,9 +4628,13 @@ function appendPagination(sql, spec) {
   return parts.join(" ");
 }
 function hasWindowDistinct(spec) {
+  if (spec.dialect !== "sqlite") return false;
   const d = spec.distinct;
   return isNotNullish(d) && isNonEmptyArray(d);
 }
+function hasAnyDistinct(spec) {
+  return isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct);
+}
 function assertDistinctAllowed(method, enabled) {
   if (enabled && method !== "findMany") {
     throw new Error(
@@ -4036,11 +4642,6 @@ function assertDistinctAllowed(method, enabled) {
     );
   }
 }
-function assertHasSelectFields(baseSelect, includeCols) {
-  if (!isNonEmptyString(baseSelect) && !isNonEmptyString(includeCols)) {
-    throw new Error("SELECT requires at least one selected field or include");
-  }
-}
 function withCountJoins(spec, countJoins, whereJoins) {
   return __spreadProps(__spreadValues({}, spec), {
     whereJoins: [...whereJoins || [], ...countJoins || []]
@@ -4067,6 +4668,63 @@ function pushWhere(parts, conditions) {
   if (!isNonEmptyArray(conditions)) return;
   parts.push(SQL_TEMPLATES.WHERE, conditions.join(SQL_SEPARATORS.CONDITION_AND));
 }
+function extractIncludeSpec(args) {
+  const includeSpec = {};
+  if (args.include && isPlainObject(args.include)) {
+    for (const [key, value] of Object.entries(args.include)) {
+      if (value !== false) {
+        includeSpec[key] = value;
+      }
+    }
+  }
+  if (args.select && isPlainObject(args.select)) {
+    for (const [key, value] of Object.entries(args.select)) {
+      if (value !== false && value !== true && isPlainObject(value)) {
+        const selectVal = value;
+        if (selectVal.include || selectVal.select) {
+          includeSpec[key] = value;
+        }
+      }
+    }
+  }
+  return includeSpec;
+}
+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 aliasLower = String(fromAlias).toLowerCase();
+  const terms = splitOrderByTerms(orderBy).map((t) => t.toLowerCase());
+  return terms.some(
+    (t) => t.startsWith(aliasLower + ".id ") || t.startsWith(aliasLower + '."id" ') || t === aliasLower + ".id" || t === 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,
@@ -4080,15 +4738,36 @@ function constructFinalSql(spec) {
     cursorClause,
     params,
     dialect,
-    model
+    model,
+    includes,
+    schemas,
+    pagination,
+    args
   } = spec;
   const useWindowDistinct = hasWindowDistinct(spec);
   assertDistinctAllowed(method, useWindowDistinct);
-  const { includeCols, selectWithIncludes, countJoins } = buildIncludeColumns(spec);
+  const hasDistinct = hasAnyDistinct(spec);
+  assertDistinctAllowed(method, hasDistinct);
+  const includeSpec = extractIncludeSpec(args);
+  const hasIncludes = hasNestedIncludes(includeSpec);
+  const shouldUseFlatJoin = dialect === "postgres" && hasIncludes && canUseFlatJoinForAll(includeSpec);
+  if (shouldUseFlatJoin) {
+    const flatResult = buildFlatJoinSql(spec);
+    if (flatResult.sql) {
+      const baseSqlResult = finalizeSql(flatResult.sql, params, dialect);
+      return {
+        sql: baseSqlResult.sql,
+        params: baseSqlResult.params,
+        paramMappings: baseSqlResult.paramMappings,
+        requiresReduction: true,
+        includeSpec: flatResult.includeSpec
+      };
+    }
+  }
+  const { includeCols, selectWithIncludes, countJoins, includeJoins } = buildIncludeColumns(spec);
   if (useWindowDistinct) {
-    const baseSelect2 = (select != null ? select : "").trim();
-    assertHasSelectFields(baseSelect2, includeCols);
-    const spec2 = withCountJoins(spec, countJoins, whereJoins);
+    const allExtraJoins = [...countJoins, ...includeJoins];
+    const spec2 = withCountJoins(spec, allExtraJoins, whereJoins);
     let sql2 = buildSqliteDistinctQuery(spec2, selectWithIncludes).trim();
     sql2 = appendPagination(sql2, spec);
     return finalizeSql(sql2, params, dialect);
@@ -4110,9 +4789,22 @@ function constructFinalSql(spec) {
     parts.push("CROSS JOIN", cteName);
   }
   pushJoinGroups(parts, whereJoins, countJoins);
+  if (isNonEmptyArray(includeJoins)) {
+    parts.push(includeJoins.join(" "));
+  }
   const conditions = buildConditions(whereClause, cursorClause);
   pushWhere(parts, conditions);
-  if (isNonEmptyString(orderBy)) parts.push(SQL_TEMPLATES.ORDER_BY, orderBy);
+  let finalOrderBy = orderBy;
+  if (dialect === "postgres" && isNonEmptyArray(distinct)) {
+    finalOrderBy = ensurePostgresDistinctOrderBy({
+      orderBy: orderBy || "",
+      distinct: [...distinct],
+      fromAlias: from.alias,
+      model
+    });
+  }
+  if (isNonEmptyString(finalOrderBy))
+    parts.push(SQL_TEMPLATES.ORDER_BY, finalOrderBy);
   let sql = parts.join(" ").trim();
   sql = appendPagination(sql, spec);
   return finalizeSql(sql, params, dialect);
@@ -4266,13 +4958,15 @@ function buildSelectSpec(input) {
     whereResult.paramMappings,
     whereResult.nextParamIndex
   );
+  const outerHasLimit = isNotNullish(take);
   const includes = buildIncludeSql(
     normalizedArgs,
     model,
     schemas,
     alias,
     params,
-    dialect
+    dialect,
+    outerHasLimit
   );
   const cursorResult = buildCursorClauseIfAny({
     cursor,
@@ -4452,6 +5146,14 @@ function buildInComparison(expr, op, val, params, dialect) {
   if (val.length === 0) {
     return op === Ops.IN ? "0=1" : "1=1";
   }
+  if (dialect === "sqlite" && val.length <= 30) {
+    const placeholders = [];
+    for (const item of val) {
+      placeholders.push(params.add(item));
+    }
+    const list = placeholders.join(", ");
+    return op === Ops.IN ? `${expr} IN (${list})` : `${expr} NOT IN (${list})`;
+  }
   const paramValue = prepareArrayParam(val, dialect);
   const placeholder = params.add(paramValue);
   return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
@@ -4702,6 +5404,7 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
     throw new Error("buildAggregateSql requires at least one aggregate field");
   }
   const selectClause = aggFields.join(SQL_SEPARATORS.FIELD_LIST);
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
@@ -4710,6 +5413,7 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
@@ -4762,7 +5466,9 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     byFields
   );
   const havingClause = buildGroupByHaving(args, alias, params, model, d);
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
+  const orderBySql = isNotNullish(args.orderBy) ? buildOrderBy(args.orderBy, alias, d, model) : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
     selectFields,
@@ -4770,9 +5476,21 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   parts.push(SQL_TEMPLATES.GROUP_BY, groupFields);
   if (havingClause) parts.push(havingClause);
+  if (orderBySql) {
+    parts.push(SQL_TEMPLATES.ORDER_BY, orderBySql);
+  }
+  if (isNotNullish(args.take)) {
+    const ph = addAutoScoped(params, args.take, "groupBy.take");
+    parts.push(SQL_TEMPLATES.LIMIT, ph);
+  }
+  if (isNotNullish(args.skip)) {
+    const ph = addAutoScoped(params, args.skip, "groupBy.skip");
+    parts.push(SQL_TEMPLATES.OFFSET, ph);
+  }
   const sql = parts.join(" ").trim();
   const snapshot = params.snapshot();
   const allParams = [...whereResult.params, ...snapshot.params];
@@ -4785,32 +5503,25 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     paramMappings: allMappings
   };
 }
-function isPositiveInteger(value) {
-  return Number.isFinite(value) && Number.isInteger(value) && value > 0;
+function findPrimaryKeyFields2(model) {
+  const pkFields = model.fields.filter((f) => f.isId && !f.isRelation);
+  if (pkFields.length > 0) return pkFields.map((f) => f.name);
+  const defaultId = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (defaultId) return ["id"];
+  return [];
 }
-function parseSkipValue(skip) {
-  return typeof skip === "string" ? Number(skip.trim()) : skip;
+function normalizeCountArgs(argsOrSkip) {
+  if (isPlainObject(argsOrSkip)) return argsOrSkip;
+  if (argsOrSkip === void 0 || argsOrSkip === null) return {};
+  return { skip: argsOrSkip };
 }
-function validateSkipParameter(skip) {
-  if (skip === void 0 || skip === null) {
-    return;
-  }
-  if (isDynamicParameter(skip)) {
-    throw new Error(
-      "count() with skip is not supported because it produces nondeterministic results. Dynamic skip cannot be validated at build time. Use findMany().length or add explicit orderBy + cursor/skip logic in a deterministic query."
-    );
-  }
-  const skipValue = parseSkipValue(skip);
-  if (isPositiveInteger(skipValue)) {
-    throw new Error(
-      "count() with skip is not supported because it produces nondeterministic results. Use findMany().length or add explicit orderBy to ensure deterministic behavior."
-    );
+function assertNoNegativeTake(args) {
+  if (typeof args.take === "number" && args.take < 0) {
+    throw new Error("Negative take is not supported for count()");
   }
 }
-function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
-  assertSafeAlias(alias);
-  assertSafeTableRef(tableName);
-  validateSkipParameter(skip);
+function buildSimpleCountSql(whereResult, tableName, alias) {
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
@@ -4821,6 +5532,7 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
@@ -4831,6 +5543,49 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
     paramMappings: whereResult.paramMappings
   };
 }
+function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model, schemas) {
+  assertSafeAlias(alias);
+  assertSafeTableRef(tableName);
+  const args = normalizeCountArgs(argsOrSkip);
+  assertNoNegativeTake(args);
+  if (!model) {
+    return buildSimpleCountSql(whereResult, tableName, alias);
+  }
+  const pkFields = findPrimaryKeyFields2(model);
+  const distinctFields = isNonEmptyArray(args.distinct) ? args.distinct.map((x) => String(x)).filter((x) => x) : [];
+  const selectFields = distinctFields.length > 0 ? distinctFields : pkFields;
+  if (selectFields.length === 0) {
+    return buildSimpleCountSql(whereResult, tableName, alias);
+  }
+  const select = {};
+  for (const f of selectFields) select[f] = true;
+  const subArgs = __spreadProps(__spreadValues({}, args), {
+    include: void 0,
+    select
+  });
+  const d = dialect != null ? dialect : getGlobalDialect();
+  const subSchemas = Array.isArray(schemas) && schemas.length > 0 ? schemas : [model];
+  const sub = buildSelectSql({
+    method: "findMany",
+    args: subArgs,
+    model,
+    schemas: subSchemas,
+    from: { tableName, alias },
+    whereResult,
+    dialect: d
+  });
+  const countAlias = quote("__count_sub");
+  const sql = `${SQL_TEMPLATES.SELECT} ${SQL_TEMPLATES.COUNT_ALL} ${SQL_TEMPLATES.AS} ${quote(
+    "_count._all"
+  )} ${SQL_TEMPLATES.FROM} (${sub.sql}) ${SQL_TEMPLATES.AS} ${countAlias}`;
+  validateSelectQuery(sql);
+  validateParamConsistency(sql, sub.params);
+  return {
+    sql,
+    params: sub.params,
+    paramMappings: sub.paramMappings
+  };
+}
 function safeAlias(input) {
   const raw = String(input).toLowerCase();
   const cleaned = raw.replace(/[^a-z0-9_]/g, "_");
@@ -4842,6 +5597,17 @@ function safeAlias(input) {
   }
   return base;
 }
+function isPrismaMethod(v) {
+  return v === "findMany" || v === "findFirst" || v === "findUnique" || v === "aggregate" || v === "groupBy" || v === "count";
+}
+function resolveMethod(directive) {
+  var _a, _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;
+  if (isPrismaMethod(pm)) return pm;
+  return "findMany";
+}
 function buildSqlResult(args) {
   const {
     method,
@@ -4871,7 +5637,11 @@ function buildSqlResult(args) {
       whereResult,
       tableName,
       alias,
-      processed.skip);
+      processed,
+      dialect,
+      modelDef,
+      schemaModels
+    );
   }
   return buildSelectSql({
     method,
@@ -4959,7 +5729,43 @@ function buildMainWhere(args) {
     dialect
   });
 }
+function extractIncludeSpec2(processed, modelDef) {
+  const includeSpec = {};
+  const relationSet = new Set(
+    Array.isArray(modelDef == null ? void 0 : modelDef.fields) ? modelDef.fields.filter((f) => f && f.isRelation && typeof f.name === "string").map((f) => f.name) : []
+  );
+  if (processed.include && isPlainObject(processed.include)) {
+    for (const [key, value] of Object.entries(processed.include)) {
+      if (!relationSet.has(key)) continue;
+      if (value !== false) {
+        includeSpec[key] = value;
+      }
+    }
+  }
+  if (processed.select && isPlainObject(processed.select)) {
+    for (const [key, value] of Object.entries(processed.select)) {
+      if (!relationSet.has(key)) continue;
+      if (value === false) continue;
+      if (value === true) {
+        includeSpec[key] = true;
+        continue;
+      }
+      if (isPlainObject(value)) {
+        const selectVal = value;
+        if (selectVal.include || selectVal.select) {
+          includeSpec[key] = value;
+        } else {
+          includeSpec[key] = true;
+        }
+      } else {
+        includeSpec[key] = true;
+      }
+    }
+  }
+  return includeSpec;
+}
 function buildAndNormalizeSql(args) {
+  var _a;
   const {
     method,
     processed,
@@ -4980,14 +5786,30 @@ function buildAndNormalizeSql(args) {
     schemaModels,
     dialect
   });
-  return normalizeSqlAndMappingsForDialect(
+  const normalized = normalizeSqlAndMappingsForDialect(
     sqlResult.sql,
     sqlResult.paramMappings,
     dialect
   );
+  const includeSpec = (_a = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a : extractIncludeSpec2(processed, modelDef);
+  const requiresReduction = sqlResult.requiresReduction === true;
+  return {
+    sql: normalized.sql,
+    paramMappings: normalized.paramMappings,
+    requiresReduction,
+    includeSpec
+  };
 }
 function finalizeDirective(args) {
-  const { directive, normalizedSql, normalizedMappings, dialect } = args;
+  const {
+    directive,
+    method,
+    normalizedSql,
+    normalizedMappings,
+    dialect,
+    requiresReduction,
+    includeSpec
+  } = args;
   const params = normalizedMappings.map((m) => {
     var _a;
     return (_a = m.value) != null ? _a : void 0;
@@ -4995,12 +5817,14 @@ function finalizeDirective(args) {
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
   const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
   return {
-    method: directive.method,
+    method,
     sql: normalizedSql,
     staticParams,
     dynamicKeys,
     paramOrder,
     paramMappings: normalizedMappings,
+    requiresReduction,
+    includeSpec,
     originalDirective: directive
   };
 }
@@ -5016,8 +5840,8 @@ function generateSQL(directive) {
     modelDef,
     dialect
   });
-  const method = directive.method;
-  const normalized = buildAndNormalizeSql({
+  const method = resolveMethod(directive);
+  const built = buildAndNormalizeSql({
     method,
     processed: query.processed,
     whereResult,
@@ -5029,9 +5853,12 @@ function generateSQL(directive) {
   });
   return finalizeDirective({
     directive,
-    normalizedSql: normalized.sql,
-    normalizedMappings: normalized.paramMappings,
-    dialect
+    method,
+    normalizedSql: built.sql,
+    normalizedMappings: built.paramMappings,
+    dialect,
+    requiresReduction: built.requiresReduction,
+    includeSpec: built.includeSpec
   });
 }
 
@@ -5329,7 +6156,9 @@ function processModelDirectives(modelName, result, config) {
         sql: sqlDirective.sql,
         params: sqlDirective.staticParams,
         dynamicKeys: sqlDirective.dynamicKeys,
-        paramMappings: sqlDirective.paramMappings
+        paramMappings: sqlDirective.paramMappings,
+        requiresReduction: sqlDirective.requiresReduction || false,
+        includeSpec: sqlDirective.includeSpec || {}
       });
     } catch (error) {
       if (!config.skipInvalid) throw error;
@@ -5366,7 +6195,9 @@ function countTotalQueries(queries) {
 }
 function generateClient(options) {
   return __async(this, null, function* () {
+    var _a;
     const { datamodel, outputDir, config } = options;
+    const runtimeImportPath = (_a = options.runtimeImportPath) != null ? _a : "prisma-sql";
     setGlobalDialect(config.dialect);
     const models = convertDMMFToModels(datamodel);
     const directiveResults = processAllDirectives(
@@ -5382,7 +6213,13 @@ function generateClient(options) {
     );
     const absoluteOutputDir = resolve(process.cwd(), outputDir);
     yield mkdir(absoluteOutputDir, { recursive: true });
-    const code = generateCode(models, queries, config.dialect, datamodel);
+    const code = generateCode(
+      models,
+      queries,
+      config.dialect,
+      datamodel,
+      runtimeImportPath
+    );
     const outputPath = join(absoluteOutputDir, "index.ts");
     yield writeFile(outputPath, code);
     const totalQueries = countTotalQueries(queries);
@@ -5407,9 +6244,11 @@ function createQueryKey(processedQuery) {
     return value;
   });
 }
-function generateImports() {
+function generateImports(runtimeImportPath) {
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
-import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, normalizeValue, type PrismaMethod, type Model, type BatchQuery, type BatchCountQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'`;
+import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, normalizeValue, type PrismaMethod, type Model, type BatchQuery, type BatchCountQuery, type TransactionQuery, type TransactionOptions } from ${JSON.stringify(
+    runtimeImportPath
+  )}`;
 }
 function generateCoreTypes() {
   return `class DeferredQuery {
@@ -5570,6 +6409,8 @@ const QUERIES: Record<string, Record<string, Record<string, {
   params: unknown[]
   dynamicKeys: string[]
   paramMappings: any[]
+  requiresReduction: boolean
+  includeSpec: Record<string, any>
 }>>> = ${formatQueries(queries)}
 
 const DIALECT = ${JSON.stringify(dialect)}
@@ -5723,7 +6564,7 @@ function normalizeQuery(args: any): string {
   })
 }`;
 }
-function generateExtension() {
+function generateExtension(runtimeImportPath) {
   return `export function speedExtension(config: {
   postgres?: any
   sqlite?: any
@@ -5756,7 +6597,7 @@ function generateExtension() {
       postgresClient: postgres,
     })
 
-    const handleMethod = async function(this: any, method: PrismaMethod, args: any) {
+    async function handleMethod(this: any, method: PrismaMethod, args: any) {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
 
@@ -5767,11 +6608,15 @@ function generateExtension() {
         let sql: string
         let params: unknown[]
         let prebaked = false
+        let requiresReduction = false
+        let includeSpec: Record<string, any> | undefined
 
         if (prebakedQuery) {
           sql = prebakedQuery.sql
           params = resolveParamsFromMappings(transformedArgs, prebakedQuery.paramMappings)
           prebaked = true
+          requiresReduction = prebakedQuery.requiresReduction || false
+          includeSpec = prebakedQuery.includeSpec
         } else {
           const model = MODELS.find((m) => m.name === modelName)
           if (!model) {
@@ -5780,15 +6625,20 @@ function generateExtension() {
           const result = buildSQL(model, MODELS, method, transformedArgs, DIALECT)
           sql = result.sql
           params = result.params as unknown[]
+          requiresReduction = result.requiresReduction || false
+          includeSpec = result.includeSpec
         }
 
         if (debug) {
           console.log(\`[\${DIALECT}] \${modelName}.\${method} \${prebaked ? '\u26A1 PREBAKED' : '\u{1F528} RUNTIME'}\`)
           console.log('SQL:', sql)
           console.log('Params:', params)
+          if (requiresReduction) {
+            console.log('Requires reduction: true')
+          }
         }
 
-        const results = await executeQuery(client, method, sql, params)
+        let results = await executeQuery(client, method, sql, params)
         const duration = Date.now() - startTime
 
         onQuery?.({
@@ -5800,6 +6650,34 @@ function generateExtension() {
           prebaked,
         })
 
+        if (requiresReduction && includeSpec) {
+          if (results.length > 10000) {
+            console.warn(
+              \`[prisma-sql] \${modelName}.\${method} returned \${results.length} rows before reduction, falling back to Prisma for safety\`
+            )
+            return this.$parent[modelName][method](args)
+          }
+
+          const model = MODEL_MAP.get(modelName)
+          if (model) {
+            const { buildReducerConfig, reduceFlatRows } = await import(${JSON.stringify(
+    runtimeImportPath
+  )})
+            const config = buildReducerConfig(model, includeSpec, MODELS)
+            results = reduceFlatRows(results, config)
+
+            if (method === 'findUnique' && results.length > 1) {
+              throw new Error(
+                \`findUnique returned \${results.length} records after reduction\`
+              )
+            }
+
+            if (method === 'findFirst' && results.length > 1) {
+              results = [results[0]]
+            }
+          }
+        }
+
         return transformQueryResults(method, results)
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error)
@@ -5970,18 +6848,18 @@ export type SpeedClient<T> = T & {
 
 export type { BatchCountQuery, TransactionQuery, TransactionOptions }`;
 }
-function generateCode(models, queries, dialect, datamodel) {
+function generateCode(models, queries, dialect, datamodel, runtimeImportPath) {
   const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
     fields: model.fields.filter((f) => f !== void 0 && f !== null)
   }));
   const { mappings, fieldTypes } = extractEnumMappings(datamodel);
   return [
-    generateImports(),
+    generateImports(runtimeImportPath),
     generateCoreTypes(),
     generateHelpers(),
     generateDataConstants(cleanModels, mappings, fieldTypes, queries, dialect),
     generateTransformLogic(),
-    generateExtension(),
+    generateExtension(runtimeImportPath),
     generateTypeExports()
   ].join("\n\n");
 }
@@ -6000,6 +6878,8 @@ function formatQueries(queries) {
       params: ${JSON.stringify(query.params)},
       dynamicKeys: ${JSON.stringify(query.dynamicKeys)},
       paramMappings: ${JSON.stringify(query.paramMappings)},
+      requiresReduction: ${query.requiresReduction || false},
+      includeSpec: ${JSON.stringify(query.includeSpec || {})},
     }`);
       }
       methodEntries.push(`    ${JSON.stringify(method)}: {