@prisma/orm-family-sql 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/orm-client.mjs

@@ -2,15 +2,15 @@ import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
 import { i as isUniqueConstraintViolation } from "./dist-x6jvtkKM.mjs";
 import { C as LiteralExpr, D as OrExpr, F as SubqueryExpr, I as TableSource, L as UpdateAst, O as OrderByItem, P as SelectAst, R as WindowFuncExpr, S as ListExpression, T as NullCheckExpr, U as isWhereExpr, V as isAggregateFn, _ as InsertAst, b as JsonArrayAggExpr, c as DeleteAst, f as EqColJoinOn, j as ProjectionItem, k as ParamRef, l as DerivedTableSource, n as AndExpr, o as ColumnRef, p as ExistsExpr, r as BinaryExpr, s as DefaultValueExpr, t as AggregateExpr, v as InsertOnConflict, w as NotExpr, x as JsonObjectExpr, y as JoinAst } from "./types-Dt4e_jC--COeP8xzN.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
-import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-Lbl4VwqP.mjs";
-import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-N0dhtKaH.mjs";
+import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-5tg0fGPQ.mjs";
+import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-ECZ4ohtG.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { AsyncIterableResult, createMetaBuilder, isRuntimeError, runtimeError } from "@prisma/orm-framework/components/runtime";
 import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
-import { AsyncIterableResult, createMetaBuilder, isRuntimeError, runtimeError } from "@prisma/orm-framework/components/runtime";
 //#region ../../../3-extensions/sql-orm-client/dist/index.mjs
 const operationNamesByRegistry = /* @__PURE__ */ new WeakMap();
 /**
@@ -139,9 +139,6 @@ function resolveFieldToColumn(contract, namespaceId, modelName, fieldName) {
 * base-table field map. Base fields are intentionally absent so callers can
 * gate variant qualification strictly to variant-owned fields.
 *
-* `baseModelName` is a default-namespace model name, consistent with the rest
-* of this module; namespace context is bound downstream at table resolution.
-*
 * Uncached on purpose: `resolvePolymorphismInfo` already memoizes the variant
 * lookup, and the remaining work is one pass over the variant's field→column
 * map, so a second cache layer would buy nothing.
@@ -190,8 +187,7 @@ function getColumnToFieldMap(contract, namespaceId, modelName) {
 }
 const completeColumnToFieldCache = /* @__PURE__ */ new WeakMap();
 /**
-* Like getColumnToFieldMap but includes identity-mapped fields (where field name equals column
-* name). getColumnToFieldMap only returns explicit remaps; this returns ALL column→field entries.
+* Like getColumnToFieldMap, but a field without a storage `column` maps under its own name.
 */
 function getCompleteColumnToFieldMap(contract, namespaceId, modelName) {
 	let perContract = completeColumnToFieldCache.get(contract);
@@ -346,6 +342,13 @@ function assertReturningCapability(contract, action) {
 		action
 	} });
 }
+function assertDistinctOnCapability(contract, methodName) {
+	if (contract.capabilities["postgres"]?.["distinctOn"] === true) return;
+	throw ormError("ORM.CAPABILITY_MISSING", `${methodName}() requires capability postgres.distinctOn`, { meta: {
+		capability: "postgres.distinctOn",
+		method: methodName
+	} });
+}
 function hasContractCapability(contract, capability) {
 	const capabilities = contract.capabilities;
 	const value = capabilities[capability];
@@ -537,16 +540,6 @@ function mapResultRows(result, mapper) {
 	};
 	return new AsyncIterableResult(generator());
 }
-async function acquireRuntimeScope(runtime) {
-	if (typeof runtime.connection !== "function") return { scope: runtime };
-	const connection = await runtime.connection();
-	const release = connection.release;
-	if (typeof release === "function") return {
-		scope: connection,
-		release: () => release.call(connection) ?? Promise.resolve()
-	};
-	return { scope: connection };
-}
 function deriveParamsFromAst(ast) {
 	return { params: collectOrderedParamRefs(ast).map((p) => p.kind === "param-ref" ? p.value : void 0) };
 }
@@ -591,8 +584,8 @@ function buildOrmQueryPlan(contract, ast, params, annotations) {
 * terminals where annotations arrive at the call site, not via state.
 *
 * Returns the input plan unchanged when `annotations` is undefined
-* or empty. Reserved framework namespaces (`codecs`, `limit`) on the
-* input plan win over caller-supplied entries under the same key —
+* or empty. Reserved namespaces already on the input plan (`codecs`, target keys such as `pg`)
+* win over caller-supplied entries under the same key —
 * see the reserved-namespace policy on `defineAnnotation`.
 */
 function mergeAnnotations(plan, annotations) {
@@ -611,202 +604,626 @@ function mergeAnnotations(plan, annotations) {
 		})
 	});
 }
-function combineWhereExprs(filters) {
-	if (filters.length === 0) return;
-	if (filters.length === 1) return filters[0];
-	return AndExpr.of(filters);
-}
-function toAggregateProjection(contract, aggregates, namespaceId, tableName, selector) {
-	const { codec, input: inputCodec, lower } = resolveAggregate({
-		aggregates,
-		contract,
-		namespaceId,
-		tableName,
-		fn: selector.fn,
-		column: selector.column
-	});
-	const inputExpr = selector.column === void 0 ? void 0 : ColumnRef.of(tableName, selector.column);
-	return {
-		expr: lower !== void 0 ? lower({
-			expr: inputExpr,
-			inputCodec
-		}) : plainAggregateExpr(selector.fn, inputExpr),
-		codec
-	};
-}
-function validateGroupedComparable(value) {
-	switch (value.kind) {
-		case "param-ref": throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: value.kind } });
-		case "literal":
-		case "column-ref":
-		case "identifier-ref":
-		case "aggregate":
-		case "operation": return value;
-		case "function-call":
-		case "cast":
-		case "case": throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported comparable kind in grouped having: "${value.kind}"`, { meta: { kind: value.kind } });
-		case "list":
-			if (value.values.some((entry) => entry.kind === "param-ref")) throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: "list" } });
-			return value;
-		default: throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported comparable kind in grouped having: "${value.kind}"`, { meta: { kind: value.kind } });
-	}
-}
-function validateGroupedMetricExpr(expr) {
-	if (expr.kind !== "aggregate") throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "groupBy().having() only supports aggregate metric expressions", { meta: { kind: expr.kind } });
-	return expr;
+function namespaceCoordinateForSource(source) {
+	return source.kind === "table-source" ? source.namespaceId : void 0;
 }
-function rejectHavingExpr(expr) {
-	throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported grouped having expression kind "${expr.kind}"`, { meta: { kind: expr.kind } });
+function bindWhereExpr(contract, expr, namespaceId) {
+	return bindWhereExprNode(contract, expr, namespaceId);
 }
-function validateGroupedHavingExpr(expr) {
+function bindWhereExprNode(contract, expr, namespaceId) {
 	return expr.accept({
-		columnRef: rejectHavingExpr,
-		identifierRef: rejectHavingExpr,
-		subquery: rejectHavingExpr,
-		operation: rejectHavingExpr,
-		aggregate: rejectHavingExpr,
-		windowFunc: rejectHavingExpr,
-		functionCall: rejectHavingExpr,
-		cast: rejectHavingExpr,
-		case: rejectHavingExpr,
-		jsonObject: rejectHavingExpr,
-		jsonArrayAgg: rejectHavingExpr,
-		literal: rejectHavingExpr,
-		param() {
-			throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: "param-ref" } });
+		columnRef(expr) {
+			return bindExpression(contract, expr);
 		},
-		preparedParam() {
-			throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "PreparedParamRef is not supported in grouped having expressions", { meta: { kind: "prepared-param-ref" } });
+		identifierRef(expr) {
+			return expr;
+		},
+		subquery(expr) {
+			return bindExpression(contract, expr);
+		},
+		operation(expr) {
+			return bindExpression(contract, expr);
+		},
+		aggregate(expr) {
+			return bindExpression(contract, expr);
+		},
+		windowFunc(expr) {
+			return bindExpression(contract, expr);
+		},
+		functionCall(expr) {
+			return bindExpression(contract, expr);
+		},
+		cast(expr) {
+			return bindExpression(contract, expr);
+		},
+		case(expr) {
+			return bindExpression(contract, expr);
+		},
+		jsonObject(expr) {
+			return bindExpression(contract, expr);
+		},
+		jsonArrayAgg(expr) {
+			return bindExpression(contract, expr);
+		},
+		literal(expr) {
+			return expr;
+		},
+		param(expr) {
+			return expr;
+		},
+		preparedParam(expr) {
+			return expr;
+		},
+		list(expr) {
+			return bindExpression(contract, expr);
+		},
+		binary(expr) {
+			const left = bindExpression(contract, expr.left);
+			const bindingColumn = left.kind === "column-ref" ? left : void 0;
+			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, namespaceId));
 		},
-		list: rejectHavingExpr,
 		and(expr) {
-			return AndExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
+			return AndExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
 		},
 		or(expr) {
-			return OrExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
+			return OrExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
+		},
+		exists(expr) {
+			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
 		},
-		exists: rejectHavingExpr,
 		nullCheck(expr) {
-			return new NullCheckExpr(validateGroupedMetricExpr(expr.expr), expr.isNull);
+			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
 		},
 		not(expr) {
-			return new NotExpr(validateGroupedHavingExpr(expr.expr));
-		},
-		binary(expr) {
-			return new BinaryExpr(expr.op, validateGroupedMetricExpr(expr.left), validateGroupedComparable(expr.right));
+			return new NotExpr(bindWhereExprNode(contract, expr.expr, namespaceId));
 		},
-		rawExpr: rejectHavingExpr
+		rawExpr(expr) {
+			return expr;
+		}
 	});
 }
-function compileAggregate(contract, aggregates, namespaceId, tableName, filters, aggregateSpec) {
-	const entries = Object.entries(aggregateSpec);
-	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "aggregate() requires at least one aggregation selector", { meta: {
-		method: "aggregate",
-		namespaceId,
-		tableName
-	} });
-	const projection = entries.map(([alias, selector]) => {
-		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
-		return ProjectionItem.of(alias, expr, codec);
-	});
-	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection);
-	const where = combineWhereExprs(filters);
-	if (where) ast = ast.withWhere(where);
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
+function bindComparable(contract, comparable, bindingColumn, namespaceId) {
+	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable);
+	if (comparable.kind === "literal") return createParamRef(contract, bindingColumn, comparable.value, namespaceId);
+	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? createParamRef(contract, bindingColumn, value.value, namespaceId) : value));
+	return bindExpression(contract, comparable);
 }
-function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, filters, groupByColumns, aggregateSpec, havingExpr) {
-	if (groupByColumns.length === 0) throw ormError("ORM.GROUP_BY_FIELD_MISSING", "groupBy() requires at least one field", { meta: {
-		namespaceId,
-		tableName
-	} });
-	const entries = Object.entries(aggregateSpec);
-	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
-		method: "groupBy.aggregate",
-		namespaceId,
-		tableName
+function createParamRef(contract, columnRef, value, namespaceId) {
+	const resolved = resolveStorageTable(contract.storage, columnRef.table, namespaceId);
+	if (resolved === void 0 || !resolved.table.columns[columnRef.column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${columnRef.column}" in table "${columnRef.table}"`, { meta: {
+		tableName: columnRef.table,
+		column: columnRef.column
 	} });
-	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column))), ...entries.map(([alias, selector]) => {
-		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
-		return ProjectionItem.of(alias, expr, codec);
-	})];
-	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
-	const where = combineWhereExprs(filters);
-	if (where) ast = ast.withWhere(where);
-	if (havingExpr) ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
-}
-function buildReturningColumns(contract, namespaceId, tableName, returningColumns) {
-	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, namespaceId, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, columnRef.table, columnRef.column);
+	return ParamRef.of(value, codec ? { codec } : void 0);
 }
-function toParamAssignments(contract, namespaceId, tableName, values) {
-	const assignments = {};
-	const table = storageTableForContract(contract, namespaceId, tableName);
-	for (const [column, value] of Object.entries(values)) {
-		if (!table.columns[column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${column}" in table "${tableName}"`, { meta: {
-			namespaceId,
-			tableName,
-			column
-		} });
-		const codec = codecRefForStorageColumn(contract.storage, namespaceId, tableName, column);
-		assignments[column] = ParamRef.of(value, {
-			name: column,
-			...ifDefined("codec", codec)
-		});
-	}
-	return { assignments };
+function createExpressionBinder(contract) {
+	return { select: (ast) => bindSelectAst(contract, ast) };
 }
-function normalizeInsertRows(contract, namespaceId, tableName, rows) {
-	if (rows.length === 0) throw new InternalError("normalizeInsertRows requires at least one row");
-	const orderedColumns = [];
-	const seenColumns = /* @__PURE__ */ new Set();
-	for (const row of rows) for (const column of Object.keys(row)) {
-		if (seenColumns.has(column)) continue;
-		seenColumns.add(column);
-		orderedColumns.push(column);
-	}
-	const table = storageTableForContract(contract, namespaceId, tableName);
-	return { rows: rows.map((row) => {
-		if (orderedColumns.length === 0) return {};
-		const normalizedRow = {};
-		for (const column of orderedColumns) {
-			if (Object.hasOwn(row, column)) {
-				if (!table.columns[column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${column}" in table "${tableName}"`, { meta: {
-					namespaceId,
-					tableName,
-					column
-				} });
-				const codec = codecRefForStorageColumn(contract.storage, namespaceId, tableName, column);
-				normalizedRow[column] = ParamRef.of(row[column], {
-					name: column,
-					...ifDefined("codec", codec)
-				});
-				continue;
-			}
-			normalizedRow[column] = new DefaultValueExpr();
-		}
-		return normalizedRow;
-	}) };
+function bindExpression(contract, expr) {
+	return expr.rewrite(createExpressionBinder(contract));
 }
-function compileInsertReturning(contract, namespaceId, tableName, rows, returningColumns) {
-	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
+function bindProjectionExpr(contract, expr) {
+	return expr.kind === "literal" ? expr : bindExpression(contract, expr);
 }
-function compileInsertCount(contract, namespaceId, tableName, rows) {
-	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows);
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params);
+function bindOrderByItem(contract, orderItem) {
+	return new OrderByItem(bindExpression(contract, orderItem.expr), orderItem.dir);
 }
-function stripUndefinedValues(row) {
+function bindJoin(contract, join) {
+	const namespaceId = namespaceCoordinateForSource(join.source);
+	return new JoinAst(join.joinType, bindFromSource(contract, join.source), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExprNode(contract, join.on, namespaceId), join.lateral);
+}
+function bindFromSource(contract, source) {
+	if (source.kind === "table-source") return source;
+	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query));
+	return source;
+}
+function bindSelectAst(contract, ast) {
+	const namespaceId = ast.from !== void 0 ? namespaceCoordinateForSource(ast.from) : void 0;
+	return new SelectAst({
+		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from) } : {},
+		joins: ast.joins?.map((join) => bindJoin(contract, join)),
+		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codec)),
+		where: ast.where ? bindWhereExprNode(contract, ast.where, namespaceId) : void 0,
+		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
+		distinct: ast.distinct,
+		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr)),
+		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr)),
+		having: ast.having ? bindWhereExprNode(contract, ast.having, namespaceId) : void 0,
+		limit: ast.limit,
+		offset: ast.offset,
+		selectAllIntent: ast.selectAllIntent
+	});
+}
+function combineWhereExprs(filters) {
+	if (filters.length === 0) return;
+	if (filters.length === 1) return filters[0];
+	return AndExpr.of(filters);
+}
+function createBoundaryExpr(tableName, entry) {
+	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
+}
+function buildLexicographicCursorWhere(tableName, entries) {
+	const branches = entries.map((entry, index) => {
+		const branchExprs = [];
+		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(ColumnRef.of(tableName, prefixEntry.column), LiteralExpr.of(prefixEntry.value)));
+		branchExprs.push(createBoundaryExpr(tableName, entry));
+		if (branchExprs.length === 1) {
+			const branch = branchExprs[0];
+			assertDefined(branch, "cursor branch contains its boundary expression");
+			return branch;
+		}
+		return AndExpr.of(branchExprs);
+	});
+	if (branches.length === 1) {
+		const branch = branches[0];
+		assertDefined(branch, "cursor expression contains its single branch");
+		return branch;
+	}
+	return OrExpr.of(branches);
+}
+function buildCursorWhere(tableName, orderBy, cursor) {
+	if (!cursor || !orderBy || orderBy.length === 0) return;
+	const entries = [];
+	for (const order of orderBy) {
+		if (order.expr.kind !== "column-ref") continue;
+		const column = order.expr.column;
+		const value = cursor[column];
+		if (value === void 0) throw ormError("ORM.CURSOR_VALUE_MISSING", `Missing cursor value for orderBy column "${column}"`, { meta: { column } });
+		entries.push({
+			column,
+			direction: order.dir,
+			value
+		});
+	}
+	const firstEntry = entries[0];
+	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(tableName, firstEntry);
+	return buildLexicographicCursorWhere(tableName, entries);
+}
+function createTableRefRemapper$1(fromTable, toTable) {
+	return {
+		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
+		tableSource: (source) => {
+			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
+			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
+			return source;
+		},
+		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
+	};
+}
+function buildStateWhere(contract, tableName, state, options) {
+	const filterTableName = options?.filterTableName;
+	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
+	const boundFilters = state.filters.map((filter) => bindWhereExpr(contract, filter, options?.namespaceId));
+	const remappedFilters = filterTableName && filterTableName !== tableName ? boundFilters.map((filter) => filter.rewrite(createTableRefRemapper$1(filterTableName, tableName))) : boundFilters;
+	const boundCursorWhere = cursorWhere ? bindWhereExpr(contract, cursorWhere, options?.namespaceId) : void 0;
+	const remappedCursorWhere = boundCursorWhere && filterTableName && filterTableName !== tableName ? boundCursorWhere.rewrite(createTableRefRemapper$1(filterTableName, tableName)) : boundCursorWhere;
+	return combineWhereExprs(remappedCursorWhere ? [...remappedFilters, remappedCursorWhere] : remappedFilters);
+}
+/**
+* Wrap a base SELECT in a `ROW_NUMBER() OVER (PARTITION BY … ORDER BY …) = 1`
+* filter, implementing Prisma-style `.distinct(cols)` semantics: one
+* representative row per `(distinctColumnRefs)` group is kept; the rest
+* are dropped.
+*
+* Picking which row survives in each partition is governed by
+* `rankingOrderBy`. When the caller's `orderBy` doesn't fully order rows
+* within a partition (e.g. user wrote `.distinct('title')` with no
+* `orderBy`, or ties in their ordering), the choice is
+* implementation-defined — matching Prisma's documented nested-distinct
+* behaviour. Callers that want determinism should pass an `orderBy` that
+* is total within each partition.
+*
+* The wrapper forwards every column of `base.projection` through the
+* derived alias, so the wrapper's projection is byte-identical in alias
+* names — making this transparent to any outer query (`json_agg`,
+* correlated subquery, top-level SELECT) that consumes the SELECT.
+*/
+function wrapWithRowNumberDedup(options) {
+	const { base, distinctColumnRefs, rankingOrderBy, rankedAlias } = options;
+	const rnAlias = "__prisma_distinct_rn";
+	const effectiveOrderBy = rankingOrderBy.length > 0 ? rankingOrderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
+	const inner = base.withProjection([...base.projection, ProjectionItem.of(rnAlias, WindowFuncExpr.rowNumber({
+		partitionBy: distinctColumnRefs,
+		orderBy: effectiveOrderBy
+	}))]);
+	return SelectAst.from(DerivedTableSource.as(rankedAlias, inner)).withProjection(base.projection.map((item) => ProjectionItem.of(item.alias, ColumnRef.of(rankedAlias, item.alias), item.codec))).withWhere(BinaryExpr.eq(ColumnRef.of(rankedAlias, rnAlias), LiteralExpr.of(1)));
+}
+/**
+* FROM source + WHERE for `state.distinct`: wraps in a `ROW_NUMBER`-ranked
+* derived table aliased back to `tableName`, so callers need no rewriting.
+*/
+function buildDedupedTableSource(contract, namespaceId, tableName, state, where, wrapProjection, joins) {
+	if (!hasEntries(state.distinct)) return {
+		source: tableSourceForContract(contract, namespaceId, tableName),
+		where
+	};
+	const distinctColumnRefs = state.distinct.map((column) => ColumnRef.of(tableName, column));
+	const rankingOrderBy = hasEntries(state.orderBy) ? state.orderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
+	let inner = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection([...wrapProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
+		partitionBy: distinctColumnRefs,
+		orderBy: rankingOrderBy
+	}))]);
+	if (joins && joins.length > 0) inner = inner.withJoins(joins);
+	if (where) inner = inner.withWhere(where);
+	return {
+		source: DerivedTableSource.as(tableName, inner),
+		where: BinaryExpr.eq(ColumnRef.of(tableName, "__prisma_distinct_rn"), LiteralExpr.of(1))
+	};
+}
+function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedColumnsByTable) {
+	const joins = [];
+	const projection = [];
+	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, polyInfo.baseTable);
+	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
+	for (const variant of variantsToJoin) {
+		const joinType = variantName ? "inner" : "left";
+		const joinOn = EqColJoinOn.of(ColumnRef.of(polyInfo.baseTable, pkColumn), ColumnRef.of(variant.table, pkColumn));
+		const join = joinType === "inner" ? JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn) : JoinAst.left(tableSourceForContract(contract, namespaceId, variant.table), joinOn);
+		joins.push(join);
+		const variantColumns = resolveTableColumns(contract, namespaceId, variant.table);
+		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
+		for (const col of variantColumns) {
+			if (col === pkColumn) continue;
+			if (selectedColumnsByTable !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
+			const alias = `${variant.table}__${col}`;
+			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), codecRefForStorageColumn(contract.storage, namespaceId, variant.table, col)));
+		}
+	}
+	return {
+		joins,
+		projection
+	};
+}
+function hasEntries(value) {
+	return value !== void 0 && value.length > 0;
+}
+/**
+* The rows an aggregate reduces over, one SELECT aliased to `tableName` — an
+* aggregate has no outer level of its own, so where/joins/distinct/orderBy/
+* limit/offset all have to live in this one wrap.
+*/
+function buildAggregateInput(contract, namespaceId, tableName, state, modelName, projection) {
+	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, void 0).joins : [];
+	const { source, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, buildStateWhere(contract, tableName, state, { namespaceId }), projection, variantJoins);
+	let inner = SelectAst.from(source).withProjection(projection);
+	if (!hasEntries(state.distinct) && variantJoins.length > 0) inner = inner.withJoins(variantJoins);
+	if (effectiveWhere) inner = inner.withWhere(effectiveWhere);
+	if (hasEntries(state.distinctOn)) inner = inner.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
+	if (hasEntries(state.orderBy)) inner = inner.withOrderBy(state.orderBy);
+	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
+	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
+	return { source: DerivedTableSource.as(tableName, inner) };
+}
+function emptyState() {
+	return {
+		filters: [],
+		includes: [],
+		orderBy: void 0,
+		cursor: void 0,
+		distinct: void 0,
+		distinctOn: void 0,
+		selectedFields: void 0,
+		limit: void 0,
+		offset: void 0,
+		variantName: void 0,
+		annotations: /* @__PURE__ */ new Map()
+	};
+}
+function emptyGroupPagingState() {
+	return {
+		orderBy: [],
+		limit: void 0,
+		offset: void 0
+	};
+}
+function param(codec, value) {
+	if (codec === void 0) return ParamRef.of(value);
+	return ParamRef.of(value, { codec });
+}
+function paramList(codec, values) {
+	return ListExpression.of(values.map((value) => param(codec, value)));
+}
+function scalarComparisonMethod(op) {
+	return ((left, codec) => (value) => {
+		if (value === null && (op === "eq" || op === "neq")) return op === "eq" ? NullCheckExpr.isNull(left) : NullCheckExpr.isNotNull(left);
+		return new BinaryExpr(op, left, param(codec, value));
+	});
+}
+function listComparisonMethod(op) {
+	return ((left, codec) => (values) => new BinaryExpr(op, left, paramList(codec, values)));
+}
+/**
+* Declares trait requirements and runtime factory for each comparison method.
+*
+* - `traits: []` means "no trait required" — always available
+* - Multi-trait: `traits: ['equality', 'order']` means BOTH traits are required
+*/
+const COMPARISON_METHODS_META = {
+	eq: {
+		traits: ["equality"],
+		create: scalarComparisonMethod("eq")
+	},
+	neq: {
+		traits: ["equality"],
+		create: scalarComparisonMethod("neq")
+	},
+	in: {
+		traits: ["equality"],
+		create: listComparisonMethod("in")
+	},
+	notIn: {
+		traits: ["equality"],
+		create: listComparisonMethod("notIn")
+	},
+	gt: {
+		traits: ["order"],
+		create: scalarComparisonMethod("gt")
+	},
+	lt: {
+		traits: ["order"],
+		create: scalarComparisonMethod("lt")
+	},
+	gte: {
+		traits: ["order"],
+		create: scalarComparisonMethod("gte")
+	},
+	lte: {
+		traits: ["order"],
+		create: scalarComparisonMethod("lte")
+	},
+	like: {
+		traits: ["textual"],
+		create: scalarComparisonMethod("like")
+	},
+	asc: {
+		traits: ["order"],
+		create: (left) => () => OrderByItem.asc(left)
+	},
+	desc: {
+		traits: ["order"],
+		create: (left) => () => OrderByItem.desc(left)
+	},
+	isNull: {
+		traits: [],
+		create: (left) => () => NullCheckExpr.isNull(left)
+	},
+	isNotNull: {
+		traits: [],
+		create: (left) => () => NullCheckExpr.isNotNull(left)
+	}
+};
+function toAggregateProjection(contract, aggregates, namespaceId, tableName, selector) {
+	const { codec, input: inputCodec, lower } = resolveAggregate({
+		aggregates,
+		contract,
+		namespaceId,
+		tableName,
+		fn: selector.fn,
+		column: selector.column
+	});
+	const inputExpr = selector.column === void 0 ? void 0 : ColumnRef.of(tableName, selector.column);
+	return {
+		expr: lower !== void 0 ? lower({
+			expr: inputExpr,
+			inputCodec
+		}) : plainAggregateExpr(selector.fn, inputExpr),
+		codec
+	};
+}
+function validateGroupedComparable(value) {
+	switch (value.kind) {
+		case "param-ref": throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: value.kind } });
+		case "literal":
+		case "column-ref":
+		case "identifier-ref":
+		case "aggregate":
+		case "operation": return value;
+		case "function-call":
+		case "cast":
+		case "case": throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported comparable kind in grouped having: "${value.kind}"`, { meta: { kind: value.kind } });
+		case "list":
+			if (value.values.some((entry) => entry.kind === "param-ref")) throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: "list" } });
+			return value;
+		default: throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported comparable kind in grouped having: "${value.kind}"`, { meta: { kind: value.kind } });
+	}
+}
+function validateGroupedMetricExpr(expr) {
+	if (expr.kind !== "aggregate") throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "groupBy().having() only supports aggregate metric expressions", { meta: { kind: expr.kind } });
+	return expr;
+}
+function rejectHavingExpr(expr) {
+	throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", `Unsupported grouped having expression kind "${expr.kind}"`, { meta: { kind: expr.kind } });
+}
+function validateGroupedHavingExpr(expr) {
+	return expr.accept({
+		columnRef: rejectHavingExpr,
+		identifierRef: rejectHavingExpr,
+		subquery: rejectHavingExpr,
+		operation: rejectHavingExpr,
+		aggregate: rejectHavingExpr,
+		windowFunc: rejectHavingExpr,
+		functionCall: rejectHavingExpr,
+		cast: rejectHavingExpr,
+		case: rejectHavingExpr,
+		jsonObject: rejectHavingExpr,
+		jsonArrayAgg: rejectHavingExpr,
+		literal: rejectHavingExpr,
+		param() {
+			throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "ParamRef is not supported in grouped having expressions", { meta: { kind: "param-ref" } });
+		},
+		preparedParam() {
+			throw ormError("ORM.HAVING_EXPRESSION_UNSUPPORTED", "PreparedParamRef is not supported in grouped having expressions", { meta: { kind: "prepared-param-ref" } });
+		},
+		list: rejectHavingExpr,
+		and(expr) {
+			return AndExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
+		},
+		or(expr) {
+			return OrExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
+		},
+		exists: rejectHavingExpr,
+		nullCheck(expr) {
+			return new NullCheckExpr(validateGroupedMetricExpr(expr.expr), expr.isNull);
+		},
+		not(expr) {
+			return new NotExpr(validateGroupedHavingExpr(expr.expr));
+		},
+		binary(expr) {
+			return new BinaryExpr(expr.op, validateGroupedMetricExpr(expr.left), validateGroupedComparable(expr.right));
+		},
+		rawExpr: rejectHavingExpr
+	});
+}
+function aggregateInputColumns(tableName, entries, orderBy, groupByColumns = []) {
+	const columns = new Set(groupByColumns);
+	for (const [, selector] of entries) if (selector.column !== void 0) columns.add(selector.column);
+	for (const item of orderBy ?? []) if (item.expr.kind === "column-ref") columns.add(item.expr.column);
+	if (columns.size === 0) return [ProjectionItem.of("__row", LiteralExpr.of(1))];
+	return Array.from(columns, (column) => ProjectionItem.of(column, ColumnRef.of(tableName, column)));
+}
+function compileAggregate(contract, aggregates, namespaceId, tableName, state, aggregateSpec, modelName) {
+	const entries = Object.entries(aggregateSpec);
+	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "aggregate() requires at least one aggregation selector", { meta: {
+		method: "aggregate",
+		namespaceId,
+		tableName
+	} });
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	const hasPagination = state.limit !== void 0 || state.offset !== void 0;
+	const hasDistinct = state.distinct !== void 0 && state.distinct.length > 0 || state.distinctOn !== void 0 && state.distinctOn.length > 0;
+	if (hasPagination || hasDistinct) {
+		const { source } = buildAggregateInput(contract, namespaceId, tableName, state, modelName, aggregateInputColumns(tableName, entries, state.orderBy));
+		const projection = entries.map(([alias, selector]) => {
+			const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+			return ProjectionItem.of(alias, expr, codec);
+		});
+		const ast = SelectAst.from(source).withProjection(projection);
+		const { params } = deriveParamsFromAst(ast);
+		return buildOrmQueryPlan(contract, ast, params);
+	}
+	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, void 0).joins : [];
+	const where = buildStateWhere(contract, tableName, state, { namespaceId });
+	const projection = entries.map(([alias, selector]) => {
+		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+		return ProjectionItem.of(alias, expr, codec);
+	});
+	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection);
+	if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
+	if (where) ast = ast.withWhere(where);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, preGroupState, groupByColumns, aggregateSpec, havingExpr, modelName, postGroup = emptyGroupPagingState()) {
+	if (groupByColumns.length === 0) throw ormError("ORM.GROUP_BY_FIELD_MISSING", "groupBy() requires at least one field", { meta: {
+		namespaceId,
+		tableName
+	} });
+	const entries = Object.entries(aggregateSpec);
+	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
+		method: "groupBy.aggregate",
+		namespaceId,
+		tableName
+	} });
+	if (preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column))), ...entries.map(([alias, selector]) => {
+		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+		return ProjectionItem.of(alias, expr, codec);
+	})];
+	const hasPagination = preGroupState.limit !== void 0 || preGroupState.offset !== void 0;
+	const hasDistinct = preGroupState.distinct !== void 0 && preGroupState.distinct.length > 0 || preGroupState.distinctOn !== void 0 && preGroupState.distinctOn.length > 0;
+	const needsInputSelect = hasPagination || hasDistinct;
+	let ast;
+	if (needsInputSelect) {
+		const { source } = buildAggregateInput(contract, namespaceId, tableName, preGroupState, modelName, aggregateInputColumns(tableName, entries, preGroupState.orderBy, groupByColumns));
+		ast = SelectAst.from(source).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+	} else {
+		const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, preGroupState.variantName, void 0).joins : [];
+		ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+		if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
+		const where = buildStateWhere(contract, tableName, preGroupState, { namespaceId });
+		if (where) ast = ast.withWhere(where);
+	}
+	if (havingExpr) ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
+	if (postGroup.orderBy.length > 0) ast = ast.withOrderBy(postGroup.orderBy);
+	if (postGroup.limit !== void 0) ast = ast.withLimit(postGroup.limit);
+	if (postGroup.offset !== void 0) ast = ast.withOffset(postGroup.offset);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function buildReturningColumns(contract, namespaceId, tableName, returningColumns) {
+	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, namespaceId, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+}
+function toParamAssignments(contract, namespaceId, tableName, values) {
+	const assignments = {};
+	const table = storageTableForContract(contract, namespaceId, tableName);
+	for (const [column, value] of Object.entries(values)) {
+		if (!table.columns[column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${column}" in table "${tableName}"`, { meta: {
+			namespaceId,
+			tableName,
+			column
+		} });
+		const codec = codecRefForStorageColumn(contract.storage, namespaceId, tableName, column);
+		assignments[column] = ParamRef.of(value, {
+			name: column,
+			...ifDefined("codec", codec)
+		});
+	}
+	return { assignments };
+}
+function normalizeInsertRows(contract, namespaceId, tableName, rows) {
+	if (rows.length === 0) throw new InternalError("normalizeInsertRows requires at least one row");
+	const orderedColumns = [];
+	const seenColumns = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const column of Object.keys(row)) {
+		if (seenColumns.has(column)) continue;
+		seenColumns.add(column);
+		orderedColumns.push(column);
+	}
+	const table = storageTableForContract(contract, namespaceId, tableName);
+	return { rows: rows.map((row) => {
+		if (orderedColumns.length === 0) return {};
+		const normalizedRow = {};
+		for (const column of orderedColumns) {
+			if (Object.hasOwn(row, column)) {
+				if (!table.columns[column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${column}" in table "${tableName}"`, { meta: {
+					namespaceId,
+					tableName,
+					column
+				} });
+				const codec = codecRefForStorageColumn(contract.storage, namespaceId, tableName, column);
+				normalizedRow[column] = ParamRef.of(row[column], {
+					name: column,
+					...ifDefined("codec", codec)
+				});
+				continue;
+			}
+			normalizedRow[column] = new DefaultValueExpr();
+		}
+		return normalizedRow;
+	}) };
+}
+function compileInsertReturning(contract, namespaceId, tableName, rows, returningColumns) {
+	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
+	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileInsertCount(contract, namespaceId, tableName, rows) {
+	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
+	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function stripUndefinedValues(row) {
 	const result = {};
 	for (const [key, value] of Object.entries(row)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function createTableRefRemapper$1(fromTable, toTable) {
+function createTableRefRemapper(fromTable, toTable) {
 	return {
 		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
 		tableSource: (source) => {
@@ -824,7 +1241,7 @@ function buildCountMutationWhere(contract, namespaceId, tableName, filters, vari
 	if (!polyInfo || !variant || variant.strategy !== "mti") return combineWhereExprs(filters);
 	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, tableName);
 	const baseTableRef = `${tableName}__write_filter`;
-	const remapper = createTableRefRemapper$1(tableName, baseTableRef);
+	const remapper = createTableRefRemapper(tableName, baseTableRef);
 	const innerFilters = filters.map((filter) => filter.rewrite(remapper));
 	const where = combineWhereExprs([BinaryExpr.eq(ColumnRef.of(baseTableRef, pkColumn), ColumnRef.of(tableName, pkColumn)), ...innerFilters]);
 	const joinOn = EqColJoinOn.of(ColumnRef.of(baseTableRef, pkColumn), ColumnRef.of(variant.table, pkColumn));
@@ -917,137 +1334,6 @@ function augmentSelectionForJoinColumns(selectedFields, requiredColumns) {
 		hiddenColumns
 	};
 }
-function namespaceCoordinateForSource(source) {
-	return source.kind === "table-source" ? source.namespaceId : void 0;
-}
-function bindWhereExpr(contract, expr, namespaceId) {
-	return bindWhereExprNode(contract, expr, namespaceId);
-}
-function bindWhereExprNode(contract, expr, namespaceId) {
-	return expr.accept({
-		columnRef(expr) {
-			return bindExpression(contract, expr);
-		},
-		identifierRef(expr) {
-			return expr;
-		},
-		subquery(expr) {
-			return bindExpression(contract, expr);
-		},
-		operation(expr) {
-			return bindExpression(contract, expr);
-		},
-		aggregate(expr) {
-			return bindExpression(contract, expr);
-		},
-		windowFunc(expr) {
-			return bindExpression(contract, expr);
-		},
-		functionCall(expr) {
-			return bindExpression(contract, expr);
-		},
-		cast(expr) {
-			return bindExpression(contract, expr);
-		},
-		case(expr) {
-			return bindExpression(contract, expr);
-		},
-		jsonObject(expr) {
-			return bindExpression(contract, expr);
-		},
-		jsonArrayAgg(expr) {
-			return bindExpression(contract, expr);
-		},
-		literal(expr) {
-			return expr;
-		},
-		param(expr) {
-			return expr;
-		},
-		preparedParam(expr) {
-			return expr;
-		},
-		list(expr) {
-			return bindExpression(contract, expr);
-		},
-		binary(expr) {
-			const left = bindExpression(contract, expr.left);
-			const bindingColumn = left.kind === "column-ref" ? left : void 0;
-			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, namespaceId));
-		},
-		and(expr) {
-			return AndExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
-		},
-		or(expr) {
-			return OrExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part, namespaceId)));
-		},
-		exists(expr) {
-			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
-		},
-		nullCheck(expr) {
-			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
-		},
-		not(expr) {
-			return new NotExpr(bindWhereExprNode(contract, expr.expr, namespaceId));
-		},
-		rawExpr(expr) {
-			return expr;
-		}
-	});
-}
-function bindComparable(contract, comparable, bindingColumn, namespaceId) {
-	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable);
-	if (comparable.kind === "literal") return createParamRef(contract, bindingColumn, comparable.value, namespaceId);
-	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? createParamRef(contract, bindingColumn, value.value, namespaceId) : value));
-	return bindExpression(contract, comparable);
-}
-function createParamRef(contract, columnRef, value, namespaceId) {
-	const resolved = resolveStorageTable(contract.storage, columnRef.table, namespaceId);
-	if (resolved === void 0 || !resolved.table.columns[columnRef.column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${columnRef.column}" in table "${columnRef.table}"`, { meta: {
-		tableName: columnRef.table,
-		column: columnRef.column
-	} });
-	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, columnRef.table, columnRef.column);
-	return ParamRef.of(value, codec ? { codec } : void 0);
-}
-function createExpressionBinder(contract) {
-	return { select: (ast) => bindSelectAst(contract, ast) };
-}
-function bindExpression(contract, expr) {
-	return expr.rewrite(createExpressionBinder(contract));
-}
-function bindProjectionExpr(contract, expr) {
-	return expr.kind === "literal" ? expr : bindExpression(contract, expr);
-}
-function bindOrderByItem(contract, orderItem) {
-	return new OrderByItem(bindExpression(contract, orderItem.expr), orderItem.dir);
-}
-function bindJoin(contract, join) {
-	const namespaceId = namespaceCoordinateForSource(join.source);
-	return new JoinAst(join.joinType, bindFromSource(contract, join.source), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExprNode(contract, join.on, namespaceId), join.lateral);
-}
-function bindFromSource(contract, source) {
-	if (source.kind === "table-source") return source;
-	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query));
-	return source;
-}
-function bindSelectAst(contract, ast) {
-	const namespaceId = ast.from !== void 0 ? namespaceCoordinateForSource(ast.from) : void 0;
-	return new SelectAst({
-		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from) } : {},
-		joins: ast.joins?.map((join) => bindJoin(contract, join)),
-		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codec)),
-		where: ast.where ? bindWhereExprNode(contract, ast.where, namespaceId) : void 0,
-		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
-		distinct: ast.distinct,
-		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr)),
-		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr)),
-		having: ast.having ? bindWhereExprNode(contract, ast.having, namespaceId) : void 0,
-		limit: ast.limit,
-		offset: ast.offset,
-		selectAllIntent: ast.selectAllIntent
-	});
-}
 /**
 * The rule for which JSON projection variant an include entry carries. Every
 * site that puts a value into a `json_build_object` or a `json_agg` goes
@@ -1098,98 +1384,38 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 		columnToField: getCompleteColumnToFieldMap(contract, namespaceId, variant.modelName)
 	}));
 	const baseSelectedFields = [];
-	const selectedMtiColumnsByTable = /* @__PURE__ */ new Map();
-	let hasVariantOwnedSelection = false;
-	for (const selectedField of state.selectedFields) {
-		const baseColumn = baseFieldToColumn[selectedField] ?? (baseTableColumns.has(selectedField) ? selectedField : void 0);
-		if (baseColumn !== void 0) appendUnique(baseSelectedFields, baseColumn);
-		let matchedVariantField = false;
-		for (const { variant, columnToField } of variantFieldMaps) for (const [column, field] of Object.entries(columnToField)) {
-			if (selectedField !== field && selectedField !== column) continue;
-			matchedVariantField = true;
-			hasVariantOwnedSelection = true;
-			if (variant.strategy === "sti") {
-				appendUnique(baseSelectedFields, column);
-				continue;
-			}
-			let selectedColumns = selectedMtiColumnsByTable.get(variant.table);
-			if (selectedColumns === void 0) {
-				selectedColumns = /* @__PURE__ */ new Set();
-				selectedMtiColumnsByTable.set(variant.table, selectedColumns);
-			}
-			selectedColumns.add(column);
-		}
-		if (baseColumn === void 0 && !matchedVariantField) appendUnique(baseSelectedFields, selectedField);
-	}
-	return {
-		baseSelectedFields,
-		selectedMtiColumnsByTable,
-		needsHiddenDiscriminator: state.variantName === void 0 && hasVariantOwnedSelection && !baseSelectedFields.includes(polyInfo.discriminatorColumn)
-	};
-}
-function buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableRef, needed) {
-	if (!needed) return [];
-	return [ProjectionItem.of(POLYMORPHIC_DISCRIMINATOR_ALIAS, ColumnRef.of(tableRef, polyInfo.discriminatorColumn), codecRefForStorageColumn(contract.storage, namespaceId, polyInfo.baseTable, polyInfo.discriminatorColumn))];
-}
-function createBoundaryExpr(tableName, entry) {
-	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
-}
-function buildLexicographicCursorWhere(tableName, entries) {
-	const branches = entries.map((entry, index) => {
-		const branchExprs = [];
-		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(ColumnRef.of(tableName, prefixEntry.column), LiteralExpr.of(prefixEntry.value)));
-		branchExprs.push(createBoundaryExpr(tableName, entry));
-		if (branchExprs.length === 1) {
-			const branch = branchExprs[0];
-			assertDefined(branch, "cursor branch contains its boundary expression");
-			return branch;
-		}
-		return AndExpr.of(branchExprs);
-	});
-	if (branches.length === 1) {
-		const branch = branches[0];
-		assertDefined(branch, "cursor expression contains its single branch");
-		return branch;
-	}
-	return OrExpr.of(branches);
-}
-function buildCursorWhere(tableName, orderBy, cursor) {
-	if (!cursor || !orderBy || orderBy.length === 0) return;
-	const entries = [];
-	for (const order of orderBy) {
-		if (order.expr.kind !== "column-ref") continue;
-		const column = order.expr.column;
-		const value = cursor[column];
-		if (value === void 0) throw ormError("ORM.CURSOR_VALUE_MISSING", `Missing cursor value for orderBy column "${column}"`, { meta: { column } });
-		entries.push({
-			column,
-			direction: order.dir,
-			value
-		});
+	const selectedMtiColumnsByTable = /* @__PURE__ */ new Map();
+	let hasVariantOwnedSelection = false;
+	for (const selectedField of state.selectedFields) {
+		const baseColumn = baseFieldToColumn[selectedField] ?? (baseTableColumns.has(selectedField) ? selectedField : void 0);
+		if (baseColumn !== void 0) appendUnique(baseSelectedFields, baseColumn);
+		let matchedVariantField = false;
+		for (const { variant, columnToField } of variantFieldMaps) for (const [column, field] of Object.entries(columnToField)) {
+			if (selectedField !== field && selectedField !== column) continue;
+			matchedVariantField = true;
+			hasVariantOwnedSelection = true;
+			if (variant.strategy === "sti") {
+				appendUnique(baseSelectedFields, column);
+				continue;
+			}
+			let selectedColumns = selectedMtiColumnsByTable.get(variant.table);
+			if (selectedColumns === void 0) {
+				selectedColumns = /* @__PURE__ */ new Set();
+				selectedMtiColumnsByTable.set(variant.table, selectedColumns);
+			}
+			selectedColumns.add(column);
+		}
+		if (baseColumn === void 0 && !matchedVariantField) appendUnique(baseSelectedFields, selectedField);
 	}
-	const firstEntry = entries[0];
-	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(tableName, firstEntry);
-	return buildLexicographicCursorWhere(tableName, entries);
-}
-function createTableRefRemapper(fromTable, toTable) {
 	return {
-		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
-		tableSource: (source) => {
-			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			return source;
-		},
-		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
+		baseSelectedFields,
+		selectedMtiColumnsByTable,
+		needsHiddenDiscriminator: state.variantName === void 0 && hasVariantOwnedSelection && !baseSelectedFields.includes(polyInfo.discriminatorColumn)
 	};
 }
-function buildStateWhere(contract, tableName, state, options) {
-	const filterTableName = options?.filterTableName;
-	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
-	const boundFilters = state.filters.map((filter) => bindWhereExpr(contract, filter, options?.namespaceId));
-	const remappedFilters = filterTableName && filterTableName !== tableName ? boundFilters.map((filter) => filter.rewrite(createTableRefRemapper(filterTableName, tableName))) : boundFilters;
-	const boundCursorWhere = cursorWhere ? bindWhereExpr(contract, cursorWhere, options?.namespaceId) : void 0;
-	const remappedCursorWhere = boundCursorWhere && filterTableName && filterTableName !== tableName ? boundCursorWhere.rewrite(createTableRefRemapper(filterTableName, tableName)) : boundCursorWhere;
-	return combineWhereExprs(remappedCursorWhere ? [...remappedFilters, remappedCursorWhere] : remappedFilters);
+function buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableRef, needed) {
+	if (!needed) return [];
+	return [ProjectionItem.of(POLYMORPHIC_DISCRIMINATOR_ALIAS, ColumnRef.of(tableRef, polyInfo.discriminatorColumn), codecRefForStorageColumn(contract.storage, namespaceId, polyInfo.baseTable, polyInfo.discriminatorColumn))];
 }
 function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 	if (!childOrderBy || childOrderBy.length === 0) return {
@@ -1208,35 +1434,6 @@ function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 		})
 	};
 }
-/**
-* Wrap a base SELECT in a `ROW_NUMBER() OVER (PARTITION BY … ORDER BY …) = 1`
-* filter, implementing Prisma-style `.distinct(cols)` semantics: one
-* representative row per `(distinctColumnRefs)` group is kept; the rest
-* are dropped.
-*
-* Picking which row survives in each partition is governed by
-* `rankingOrderBy`. When the caller's `orderBy` doesn't fully order rows
-* within a partition (e.g. user wrote `.distinct('title')` with no
-* `orderBy`, or ties in their ordering), the choice is
-* implementation-defined — matching Prisma's documented nested-distinct
-* behaviour. Callers that want determinism should pass an `orderBy` that
-* is total within each partition.
-*
-* The wrapper forwards every column of `base.projection` through the
-* derived alias, so the wrapper's projection is byte-identical in alias
-* names — making this transparent to any outer query (`json_agg`,
-* correlated subquery, top-level SELECT) that consumes the SELECT.
-*/
-function wrapWithRowNumberDedup(options) {
-	const { base, distinctColumnRefs, rankingOrderBy, rankedAlias } = options;
-	const rnAlias = "__prisma_distinct_rn";
-	const effectiveOrderBy = rankingOrderBy.length > 0 ? rankingOrderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
-	const inner = base.withProjection([...base.projection, ProjectionItem.of(rnAlias, WindowFuncExpr.rowNumber({
-		partitionBy: distinctColumnRefs,
-		orderBy: effectiveOrderBy
-	}))]);
-	return SelectAst.from(DerivedTableSource.as(rankedAlias, inner)).withProjection(base.projection.map((item) => ProjectionItem.of(item.alias, ColumnRef.of(rankedAlias, item.alias), item.codec))).withWhere(BinaryExpr.eq(ColumnRef.of(rankedAlias, rnAlias), LiteralExpr.of(1)));
-}
 function localColumnsForRowInclude(include) {
 	return include.through?.parentLocalColumns ?? [include.localColumn];
 }
@@ -1304,7 +1501,7 @@ function buildChildPolymorphismJoinsAndProjection(contract, include, childTableA
 		hiddenProjection,
 		baseSelectedFields: selection.baseSelectedFields
 	};
-	const remapper = createTableRefRemapper(polyInfo.baseTable, childTableRef);
+	const remapper = createTableRefRemapper$1(polyInfo.baseTable, childTableRef);
 	return {
 		joins: joins.map((join) => join.rewrite(remapper)),
 		projection,
@@ -1368,12 +1565,13 @@ function buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, throug
 }
 function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include) {
 	const childState = include.nested;
+	if (childState.distinctOn !== void 0 && childState.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, localColumnsForRowInclude(include));
 	const childSource = resolveChildTableSource(include, parentLocalRefs);
 	const childTableAlias = childSource.alias;
 	const childTableRef = childSource.tableRef;
 	const rowsAlias = `${include.relationName}__rows`;
-	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper(include.relatedTableName, childTableRef))) : childState.orderBy;
+	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : childState.orderBy;
 	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, remappedChildOrderBy);
 	const childWhere = buildStateWhere(contract, childTableRef, childState, {
 		filterTableName: include.relatedTableName,
@@ -1503,8 +1701,8 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 	};
 }
 /**
-* Build the inner SELECT for a scalar include reducer (`count` /
-* `sum` / `avg` / `min` / `max`).
+* Build the inner SELECT for a scalar include reducer (any operation the aggregate registry
+* contributes).
 *
 * Emits one row containing `json_build_object('value', AGG(...))`
 * over the child relation correlated to the parent via the FK. The
@@ -1513,18 +1711,18 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 * pulls `.value` out).
 *
 * The refine state's pipeline composes through to the aggregate's
-* input set: `where` / `orderBy` / `take` / `skip` / `distinct` shape
+* input set: `where` / `orderBy` / `limit` / `offset` / `distinct` shape
 * the rows the aggregate sees, matching the natural compositional
 * semantic of
 *
-*   `db.User.include('posts', p => p.where(W).take(N).count())  // ≤ N`
+*   `db.User.include('posts', p => p.where(W).limit(N).count())  // ≤ N`
 *
-* When `take` / `skip` / `distinct` is set, the aggregate's input
+* When `limit` / `offset` / `distinct` is set, the aggregate's input
 * cannot just be the bare correlated table — a top-level `LIMIT` on
 * the aggregating SELECT only trims the (already one-row) output, not
 * the rows being aggregated. We therefore wrap the source in a
 * derived SELECT that materialises the shaped row set, then
-* aggregate over that. `orderBy` alone (no `take` / `skip` /
+* aggregate over that. `orderBy` alone (no `limit` / `offset` /
 * `distinct`) is dropped at the SQL level since reordering does not
 * change which rows are aggregated.
 */
@@ -1542,6 +1740,7 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 	const childTableAlias = childSource.alias;
 	const childTableRef = childSource.tableRef;
 	const state = scalar.state;
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const childWhere = buildStateWhere(contract, childTableRef, state, {
 		filterTableName: include.relatedTableName,
 		namespaceId: include.relatedNamespaceId
@@ -1558,7 +1757,7 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 		const joinExpr = BinaryExpr.eq(ColumnRef.of(childTableRef, include.targetColumn), parentLocalRef);
 		whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
 	}
-	const remappedOrderBy = childTableAlias && state.orderBy ? state.orderBy.map((item) => item.rewrite(createTableRefRemapper(include.relatedTableName, childTableRef))) : state.orderBy;
+	const remappedOrderBy = childTableAlias && state.orderBy ? state.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : state.orderBy;
 	const hasPagination = state.limit !== void 0 || state.offset !== void 0;
 	const hasDistinct = state.distinct !== void 0 && state.distinct.length > 0 || state.distinctOn !== void 0 && state.distinctOn.length > 0;
 	if (!(hasPagination || hasDistinct)) {
@@ -1615,7 +1814,7 @@ function buildIncludeAggregateExpr(scalar, childTableRef, lower, inputCodec) {
 * Row branches reuse the standalone row-include builder; scalar
 * branches reuse `buildIncludeChildScalarSelect` — the `{value: ...}`
 * envelope survives into the combined JSON and the decoder unwraps
-* it per scalar branch. Distinct/take/skip semantics inside a row
+* it per scalar branch. Distinct/limit/offset semantics inside a row
 * branch fan out naturally because the row builder is invoked with
 * a synthetic IncludeExpr whose `nested` is the branch's state.
 */
@@ -1676,13 +1875,11 @@ function buildCorrelatedIncludeProjection(contract, aggregates, parentSource, in
 }
 function buildSelectAst(contract, tableName, state, options) {
 	const namespaceId = options.namespaceId;
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
 	const projection = [...buildProjection(contract, namespaceId, tableName, state.selectedFields, tableName), ...options.includeProjection ?? []];
-	const where = options.where ?? buildStateWhere(contract, tableName, state, { namespaceId });
-	const usesRowNumberDistinct = state.distinct !== void 0 && state.distinct.length > 0;
-	const fromSource = usesRowNumberDistinct ? DerivedTableSource.as(tableName, buildTopLevelDistinctRankedInner(contract, namespaceId, tableName, state, where)) : tableSourceForContract(contract, namespaceId, tableName);
+	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, options.where ?? buildStateWhere(contract, tableName, state, { namespaceId }), resolveTableColumns(contract, namespaceId, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))));
 	let ast = SelectAst.from(fromSource).withProjection(projection);
-	if (usesRowNumberDistinct) ast = ast.withWhere(BinaryExpr.eq(ColumnRef.of(tableName, "__prisma_distinct_rn"), LiteralExpr.of(1)));
-	else if (where) ast = ast.withWhere(where);
+	if (effectiveWhere) ast = ast.withWhere(effectiveWhere);
 	if (state.orderBy) ast = ast.withOrderBy(state.orderBy);
 	if (state.selectedFields === void 0) ast = ast.withSelectAllIntent({ table: tableName });
 	if (state.distinctOn && state.distinctOn.length > 0) ast = ast.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
@@ -1690,197 +1887,70 @@ function buildSelectAst(contract, tableName, state, options) {
 	if (state.offset !== void 0) ast = ast.withOffset(state.offset);
 	if (options.joins && options.joins.length > 0) ast = ast.withJoins(options.joins);
 	return ast;
-}
-function buildTopLevelDistinctRankedInner(contract, namespaceId, tableName, state, where) {
-	const distinctColumns = state.distinct;
-	if (distinctColumns === void 0 || distinctColumns.length === 0) throw new InternalError("buildTopLevelDistinctRankedInner called without `state.distinct`");
-	const allColsProjection = resolveTableColumns(contract, namespaceId, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column)));
-	const distinctColumnRefs = distinctColumns.map((column) => ColumnRef.of(tableName, column));
-	const rankingOrderBy = state.orderBy && state.orderBy.length > 0 ? state.orderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
-	let inner = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection([...allColsProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
-		partitionBy: distinctColumnRefs,
-		orderBy: rankingOrderBy
-	}))]);
-	if (where) inner = inner.withWhere(where);
-	return inner;
-}
-function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedColumnsByTable) {
-	const joins = [];
-	const projection = [];
-	const pkColumn = resolvePrimaryKeyColumn(contract, namespaceId, polyInfo.baseTable);
-	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
-	for (const variant of variantsToJoin) {
-		const joinType = variantName ? "inner" : "left";
-		const joinOn = EqColJoinOn.of(ColumnRef.of(polyInfo.baseTable, pkColumn), ColumnRef.of(variant.table, pkColumn));
-		const join = joinType === "inner" ? JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn) : JoinAst.left(tableSourceForContract(contract, namespaceId, variant.table), joinOn);
-		joins.push(join);
-		const variantColumns = resolveTableColumns(contract, namespaceId, variant.table);
-		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
-		for (const col of variantColumns) {
-			if (col === pkColumn) continue;
-			if (selectedColumnsByTable !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
-			const alias = `${variant.table}__${col}`;
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), codecRefForStorageColumn(contract.storage, namespaceId, variant.table, col)));
-		}
-	}
-	return {
-		joins,
-		projection
-	};
-}
-function compileSelect(contract, namespaceId, tableName, state, modelName) {
-	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
-	const projectionState = selection ? {
-		...state,
-		selectedFields: selection.baseSelectedFields
-	} : state;
-	const mtiArtifacts = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, selection?.selectedMtiColumnsByTable) : void 0;
-	const hiddenProjection = polyInfo && selection ? buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableName, selection.needsHiddenDiscriminator) : [];
-	const ast = buildSelectAst(contract, tableName, {
-		...projectionState,
-		includes: []
-	}, {
-		joins: mtiArtifacts?.joins ?? [],
-		includeProjection: [...mtiArtifacts?.projection ?? [], ...hiddenProjection],
-		namespaceId
-	});
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, state.annotations);
-}
-function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName, state, modelName) {
-	const includeJoins = [];
-	const includeProjection = [];
-	const topLevelWhere = buildStateWhere(contract, tableName, state, { namespaceId });
-	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
-	const projectionState = selection ? {
-		...state,
-		selectedFields: selection.baseSelectedFields
-	} : state;
-	if (polyInfo && selection) {
-		if (polyInfo.mtiVariants.length > 0) {
-			const mtiArtifacts = buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, selection.selectedMtiColumnsByTable);
-			includeJoins.push(...mtiArtifacts.joins);
-			includeProjection.push(...mtiArtifacts.projection);
-		}
-		includeProjection.push(...buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableName, selection.needsHiddenDiscriminator));
-	}
-	const parentSource = {
-		baseTableName: tableName,
-		tableRef: tableName,
-		variantColumnsProjected: false
-	};
-	for (const include of state.includes) {
-		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, parentSource, include);
-		includeProjection.push(artifact.projection);
-	}
-	const ast = buildSelectAst(contract, tableName, {
-		...projectionState,
-		includes: []
-	}, {
-		joins: includeJoins,
-		includeProjection,
-		namespaceId,
-		...ifDefined("where", topLevelWhere)
-	});
-	const { params } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, state.annotations);
-}
-function queryPlanRows(scope, plan) {
-	return scope.query(plan);
-}
-function emptyState() {
-	return {
-		filters: [],
-		includes: [],
-		orderBy: void 0,
-		cursor: void 0,
-		distinct: void 0,
-		distinctOn: void 0,
-		selectedFields: void 0,
-		limit: void 0,
-		offset: void 0,
-		variantName: void 0,
-		annotations: /* @__PURE__ */ new Map()
-	};
-}
-function param(codec, value) {
-	if (codec === void 0) return ParamRef.of(value);
-	return ParamRef.of(value, { codec });
-}
-function paramList(codec, values) {
-	return ListExpression.of(values.map((value) => param(codec, value)));
-}
-function scalarComparisonMethod(op) {
-	return ((left, codec) => (value) => {
-		if (value === null && (op === "eq" || op === "neq")) return op === "eq" ? NullCheckExpr.isNull(left) : NullCheckExpr.isNotNull(left);
-		return new BinaryExpr(op, left, param(codec, value));
-	});
-}
-function listComparisonMethod(op) {
-	return ((left, codec) => (values) => new BinaryExpr(op, left, paramList(codec, values)));
-}
-/**
-* Declares trait requirements and runtime factory for each comparison method.
-*
-* - `traits: []` means "no trait required" — always available
-* - Multi-trait: `traits: ['equality', 'order']` means BOTH traits are required
-*/
-const COMPARISON_METHODS_META = {
-	eq: {
-		traits: ["equality"],
-		create: scalarComparisonMethod("eq")
-	},
-	neq: {
-		traits: ["equality"],
-		create: scalarComparisonMethod("neq")
-	},
-	in: {
-		traits: ["equality"],
-		create: listComparisonMethod("in")
-	},
-	notIn: {
-		traits: ["equality"],
-		create: listComparisonMethod("notIn")
-	},
-	gt: {
-		traits: ["order"],
-		create: scalarComparisonMethod("gt")
-	},
-	lt: {
-		traits: ["order"],
-		create: scalarComparisonMethod("lt")
-	},
-	gte: {
-		traits: ["order"],
-		create: scalarComparisonMethod("gte")
-	},
-	lte: {
-		traits: ["order"],
-		create: scalarComparisonMethod("lte")
-	},
-	like: {
-		traits: ["textual"],
-		create: scalarComparisonMethod("like")
-	},
-	asc: {
-		traits: ["order"],
-		create: (left) => () => OrderByItem.asc(left)
-	},
-	desc: {
-		traits: ["order"],
-		create: (left) => () => OrderByItem.desc(left)
-	},
-	isNull: {
-		traits: [],
-		create: (left) => () => NullCheckExpr.isNull(left)
-	},
-	isNotNull: {
-		traits: [],
-		create: (left) => () => NullCheckExpr.isNotNull(left)
+}
+function compileSelect(contract, namespaceId, tableName, state, modelName) {
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
+	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
+	const projectionState = selection ? {
+		...state,
+		selectedFields: selection.baseSelectedFields
+	} : state;
+	const mtiArtifacts = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, selection?.selectedMtiColumnsByTable) : void 0;
+	const hiddenProjection = polyInfo && selection ? buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableName, selection.needsHiddenDiscriminator) : [];
+	const ast = buildSelectAst(contract, tableName, {
+		...projectionState,
+		includes: []
+	}, {
+		joins: mtiArtifacts?.joins ?? [],
+		includeProjection: [...mtiArtifacts?.projection ?? [], ...hiddenProjection],
+		namespaceId
+	});
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params, state.annotations);
+}
+function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName, state, modelName) {
+	const includeJoins = [];
+	const includeProjection = [];
+	const topLevelWhere = buildStateWhere(contract, tableName, state, { namespaceId });
+	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
+	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
+	const projectionState = selection ? {
+		...state,
+		selectedFields: selection.baseSelectedFields
+	} : state;
+	if (polyInfo && selection) {
+		if (polyInfo.mtiVariants.length > 0) {
+			const mtiArtifacts = buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, selection.selectedMtiColumnsByTable);
+			includeJoins.push(...mtiArtifacts.joins);
+			includeProjection.push(...mtiArtifacts.projection);
+		}
+		includeProjection.push(...buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableName, selection.needsHiddenDiscriminator));
 	}
-};
+	const parentSource = {
+		baseTableName: tableName,
+		tableRef: tableName,
+		variantColumnsProjected: false
+	};
+	for (const include of state.includes) {
+		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, parentSource, include);
+		includeProjection.push(artifact.projection);
+	}
+	const ast = buildSelectAst(contract, tableName, {
+		...projectionState,
+		includes: []
+	}, {
+		joins: includeJoins,
+		includeProjection,
+		namespaceId,
+		...ifDefined("where", topLevelWhere)
+	});
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params, state.annotations);
+}
+function queryPlanRows(scope, plan) {
+	return scope.query(plan);
+}
 function dispatchCollectionRows(options) {
 	const { context, runtime, state, tableName, modelName, namespaceId } = options;
 	const { contract } = context;
@@ -1892,22 +1962,18 @@ function dispatchWithIncludes(options) {
 	const { context, runtime, state, tableName, modelName, namespaceId } = options;
 	const { contract } = context;
 	const generator = async function* () {
-		const { scope, release } = await acquireRuntimeScope(runtime);
-		try {
-			const parentRowsRaw = await queryPlanRows(scope, compileSelectWithIncludes(contract, context.aggregateDescriptors, namespaceId, tableName, state, modelName)).toArray();
-			if (parentRowsRaw.length === 0) return;
-			const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-			const parentRows = parentRowsRaw.map((row) => {
-				return {
-					raw: row,
-					mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
-				};
-			});
-			for (const parent of parentRows) for (const include of state.includes) parent.mapped[include.relationName] = await decodeIncludePayload(contract, context, include, parent.raw[include.relationName]);
-			for (const row of parentRows) yield blindCast(row.mapped);
-		} finally {
-			if (release) await release();
-		}
+		const compiled = compileSelectWithIncludes(contract, context.aggregateDescriptors, namespaceId, tableName, state, modelName);
+		const parentRowsRaw = await queryPlanRows(runtime, compiled).toArray();
+		if (parentRowsRaw.length === 0) return;
+		const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+		const parentRows = parentRowsRaw.map((row) => {
+			return {
+				raw: row,
+				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
+			};
+		});
+		for (const parent of parentRows) for (const include of state.includes) parent.mapped[include.relationName] = await decodeIncludePayload(contract, context, include, parent.raw[include.relationName]);
+		for (const row of parentRows) yield blindCast(row.mapped);
 	};
 	return new AsyncIterableResult(generator());
 }
@@ -1981,11 +2047,9 @@ function buildIdentityInFilter(contract, namespaceId, tableName, identityColumns
 *
 * Scalar leaves arrive wrapped in a `{ value: <primitive> }` JSON
 * envelope (see `buildIncludeChildScalarSelect`); the branch below
-* unwraps that envelope and passes the value straight through. The
-* empty-relation default is driven by SQL semantics, not the decoder:
-* `COUNT(*)` over an empty input set is `0`; `SUM` / `AVG` / `MIN` /
-* `MAX` over an empty input set are SQL `NULL`, which surfaces as
-* `null` in TS — the documented contract for those reducers.
+* unwraps that envelope and passes the value straight through. The empty-relation value reads off
+* the operation's declared row via `emptyAggregateResult`: `null` where the row is nullable,
+* otherwise the row's declared empty value (so `count()` is `0`).
 *
 * Combine descriptors arrive as a JSON object keyed by branch name;
 * each branch is dispatched to the row or scalar decoder per its
@@ -2100,10 +2164,7 @@ function wrapIncludedDecodeFailure(error, ref, codecId) {
 * On a parent with zero matching child rows the correlated subquery
 * still produces one row (aggregates collapse the empty input to a
 * single row), so the combine envelope here is always present in the
-* read path. The
-* mutation read-back's `assignEmptyMutationIncludes` writes the empty
-* per-branch shape directly to `parent.mapped[relationName]` for any
-* parent absent from the read-back result and never enters the decoder,
+* read path. Mutation read-back goes through the same read dispatch,
 * so a missing or non-object envelope here is always a planner/decoder
 * bug — `parseCombineEnvelope` throws loudly rather than papering over
 * it with an empty shape.
@@ -2143,8 +2204,7 @@ function describeEnvelopeShape(value) {
 *
 * Contract: the envelope is always either
 *   - a `{ value: <primitive> }` JSON object (the SQL path), or
-*   - `null` / `undefined` (the mutation read-back's empty-include
-*     short-circuit, for a parent absent from the read-back result).
+*   - `null` / `undefined` (no row reached the decoder), answered with `emptyAggregateResult`.
 *
 * Any other shape — array, primitive, string that JSON-parses to
 * non-object — indicates a planner / decoder bug, so we throw
@@ -2255,224 +2315,78 @@ function dispatchSplitMutationRows(options) {
 			const mapped = mapStorageRow(rawRow);
 			if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
 			yield mapRow(mapped);
-		}
-	};
-	return new AsyncIterableResult(generator());
-}
-async function executeMutationReturningSingleRow(options) {
-	const { context, runtime, compiled, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
-	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
-	if (includes.length === 0) {
-		const first = (await queryPlanRows(runtime, compiled).toArray())[0];
-		if (!first) return null;
-		const mapped = mapStorageRow(first);
-		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
-		return mapRow(mapped);
-	}
-	const identityRows = await queryPlanRows(runtime, compiled).toArray();
-	if (identityRows.length === 0) return null;
-	for await (const row of reloadMutationRowsByIdentities({
-		context,
-		runtime,
-		tableName,
-		modelName,
-		namespaceId,
-		identityRows,
-		selectedFields,
-		includes
-	})) return row;
-	throw ormError("ORM.MUTATION_ROW_MISSING", onMissingRowMessage, { meta: {
-		operation,
-		model: modelName,
-		tableName
-	} });
-}
-function and(...exprs) {
-	return AndExpr.of(exprs);
-}
-function or(...exprs) {
-	return OrExpr.of(exprs);
-}
-function not(expr) {
-	return expr.not();
-}
-function all() {
-	return AndExpr.true();
-}
-function shorthandToWhereExpr(context, namespaceId, modelName, filters) {
-	const contract = context.contract;
-	const tableName = resolveModelTableName(contract, namespaceId, modelName);
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	const exprs = [];
-	for (const [fieldName, value] of Object.entries(filters)) {
-		if (value === void 0) continue;
-		const columnName = fieldToColumn[fieldName] ?? fieldName;
-		const left = ColumnRef.of(tableName, columnName);
-		if (value === null) {
-			exprs.push(NullCheckExpr.isNull(left));
-			continue;
-		}
-		assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName);
-		exprs.push(BinaryExpr.eq(left, LiteralExpr.of(value)));
-	}
-	if (exprs.length === 0) return;
-	return exprs.length === 1 ? exprs[0] : and(...exprs);
-}
-function assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName) {
-	const fieldType = modelOf(context.contract, namespaceId, modelName)?.fields?.[fieldName]?.type;
-	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
-	if (!(codecId ? context.codecDescriptors.descriptorFor(codecId)?.traits ?? [] : []).includes("equality")) throw ormError("ORM.FILTER_UNSUPPORTED", `Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`, { meta: {
-		model: modelName,
-		field: fieldName,
-		trait: "equality"
-	} });
-}
-var GroupedCollection = class GroupedCollection {
-	ctx;
-	contract;
-	modelName;
-	tableName;
-	namespaceId;
-	baseFilters;
-	groupByFields;
-	groupByColumns;
-	havingFilters;
-	constructor(ctx, modelName, options) {
-		this.ctx = ctx;
-		this.contract = ctx.context.contract;
-		this.modelName = modelName;
-		this.tableName = options.tableName;
-		this.namespaceId = options.namespaceId;
-		this.baseFilters = options.baseFilters;
-		this.groupByFields = options.groupByFields;
-		this.groupByColumns = options.groupByColumns;
-		this.havingFilters = options.havingFilters;
-	}
-	having(predicate) {
-		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.tableName));
-		return new GroupedCollection(this.ctx, this.modelName, {
-			tableName: this.tableName,
-			namespaceId: this.namespaceId,
-			baseFilters: this.baseFilters,
-			groupByFields: this.groupByFields,
-			groupByColumns: this.groupByColumns,
-			havingFilters: [...this.havingFilters, havingExpr]
-		});
-	}
-	/**
-	* Read terminal: run a grouped aggregate query.
-	*
-	* Accepts an optional `configure` callback that receives a
-	* `MetaBuilder<'read'>` for attaching typed annotations.
-	* Annotations are merged into the compiled plan's `meta.annotations`.
-	*/
-	async aggregate(fn, configure) {
-		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName));
-		const aggregateEntries = Object.entries(aggregateSpec);
-		if (aggregateEntries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
-			method: "groupBy.aggregate",
-			model: this.modelName
-		} });
-		for (const [alias, selector] of aggregateEntries) if (!isAggregateSelector(selector)) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `groupBy().aggregate() selector "${alias}" is invalid`, { meta: {
-			method: "groupBy.aggregate",
-			model: this.modelName,
-			alias
-		} });
-		let annotationsMap;
-		if (configure !== void 0) {
-			const meta = createMetaBuilder("read", "groupBy.aggregate");
-			configure(meta);
-			if (meta.annotations.size > 0) annotationsMap = meta.annotations;
-		}
-		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.baseFilters, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters)), annotationsMap);
-		return (await queryPlanRows(this.ctx.runtime, compiled).toArray()).map((row) => {
-			const mapped = mapStorageRowToModelFields(this.contract, this.namespaceId, this.modelName, row);
-			for (const [alias] of aggregateEntries) mapped[alias] = row[alias];
-			return mapped;
-		});
-	}
-};
-/**
-* The having metric methods, one per operation the registry contributes —
-* the runtime mirror of the contract's emitted aggregate map, which is what
-* types the surface as {@link HavingBuilder}. HAVING compares the value
-* inside the database, so only an operation's plain `AggregateExpr` form is
-* sound here: an operation outside the SQL aggregate alphabet exists only in
-* its descriptor-lowered form — a rendering for the driver boundary — and is
-* refused. The typed surface already excludes it; the runtime refusal covers
-* dynamic invocation.
-*/
-function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	const builder = {};
-	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
-		if (!isAggregateFn(operation)) throw ormError("ORM.AGGREGATE_PROJECTION_ONLY", `Aggregate operation '${operation}' is projection-only: it has no plain SQL form for HAVING, ORDER BY, or comparison positions.`, {
-			why: "An operation outside the SQL aggregate alphabet reaches SQL only through its descriptor's lowering hook — a rendering for the driver boundary. HAVING and ORDER BY compare the value inside the database, where that rendering would change SQL semantics.",
-			fix: `Project '${operation}' in a select and filter or order on the projected value, or use an operation from the SQL aggregate alphabet.`,
-			meta: { operation }
-		});
-		return createHavingComparisonMethods(new AggregateExpr(operation, field === void 0 ? void 0 : ColumnRef.of(tableName, fieldToColumn[field] ?? field)));
-	};
-	return blindCast(builder);
-}
-function createHavingComparisonMethods(metric) {
-	const buildBinaryExpr = (op, value) => new BinaryExpr(op, metric, LiteralExpr.of(value));
-	return {
-		eq(value) {
-			return buildBinaryExpr("eq", value);
-		},
-		neq(value) {
-			return buildBinaryExpr("neq", value);
-		},
-		gt(value) {
-			return buildBinaryExpr("gt", value);
-		},
-		lt(value) {
-			return buildBinaryExpr("lt", value);
-		},
-		gte(value) {
-			return buildBinaryExpr("gte", value);
-		},
-		lte(value) {
-			return buildBinaryExpr("lte", value);
-		}
-	};
-}
-function createIncludeScalar(fn, state, column) {
-	return {
-		kind: "includeScalar",
-		fn,
-		state,
-		...column !== void 0 ? { column } : {}
+		}
 	};
+	return new AsyncIterableResult(generator());
 }
-function createIncludeCombine(branches) {
-	return {
-		kind: "includeCombine",
-		branches
-	};
+async function executeMutationReturningSingleRow(options) {
+	const { context, runtime, compiled, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
+	const { contract } = context;
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	if (includes.length === 0) {
+		const first = (await queryPlanRows(runtime, compiled).toArray())[0];
+		if (!first) return null;
+		const mapped = mapStorageRow(first);
+		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
+		return mapRow(mapped);
+	}
+	const identityRows = await queryPlanRows(runtime, compiled).toArray();
+	if (identityRows.length === 0) return null;
+	for await (const row of reloadMutationRowsByIdentities({
+		context,
+		runtime,
+		tableName,
+		modelName,
+		namespaceId,
+		identityRows,
+		selectedFields,
+		includes
+	})) return row;
+	throw ormError("ORM.MUTATION_ROW_MISSING", onMissingRowMessage, { meta: {
+		operation,
+		model: modelName,
+		tableName
+	} });
 }
-function isIncludeScalar(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && isCollectionState(candidate.state);
+function and(...exprs) {
+	return AndExpr.of(exprs);
 }
-function isIncludeCombine(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	if (candidate.kind !== "includeCombine") return false;
-	if (typeof candidate.branches !== "object" || candidate.branches === null) return false;
-	return true;
+function or(...exprs) {
+	return OrExpr.of(exprs);
 }
-function isCollectionStateCarrier(value) {
-	if (typeof value !== "object" || value === null) return false;
-	return isCollectionState(value.state);
+function not(expr) {
+	return expr.not();
 }
-function isCollectionState(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const candidate = value;
-	return Array.isArray(candidate.filters) && Array.isArray(candidate.includes);
+function all() {
+	return AndExpr.true();
+}
+function shorthandToWhereExpr(context, namespaceId, modelName, filters) {
+	const contract = context.contract;
+	const tableName = resolveModelTableName(contract, namespaceId, modelName);
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const exprs = [];
+	for (const [fieldName, value] of Object.entries(filters)) {
+		if (value === void 0) continue;
+		const columnName = fieldToColumn[fieldName] ?? fieldName;
+		const left = ColumnRef.of(tableName, columnName);
+		if (value === null) {
+			exprs.push(NullCheckExpr.isNull(left));
+			continue;
+		}
+		assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName);
+		exprs.push(BinaryExpr.eq(left, LiteralExpr.of(value)));
+	}
+	if (exprs.length === 0) return;
+	return exprs.length === 1 ? exprs[0] : and(...exprs);
+}
+function assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName) {
+	const fieldType = modelOf(context.contract, namespaceId, modelName)?.fields?.[fieldName]?.type;
+	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
+	if (!(codecId ? context.codecDescriptors.descriptorFor(codecId)?.traits ?? [] : []).includes("equality")) throw ormError("ORM.FILTER_UNSUPPORTED", `Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`, { meta: {
+		model: modelName,
+		field: fieldName,
+		trait: "equality"
+	} });
 }
 function hasThrough$1(relation) {
 	return relation.through !== void 0;
@@ -2786,6 +2700,200 @@ function firstTargetColumn(contract, relation) {
 	if (!firstField) return;
 	return resolveFieldToColumn(contract, relation.toNamespace, relation.to, firstField);
 }
+var GroupedCollection = class GroupedCollection {
+	ctx;
+	contract;
+	modelName;
+	tableName;
+	namespaceId;
+	preGroupState;
+	groupByFields;
+	groupByColumns;
+	havingFilters;
+	postGroup;
+	constructor(ctx, modelName, options) {
+		this.ctx = ctx;
+		this.contract = ctx.context.contract;
+		this.modelName = modelName;
+		this.tableName = options.tableName;
+		this.namespaceId = blindCast(options.namespaceId);
+		this.preGroupState = options.preGroupState;
+		this.groupByFields = options.groupByFields;
+		this.groupByColumns = options.groupByColumns;
+		this.havingFilters = options.havingFilters;
+		this.postGroup = options.postGroup;
+	}
+	#clone(overrides) {
+		return blindCast(new GroupedCollection(this.ctx, this.modelName, {
+			tableName: this.tableName,
+			namespaceId: this.namespaceId,
+			preGroupState: this.preGroupState,
+			groupByFields: this.groupByFields,
+			groupByColumns: this.groupByColumns,
+			havingFilters: this.havingFilters,
+			postGroup: this.postGroup,
+			...overrides
+		}));
+	}
+	having(predicate) {
+		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.tableName));
+		return this.#clone({ havingFilters: [...this.havingFilters, havingExpr] });
+	}
+	/**
+	* Append an `ORDER BY` clause on the grouped rows themselves — orders by
+	* group key. Ordering by an aggregate alias needs a builder surface over
+	* the aliases and isn't supported here. Unlocks post-group `limit(...)` /
+	* `offset(...)`, which page a group order that would otherwise be undefined.
+	*/
+	orderBy(selection) {
+		const selectors = Array.isArray(selection) ? selection : [selection];
+		if (selectors.length === 0) throw ormError("ORM.ARGUMENT_INVALID", `orderBy() for model "${this.modelName}" requires at least one selector`, { meta: {
+			method: "orderBy",
+			model: this.modelName
+		} });
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName);
+		const nextOrders = selectors.map((selector) => selector(accessor));
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			orderBy: [...this.postGroup.orderBy, ...nextOrders]
+		} });
+	}
+	/**
+	* Apply `LIMIT n` to the grouped rows. Replaces any previous post-group
+	* limit. Requires a prior `orderBy(...)` — a database may return groups in
+	* any order, so "the first n groups" is undefined without one.
+	*/
+	limit(n) {
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			limit: n
+		} });
+	}
+	/**
+	* Apply `OFFSET n` to the grouped rows. Replaces any previous post-group
+	* offset. Requires a prior `orderBy(...)`, same as `limit(...)` — both
+	* pagination methods need a deterministic group order.
+	*/
+	offset(n) {
+		return this.#clone({ postGroup: {
+			...this.postGroup,
+			offset: n
+		} });
+	}
+	/**
+	* Read terminal: run a grouped aggregate query.
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'read'>` for attaching typed annotations.
+	* Annotations are merged into the compiled plan's `meta.annotations`.
+	*/
+	async aggregate(fn, configure) {
+		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName));
+		const aggregateEntries = Object.entries(aggregateSpec);
+		if (aggregateEntries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "groupBy().aggregate() requires at least one aggregation selector", { meta: {
+			method: "groupBy.aggregate",
+			model: this.modelName
+		} });
+		for (const [alias, selector] of aggregateEntries) if (!isAggregateSelector(selector)) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `groupBy().aggregate() selector "${alias}" is invalid`, { meta: {
+			method: "groupBy.aggregate",
+			model: this.modelName,
+			alias
+		} });
+		let annotationsMap;
+		if (configure !== void 0) {
+			const meta = createMetaBuilder("read", "groupBy.aggregate");
+			configure(meta);
+			if (meta.annotations.size > 0) annotationsMap = meta.annotations;
+		}
+		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.preGroupState, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters), this.modelName, this.postGroup), annotationsMap);
+		return (await queryPlanRows(this.ctx.runtime, compiled).toArray()).map((row) => {
+			const mapped = mapStorageRowToModelFields(this.contract, this.namespaceId, this.modelName, row);
+			for (const [alias] of aggregateEntries) mapped[alias] = row[alias];
+			return blindCast(mapped);
+		});
+	}
+};
+/**
+* The having metric methods, one per operation the registry contributes —
+* the runtime mirror of the contract's emitted aggregate map, which is what
+* types the surface as {@link HavingBuilder}. HAVING compares the value
+* inside the database, so only an operation's plain `AggregateExpr` form is
+* sound here: an operation outside the SQL aggregate alphabet exists only in
+* its descriptor-lowered form — a rendering for the driver boundary — and is
+* refused. The typed surface already excludes it; the runtime refusal covers
+* dynamic invocation.
+*/
+function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const builder = {};
+	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
+		if (!isAggregateFn(operation)) throw ormError("ORM.AGGREGATE_PROJECTION_ONLY", `Aggregate operation '${operation}' is projection-only: it has no plain SQL form for HAVING, ORDER BY, or comparison positions.`, {
+			why: "An operation outside the SQL aggregate alphabet reaches SQL only through its descriptor's lowering hook — a rendering for the driver boundary. HAVING and ORDER BY compare the value inside the database, where that rendering would change SQL semantics.",
+			fix: `Project '${operation}' in a select and filter or order on the projected value, or use an operation from the SQL aggregate alphabet.`,
+			meta: { operation }
+		});
+		return createHavingComparisonMethods(new AggregateExpr(operation, field === void 0 ? void 0 : ColumnRef.of(tableName, fieldToColumn[field] ?? field)));
+	};
+	return blindCast(builder);
+}
+function createHavingComparisonMethods(metric) {
+	const buildBinaryExpr = (op, value) => new BinaryExpr(op, metric, LiteralExpr.of(value));
+	return {
+		eq(value) {
+			return buildBinaryExpr("eq", value);
+		},
+		neq(value) {
+			return buildBinaryExpr("neq", value);
+		},
+		gt(value) {
+			return buildBinaryExpr("gt", value);
+		},
+		lt(value) {
+			return buildBinaryExpr("lt", value);
+		},
+		gte(value) {
+			return buildBinaryExpr("gte", value);
+		},
+		lte(value) {
+			return buildBinaryExpr("lte", value);
+		}
+	};
+}
+function createIncludeScalar(fn, state, column) {
+	return {
+		kind: "includeScalar",
+		fn,
+		state,
+		...column !== void 0 ? { column } : {}
+	};
+}
+function createIncludeCombine(branches) {
+	return {
+		kind: "includeCombine",
+		branches
+	};
+}
+function isIncludeScalar(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && isCollectionState(candidate.state);
+}
+function isIncludeCombine(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (candidate.kind !== "includeCombine") return false;
+	if (typeof candidate.branches !== "object" || candidate.branches === null) return false;
+	return true;
+}
+function isCollectionStateCarrier(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return isCollectionState(value.state);
+}
+function isCollectionState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return Array.isArray(candidate.filters) && Array.isArray(candidate.includes);
+}
 function createRelationMutator() {
 	return {
 		create(data) {
@@ -3463,34 +3571,6 @@ var CollectionImpl = class CollectionImpl {
 			variantName
 		});
 	}
-	/**
-	* Eagerly load a related model. The relation appears on every
-	* returned row under its declared name; to-one relations are mapped
-	* to a single object (or `null`), to-many relations to an array.
-	*
-	* An optional refinement callback receives a child collection that
-	* can be further constrained, projected, ordered, paginated, or
-	* reduced to scalars via `count()`/`sum()`/etc. or to multiple
-	* sub-aggregates via `combine()`.
-	*
-	* ```typescript
-	* // Simple include — every user comes back with its posts array:
-	* const users = await db.orm.User.include('posts').all();
-	*
-	* // Refine the related collection:
-	* const withRecent = await db.orm.User.include('posts', (posts) =>
-	*   posts.where({ published: true }).orderBy((p) => p.createdAt.desc()).take(5),
-	* ).all();
-	*
-	* // Reduce a to-many relation to a scalar value:
-	* const withCounts = await db.orm.User.include('posts', (posts) => posts.count()).all();
-	*
-	* // Multiple sub-views via combine():
-	* const overview = await db.orm.User.include('posts', (posts) =>
-	*   posts.combine({ recent: posts.take(3), total: posts.count() }),
-	* ).all();
-	* ```
-	*/
 	include(relationName, refineFn) {
 		const relation = resolveIncludeRelation(this.contract, this.namespaceId, this.modelName, relationName, this.state.variantName);
 		let nestedState = emptyState();
@@ -3594,10 +3674,11 @@ var CollectionImpl = class CollectionImpl {
 		return new GroupedCollection(this.ctx, this.modelName, {
 			tableName: this.tableName,
 			namespaceId: this.namespaceId,
-			baseFilters: this.state.filters,
+			preGroupState: this.state,
 			groupByFields: [...fields],
 			groupByColumns,
-			havingFilters: []
+			havingFilters: [],
+			postGroup: emptyGroupPagingState()
 		});
 	}
 	/**
@@ -3610,7 +3691,7 @@ var CollectionImpl = class CollectionImpl {
 	* ```typescript
 	* const users = await db.orm.User.include('posts', (posts) =>
 	*   posts.combine({
-	*     recent: posts.where({ published: true }).take(3),
+	*     recent: posts.where({ published: true }).limit(3),
 	*     total: posts.count(),
 	*     averageViews: posts.avg('views'),
 	*   }),
@@ -3652,14 +3733,14 @@ var CollectionImpl = class CollectionImpl {
 	* ```typescript
 	* const page1 = await db.orm.Post
 	*   .orderBy((p) => p.createdAt.desc())
-	*   .take(20)
+	*   .limit(20)
 	*   .all();
 	*
 	* const last = page1[page1.length - 1]!;
 	* const page2 = await db.orm.Post
 	*   .orderBy((p) => p.createdAt.desc())
 	*   .cursor({ createdAt: last.createdAt })
-	*   .take(20)
+	*   .limit(20)
 	*   .all();
 	* ```
 	*/
@@ -3689,6 +3770,8 @@ var CollectionImpl = class CollectionImpl {
 	* prior `orderBy(...)`; replaces any previous `distinct(...)` /
 	* `distinctOn(...)` selection.
 	*
+	* Requires the `postgres.distinctOn` capability.
+	*
 	* ```typescript
 	* // Latest post per user:
 	* const latestPerUser = await db.orm.Post
@@ -3698,6 +3781,7 @@ var CollectionImpl = class CollectionImpl {
 	* ```
 	*/
 	distinctOn(...fields) {
+		assertDistinctOnCapability(this.contract, "distinctOn");
 		const distinctOnFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
 		return this.#clone({
 			distinct: void 0,
@@ -3708,10 +3792,10 @@ var CollectionImpl = class CollectionImpl {
 	* Apply `LIMIT n`. Replaces any previous limit set on this collection.
 	*
 	* ```typescript
-	* const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).take(10).all();
+	* const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).limit(10).all();
 	* ```
 	*/
-	take(n) {
+	limit(n) {
 		return this.#clone({ limit: n });
 	}
 	/**
@@ -3720,12 +3804,12 @@ var CollectionImpl = class CollectionImpl {
 	* ```typescript
 	* const page2 = await db.orm.User
 	*   .orderBy((u) => u.id.asc())
-	*   .skip(10)
-	*   .take(10)
+	*   .offset(10)
+	*   .limit(10)
 	*   .all();
 	* ```
 	*/
-	skip(n) {
+	offset(n) {
 		return this.#clone({ offset: n });
 	}
 	/**
@@ -3738,15 +3822,9 @@ var CollectionImpl = class CollectionImpl {
 	* whichever fits the caller. A single result can only be consumed
 	* once.
 	*
-	* Streaming is the default and the expected execution model. The
-	* only scenarios that fall back to buffering internally before
-	* yielding are drivers that cannot expose a cursor to the
-	* underlying database, and — for queries with `include(...)` —
-	* targets whose SQL dialect supports neither lateral joins nor
-	* correlated subqueries (so child rows cannot be stitched in a
-	* single streaming query). These are implementation details below
-	* the public API; the iteration shape itself is genuinely
-	* streaming whenever the driver and plan allow it.
+	* Queries without `include(...)` stream rows as the driver yields them (drivers that cannot
+	* expose a cursor buffer internally first). Queries with `include(...)` read the whole parent
+	* result set into memory before yielding the first row.
 	*
 	* ```typescript
 	* // Thenable — collect to an array:
@@ -3773,7 +3851,7 @@ var CollectionImpl = class CollectionImpl {
 		return this.#withAnnotationsFromMeta(configure, "all").#dispatch();
 	}
 	async first(filter, configure) {
-		return (await (filter === void 0 ? this : typeof filter === "function" ? this.where(filter) : this.where(filter)).take(1).#withAnnotationsFromMeta(configure, "first").#dispatch().toArray())[0] ?? null;
+		return (await (filter === void 0 ? this : typeof filter === "function" ? this.where(filter) : this.where(filter)).limit(1).#withAnnotationsFromMeta(configure, "first").#dispatch().toArray())[0] ?? null;
 	}
 	/**
 	* Read terminal: run an aggregate query (count, sum, avg, min, max)
@@ -3809,7 +3887,7 @@ var CollectionImpl = class CollectionImpl {
 			alias
 		} });
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "read", "aggregate");
-		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state.filters, aggregateSpec), annotationsMap);
+		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state, aggregateSpec, this.modelName), annotationsMap);
 		const row = (await queryPlanRows(this.ctx.runtime, compiled).toArray())[0] ?? {};
 		const result = {};
 		for (const [alias, selector] of entries) result[alias] = row[alias] ?? this.#emptyAggregateValue(selector);
@@ -4137,12 +4215,13 @@ var CollectionImpl = class CollectionImpl {
 	* Requires a prior `.where(...)` — calling `update(...)` on an
 	* unfiltered collection is a type error.
 	*
-	* Related rows can be created or relinked through relation
-	* callbacks on parent/child-owned relations (one-to-one or
-	* one-to-many). The callback receives a mutator exposing
-	* `create(...)`, `connect(...)`, and `disconnect(...)`. Nested
-	* updates against existing related rows, and many-to-many relations
-	* as nested-mutation targets, are not supported through this API.
+	* Related rows can be created, linked, or unlinked through relation callbacks on any relation:
+	* to-one (1:1, N:1), to-many (1:N), and many-to-many (N:M, written through the junction table).
+	* The callback receives a mutator exposing `create(...)`, `connect(...)`, and `disconnect(...)`.
+	* A to-one `disconnect()` clears the foreign key; a to-many `disconnect()` with no criteria
+	* unlinks every related row; an N:M `disconnect()` requires criteria. N:M `create`/`connect` are
+	* unavailable when the junction has required columns the relation API cannot populate. Nested
+	* updates against existing related rows are not supported through this API.
 	*
 	* ```typescript
 	* // Update one row by id:
@@ -4164,9 +4243,9 @@ var CollectionImpl = class CollectionImpl {
 	*
 	* Note: when the input contains nested-mutation callbacks, the
 	* operation is executed as a graph of internal queries via
-	* `withMutationScope`. In that path, annotations apply to the logical
-	* `update()` call but do not currently flow into each constituent SQL
-	* statement issued for the related rows.
+	* `withMutationScope`. In that path the `configure` callback still runs, so `meta.annotate`
+	* validation applies, but the recorded annotations are discarded: neither the nested
+	* statements nor the read-back query carry them.
 	*/
 	async update(data, configure) {
 		assertReturningCapability(this.contract, "update()");
@@ -4573,7 +4652,7 @@ var CollectionImpl = class CollectionImpl {
 	* compiled plan is post-wrapped via `mergeAnnotations` instead.
 	* Read terminals `all` and `first` populate `state.annotations`
 	* via `#withAnnotationsFromMeta` instead; `aggregate` uses this
-	* post-wrap path because its compile function doesn't take `state`.
+	* post-wrap path because `compileAggregate` does not forward `state.annotations` into the plan.
 	* The meta builder's `annotate` method enforces applicability at the
 	* type level and at runtime.
 	*/