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

package/dist/orm-client.mjs

@@ -1,8 +1,8 @@
 import { t as resolveStorageTable } from "./resolve-storage-table-DZsfnzeW.mjs";
 import { i as isUniqueConstraintViolation } from "./dist-x6jvtkKM.mjs";
-import { B as isWhereExpr, 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, _ 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-D-_2ZCos-9q6j1gKx.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-CSP6WmWn-DVuxsZJW.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
-import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-DDAyIKdt.mjs";
+import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-B-eeN74F.mjs";
 import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-BQPj9q8O.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -12,6 +12,26 @@ 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();
+/**
+* The operation vocabulary the composed registry contributes, in contribution
+* order — the runtime mirror of the contract's emitted aggregate map, both
+* settled from the same contributed descriptors. Cached per registry: the set
+* is fixed at composition time, and every collection construction reads it.
+*/
+function aggregateOperationNames(registry) {
+	const cached = operationNamesByRegistry.get(registry);
+	if (cached !== void 0) return cached;
+	const names = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const { operation } of registry.values()) {
+		if (seen.has(operation)) continue;
+		seen.add(operation);
+		names.push(operation);
+	}
+	operationNamesByRegistry.set(registry, names);
+	return names;
+}
 function ormError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -343,70 +363,31 @@ function capabilityEnabled(value) {
 function isToOneCardinality(cardinality) {
 	return cardinality === "1:1" || cardinality === "N:1";
 }
-function createAggregateBuilder(contract, namespaceId, modelName) {
+/**
+* The aggregate selector 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 AggregateBuilder}. Each method builds a selector
+* carrying the operation's name and, for a field-taking call, the field's
+* storage column; what a selector resolves to is the plan compiler's question
+* to the same registry.
+*/
+function createAggregateBuilder(contract, aggregates, namespaceId, modelName) {
 	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	return {
-		count() {
-			return {
-				kind: "aggregate",
-				fn: "count"
-			};
-		},
-		sum(field) {
-			return createFieldAggregateSelector(fieldToColumn, field, "sum");
-		},
-		avg(field) {
-			return createFieldAggregateSelector(fieldToColumn, field, "avg");
-		},
-		min(field) {
-			return createFieldAggregateSelector(fieldToColumn, field, "min");
-		},
-		max(field) {
-			return createFieldAggregateSelector(fieldToColumn, field, "max");
-		}
+	const builder = {};
+	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
+		const column = field === void 0 ? void 0 : fieldToColumn[field] ?? field;
+		return {
+			kind: "aggregate",
+			fn: operation,
+			...ifDefined("column", column)
+		};
 	};
+	return blindCast(builder);
 }
 function isAggregateSelector(value) {
 	if (!value || typeof value !== "object") return false;
 	const candidate = value;
-	if (candidate.kind !== "aggregate") return false;
-	return candidate.fn === "count" || candidate.fn === "sum" || candidate.fn === "avg" || candidate.fn === "min" || candidate.fn === "max";
-}
-/**
-* The selector's result type is the contract's to state — it varies by target, operation, and the field's own codec — so the builder erases it here and each method's declared return type names it.
-*/
-function createFieldAggregateSelector(fieldToColumn, field, fn) {
-	return {
-		kind: "aggregate",
-		fn,
-		column: fieldToColumn[field] ?? field
-	};
-}
-/**
-* What an aggregate reads as when there is no row to read at all.
-*
-* SQL answers an empty input set itself — `count` collapses to zero, the rest
-* to null — so this covers only the degenerate case of a result set with no
-* row: an absent aggregate alias, or an include whose envelope never arrived.
-* Zero is a `bigint` because that is what both targets' `count` codecs decode
-* to; a count is a cardinality, and cardinalities are not capped at 2^53.
-*/
-function emptyAggregateResult(fn) {
-	return fn === "count" ? 0n : null;
-}
-function mapFieldsToColumns(contract, namespaceId, modelName, fieldNames) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	return fieldNames.map((fieldName) => fieldToColumn[fieldName] ?? fieldName);
-}
-function mapCursorValuesToColumns(contract, namespaceId, modelName, cursorValues) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	const mappedCursor = {};
-	for (const [fieldName, value] of Object.entries(cursorValues)) {
-		if (value === void 0) continue;
-		const columnName = fieldToColumn[fieldName] ?? fieldName;
-		mappedCursor[columnName] = value;
-	}
-	return mappedCursor;
+	return candidate.kind === "aggregate" && typeof candidate.fn === "string";
 }
 /**
 * What an aggregate resolves to: the codec its result carries, and the expression the target wants built for it.
@@ -419,15 +400,26 @@ function resolveAggregate(query) {
 	const input = inputCodecRef(query);
 	const resolved = query.aggregates.resolve(query.fn, input);
 	if (resolved === void 0) throw unsupportedAggregate(query, input);
+	const nullability = resolved.nullable ? { nullable: true } : {
+		nullable: false,
+		emptyResultJson: resolved.emptyResultJson
+	};
 	return {
 		codec: resolved.output,
+		...nullability,
 		input,
 		lower: resolved.lower
 	};
 }
-/** The codec an aggregate's result carries. Rejects a pair the composed stack declares no overload for, exactly as planning does. */
-function resolveAggregateOutputCodec(query) {
-	return resolveAggregate(query).codec;
+/**
+* The plain SQL form of an operation in the closed aggregate alphabet.
+* Registry composition guarantees every operation outside the alphabet
+* carries a lowering hook, so a resolution without one for any other name is
+* a composition bug, not a user error.
+*/
+function plainAggregateExpr(fn, expr) {
+	if (!isAggregateFn(fn)) throw new InternalError(`aggregate operation '${fn}' is outside the SQL aggregate alphabet and resolved without a lowering hook`);
+	return new AggregateExpr(fn, expr);
 }
 function unsupportedAggregate(query, input) {
 	return ormError("ORM.AGGREGATE_UNSUPPORTED", input === void 0 ? `The composed target declares no '${query.fn}' aggregate for a call without an input.` : `The composed target declares no '${query.fn}' aggregate over codec '${input.codecId}' (column '${query.column}' of table '${query.tableName}').`, {
@@ -445,6 +437,36 @@ function unsupportedAggregate(query, input) {
 function inputCodecRef(query) {
 	return query.column === void 0 ? void 0 : codecRefForStorageColumn(query.contract.storage, query.namespaceId, query.tableName, query.column);
 }
+/**
+* What an aggregate reads as when there is no row to read at all.
+*
+* SQL answers an empty input set itself — a nullable-declared aggregate
+* collapses to NULL, a non-nullable one to a value SQL still produces, a
+* count's zero cardinality — so this covers only the degenerate case of a
+* result set with no row: an absent aggregate alias, or an include whose
+* envelope never arrived. The answer reads off the operation's declared row:
+* NULL where the row is nullable, else the value the row declares, decoded
+* through the codec it declared beside it — so the application sees the same
+* value shape a real row would produce, in whichever form that codec's
+* canonical JSON takes.
+*/
+function emptyAggregateResult(result, codec) {
+	return result.nullable ? null : codec.decodeJson(result.emptyResultJson);
+}
+function mapFieldsToColumns(contract, namespaceId, modelName, fieldNames) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	return fieldNames.map((fieldName) => fieldToColumn[fieldName] ?? fieldName);
+}
+function mapCursorValuesToColumns(contract, namespaceId, modelName, cursorValues) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const mappedCursor = {};
+	for (const [fieldName, value] of Object.entries(cursorValues)) {
+		if (value === void 0) continue;
+		const columnName = fieldToColumn[fieldName] ?? fieldName;
+		mappedCursor[columnName] = value;
+	}
+	return mappedCursor;
+}
 function stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns) {
 	if (hiddenColumns.length === 0) return;
 	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
@@ -611,7 +633,7 @@ function toAggregateProjection(contract, aggregates, namespaceId, tableName, sel
 		expr: lower !== void 0 ? lower({
 			expr: inputExpr,
 			inputCodec
-		}) : new AggregateExpr(selector.fn, inputExpr),
+		}) : plainAggregateExpr(selector.fn, inputExpr),
 		codec
 	};
 }
@@ -1579,7 +1601,7 @@ function buildIncludeAggregateExpr(scalar, childTableRef, lower, inputCodec) {
 		expr,
 		inputCodec
 	});
-	return new AggregateExpr(scalar.fn, expr);
+	return plainAggregateExpr(scalar.fn, expr);
 }
 /**
 * Build the inner SELECT for a `combine({ a, b, ... })` include.
@@ -2121,9 +2143,8 @@ 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
-*     `assignEmptyMutationIncludes` short-circuit before this decoder
-*     runs, for a parent absent from the read-back result).
+*   - `null` / `undefined` (the mutation read-back's empty-include
+*     short-circuit, for a parent absent from the read-back result).
 *
 * Any other shape — array, primitive, string that JSON-parses to
 * non-object — indicates a planner / decoder bug, so we throw
@@ -2132,21 +2153,16 @@ function describeEnvelopeShape(value) {
 *
 * The value passes through its own codec — the one the planner projected it
 * under — because it arrived inside a JSON document, where a count past 2^53
-* would otherwise have been read as a rounded number. SQL semantics drive the
-* empty-relation case: `COUNT(*)` over an empty input set is `0`;
-* `SUM` / `AVG` / `MIN` / `MAX` over an empty input set return SQL
-* `NULL`, which surfaces as `null` here. The outer `raw === null`
-* fallback is defensive cover for an empty parent set; in single-query
-* dispatch the correlated subquery always produces a row, so the inner
-* envelope's `value` is always set by SQL.
+* would otherwise have been read as a rounded number. Resolution mirrors
+* planning — the same registry, operation, and column — so the empty-relation
+* answer derives from the operation's declared row: NULL where the row is
+* nullable, else the value that row declares. The outer `raw === null` fallback is
+* defensive cover for an empty parent set; in single-query dispatch the
+* correlated subquery always produces a row, so the inner envelope's `value`
+* is always set by SQL.
 */
 function decodeScalarIncludePayload(contract, context, include, scalar, raw) {
-	if (raw === null || raw === void 0) return emptyAggregateResult(scalar.fn);
-	const parsed = parseIncludePayload(raw);
-	if (!isPlainObjectEnvelope(parsed)) throw new InternalError(`scalar() envelope for include "${include.relationName}" has unexpected shape (expected object, got ${describeEnvelopeShape(parsed)}); this indicates a planner or decoder bug.`);
-	const value = parsed["value"];
-	if (value === null || value === void 0) return emptyAggregateResult(scalar.fn);
-	const codecRef = resolveAggregateOutputCodec({
+	const resolved = resolveAggregate({
 		aggregates: context.aggregateDescriptors,
 		contract,
 		namespaceId: include.relatedNamespaceId,
@@ -2154,10 +2170,16 @@ function decodeScalarIncludePayload(contract, context, include, scalar, raw) {
 		fn: scalar.fn,
 		column: scalar.column
 	});
+	const codec = context.contractCodecs.forCodecRef(resolved.codec);
+	if (raw === null || raw === void 0) return emptyAggregateResult(resolved, codec);
+	const parsed = parseIncludePayload(raw);
+	if (!isPlainObjectEnvelope(parsed)) throw new InternalError(`scalar() envelope for include "${include.relationName}" has unexpected shape (expected object, got ${describeEnvelopeShape(parsed)}); this indicates a planner or decoder bug.`);
+	const value = parsed["value"];
+	if (value === null || value === void 0) return emptyAggregateResult(resolved, codec);
 	return decodeIncludedJsonValue({
 		table: include.relatedTableName,
 		column: include.relationName
-	}, codecRef.codecId, context.contractCodecs.forCodecRef(codecRef), value);
+	}, resolved.codec.codecId, codec, value);
 }
 function parseIncludedRows(include, value) {
 	if (value === null || value === void 0) return [];
@@ -2328,7 +2350,7 @@ var GroupedCollection = class GroupedCollection {
 		this.havingFilters = options.havingFilters;
 	}
 	having(predicate) {
-		const havingExpr = predicate(createHavingBuilder(this.contract, this.namespaceId, this.modelName, this.tableName));
+		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,
@@ -2346,7 +2368,7 @@ var GroupedCollection = class GroupedCollection {
 	* Annotations are merged into the compiled plan's `meta.annotations`.
 	*/
 	async aggregate(fn, configure) {
-		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.namespaceId, this.modelName));
+		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",
@@ -2371,26 +2393,28 @@ var GroupedCollection = class GroupedCollection {
 		});
 	}
 };
-function createHavingBuilder(contract, namespaceId, modelName, tableName) {
+/**
+* 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 createMetricExpr = (fn, fieldName) => new AggregateExpr(fn, ColumnRef.of(tableName, fieldToColumn[fieldName] ?? fieldName));
-	return {
-		count() {
-			return createHavingComparisonMethods(AggregateExpr.count());
-		},
-		sum(field) {
-			return createHavingComparisonMethods(createMetricExpr("sum", field));
-		},
-		avg(field) {
-			return createHavingComparisonMethods(createMetricExpr("avg", field));
-		},
-		min(field) {
-			return createHavingComparisonMethods(createMetricExpr("min", field));
-		},
-		max(field) {
-			return createHavingComparisonMethods(createMetricExpr("max", field));
-		}
+	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));
@@ -2415,13 +2439,6 @@ function createHavingComparisonMethods(metric) {
 		}
 	};
 }
-const aggregateFns = /* @__PURE__ */ new Set([
-	"count",
-	"sum",
-	"avg",
-	"min",
-	"max"
-]);
 function createIncludeScalar(fn, state, column) {
 	return {
 		kind: "includeScalar",
@@ -2439,7 +2456,7 @@ function createIncludeCombine(branches) {
 function isIncludeScalar(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const candidate = value;
-	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && aggregateFns.has(candidate.fn) && isCollectionState(candidate.state);
+	return candidate.kind === "includeScalar" && typeof candidate.fn === "string" && isCollectionState(candidate.state);
 }
 function isIncludeCombine(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -3332,7 +3349,7 @@ function isWhereDirectInput(value) {
 function isMtiVariantInfo(variant) {
 	return variant?.strategy === "mti";
 }
-var Collection = class Collection {
+var CollectionImpl = class CollectionImpl {
 	/** @internal */
 	ctx;
 	/** @internal */
@@ -3358,6 +3375,49 @@ var Collection = class Collection {
 		this.state = options.state ?? emptyState();
 		this.registry = options.registry ?? /* @__PURE__ */ new Map();
 		this.includeRefinementMode = options.includeRefinementMode ?? false;
+		this.#installAggregateReducers();
+	}
+	/**
+	* Install one include-scalar reducer per operation the composed registry
+	* contributes — the runtime mirror of the contract's emitted aggregate map,
+	* which is what types the reducers as {@link AggregateIncludeReducers} on
+	* the public {@link Collection} surface. The reducers live on the instance
+	* because their names are the registry's, not the class declaration's.
+	*
+	* A name the collection already carries is skipped, and which member holds
+	* it decides what the skip means. A `CollectionImpl` member is rejected at
+	* ORM composition with `ORM.AGGREGATE_OPERATION_RESERVED`, since
+	* {@link reservedCollectionMemberNames} scans this class. A member declared
+	* by a custom collection class registered through `orm({ collections })`
+	* falls outside that set, so it keeps the name and the operation gets no
+	* reducer. The type level is what guards that case: {@link Collection}
+	* intersects the class with {@link AggregateIncludeReducers}, so for any
+	* contract whose emitted map carries the operation, a subclass member that
+	* does not match the reducer's signature is a type error.
+	*/
+	#installAggregateReducers() {
+		for (const operation of aggregateOperationNames(this.ctx.context.aggregateDescriptors)) {
+			if (operation in this) continue;
+			Object.defineProperty(this, operation, {
+				value: (field) => this.#includeScalarReducer(operation, field),
+				writable: true,
+				enumerable: false,
+				configurable: true
+			});
+		}
+	}
+	/**
+	* Scalar reducer — reduces a to-many relation to the operation's value over
+	* the related rows. Use inside an `include(...)` refinement callback as
+	* `include(..., (rel) => rel.count())`; throws if called elsewhere. The
+	* parent row's relation field becomes that value instead of an array. A
+	* call without a field aggregates over rows; a call with one aggregates the
+	* field's storage column.
+	*/
+	#includeScalarReducer(operation, field) {
+		this.#assertIncludeRefinementMode(`${operation}()`);
+		const column = field === void 0 ? void 0 : resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
+		return createIncludeScalar(operation, this.state, column);
 	}
 	where(input) {
 		const filter = normalizeWhereArg(typeof input === "function" ? input(createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, this.state.variantName)) : isWhereDirectInput(input) ? input : shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, input), {
@@ -3524,7 +3584,7 @@ var Collection = class Collection {
 	*   .where({ published: true })
 	*   .groupBy('userId')
 	*   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum('views') }));
-	* // [{ userId: 1, count: 3n, totalViews: 120n }, ...]
+	* // [{ userId: 1, count: 3, totalViews: 120 }, ...]
 	* ```
 	*/
 	groupBy(...fields) {
@@ -3539,84 +3599,6 @@ var Collection = class Collection {
 		});
 	}
 	/**
-	* Scalar reducer — reduces a to-many relation to the number of
-	* related rows. Use inside an `include(...)` refinement callback as
-	* `include(..., (rel) => rel.count())`; throws if called elsewhere.
-	* The parent row's relation field becomes that count instead of an
-	* array.
-	*
-	* ```typescript
-	* const users = await db.orm.User.include('posts', (posts) => posts.count()).all();
-	* // each user row: { ...user, posts: bigint }
-	* ```
-	*/
-	count() {
-		this.#assertIncludeRefinementMode("count()");
-		return createIncludeScalar("count", this.state);
-	}
-	/**
-	* Scalar reducer — reduces a to-many relation to the sum of `field`
-	* across related rows. Returns `null` when there are no related
-	* rows. Use inside an `include(...)` refinement callback; throws if
-	* called elsewhere.
-	*
-	* ```typescript
-	* const users = await db.orm.User.include('posts', (posts) => posts.sum('views')).all();
-	* // each user row: { ...user, posts: bigint | null } — an int4 column's sum widens to int8
-	* ```
-	*/
-	sum(field) {
-		this.#assertIncludeRefinementMode("sum()");
-		const columnName = resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
-		return createIncludeScalar("sum", this.state, columnName);
-	}
-	/**
-	* Scalar reducer — reduces a to-many relation to the average of
-	* `field` across related rows. Returns `null` when there are no
-	* related rows. Use inside an `include(...)` refinement callback;
-	* throws if called elsewhere.
-	*
-	* ```typescript
-	* const users = await db.orm.User.include('posts', (posts) => posts.avg('views')).all();
-	* // each user row: { ...user, posts: string | null } — PostgreSQL averages integers as numeric
-	* ```
-	*/
-	avg(field) {
-		this.#assertIncludeRefinementMode("avg()");
-		const columnName = resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
-		return createIncludeScalar("avg", this.state, columnName);
-	}
-	/**
-	* Scalar reducer — reduces a to-many relation to the minimum value
-	* of `field` across related rows. Returns `null` when there are no
-	* related rows. Use inside an `include(...)` refinement callback;
-	* throws if called elsewhere.
-	*
-	* ```typescript
-	* const users = await db.orm.User.include('posts', (posts) => posts.min('views')).all();
-	* ```
-	*/
-	min(field) {
-		this.#assertIncludeRefinementMode("min()");
-		const columnName = resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
-		return createIncludeScalar("min", this.state, columnName);
-	}
-	/**
-	* Scalar reducer — reduces a to-many relation to the maximum value
-	* of `field` across related rows. Returns `null` when there are no
-	* related rows. Use inside an `include(...)` refinement callback;
-	* throws if called elsewhere.
-	*
-	* ```typescript
-	* const users = await db.orm.User.include('posts', (posts) => posts.max('views')).all();
-	* ```
-	*/
-	max(field) {
-		this.#assertIncludeRefinementMode("max()");
-		const columnName = resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
-		return createIncludeScalar("max", this.state, columnName);
-	}
-	/**
 	* Produce multiple named sub-views of a to-many relation in a
 	* single `include(...)`. Each branch is either another refined
 	* collection (mapped to a row array on the parent) or a scalar
@@ -3633,7 +3615,7 @@ var Collection = class Collection {
 	* ).all();
 	* // each user row: {
 	* //   ...user,
-	* //   posts: { recent: Post[]; total: bigint; averageViews: string | null };
+	* //   posts: { recent: Post[]; total: number; averageViews: number | null };
 	* // }
 	* ```
 	*/
@@ -3681,7 +3663,7 @@ var Collection = class Collection {
 	*/
 	cursor(cursorValues) {
 		const mappedCursor = mapCursorValuesToColumns(this.contract, this.namespaceId, this.modelName, cursorValues);
-		if (Object.keys(mappedCursor).length === 0) return this;
+		if (Object.keys(mappedCursor).length === 0) return blindCast(this);
 		return this.#clone({ cursor: mappedCursor });
 	}
 	/**
@@ -3805,7 +3787,7 @@ var Collection = class Collection {
 	*     averageViews: agg.avg('views'),
 	*     maxViews: agg.max('views'),
 	*   }));
-	* // { total: 42n, averageViews: '17.3000000000000000', maxViews: 9001 }
+	* // { total: 42, averageViews: 17.3, maxViews: 9001 }
 	* ```
 	*
 	* Accepts an optional `configure` callback that receives a
@@ -3813,7 +3795,7 @@ var Collection = class Collection {
 	* Annotations are merged into the compiled plan's `meta.annotations`.
 	*/
 	async aggregate(fn, configure) {
-		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.namespaceId, this.modelName));
+		const aggregateSpec = fn(createAggregateBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.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",
@@ -3828,7 +3810,7 @@ var Collection = class Collection {
 		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state.filters, aggregateSpec), annotationsMap);
 		const row = (await executeQueryPlan(this.ctx.runtime, compiled).toArray())[0] ?? {};
 		const result = {};
-		for (const [alias, selector] of entries) result[alias] = row[alias] ?? emptyAggregateResult(selector.fn);
+		for (const [alias, selector] of entries) result[alias] = row[alias] ?? this.#emptyAggregateValue(selector);
 		return blindCast(result);
 	}
 	async create(data, configure) {
@@ -4506,6 +4488,23 @@ var Collection = class Collection {
 			namespaceId: this.namespaceId
 		}))[0] ?? null;
 	}
+	/**
+	* The value an aggregate alias reads as when the result set has no row to
+	* read at all. Resolution mirrors planning — the same registry, operation,
+	* and column — so the answer derives from the operation's declared row
+	* rather than its name.
+	*/
+	#emptyAggregateValue(selector) {
+		const resolved = resolveAggregate({
+			aggregates: this.ctx.context.aggregateDescriptors,
+			contract: this.contract,
+			namespaceId: this.namespaceId,
+			tableName: this.tableName,
+			fn: selector.fn,
+			column: selector.column
+		});
+		return emptyAggregateResult(resolved, this.ctx.context.contractCodecs.forCodecRef(resolved.codec));
+	}
 	#assertIncludeRefinementMode(action) {
 		if (this.includeRefinementMode) return;
 		throw ormError("ORM.INCLUDE_INVALID", `${action} is only available inside include() refinement callbacks`, { meta: { action } });
@@ -4544,7 +4543,7 @@ var Collection = class Collection {
 		}));
 	}
 	#createCollection(modelName, options) {
-		return blindCast(new ((this.registry.get(modelName)) ?? (blindCast(Collection)))(this.ctx, modelName, {
+		return blindCast(new ((this.registry.get(modelName)) ?? (blindCast(CollectionImpl)))(this.ctx, modelName, {
 			tableName: options.tableName,
 			namespaceId: options.namespaceId,
 			state: options.state,
@@ -4602,8 +4601,55 @@ var Collection = class Collection {
 		return meta.annotations.size === 0 ? void 0 : meta.annotations;
 	}
 };
+const collectionInstanceMemberNames = [
+	"ctx",
+	"contract",
+	"modelName",
+	"tableName",
+	"namespaceId",
+	"state",
+	"registry",
+	"includeRefinementMode"
+];
+/**
+* Every member name the collection surface owns: the prototype's methods plus
+* the declared instance fields. A contributed aggregate operation may not
+* take one of these names — reducers install into the same flat namespace —
+* so ORM composition rejects any operation this set contains.
+*/
+function reservedCollectionMemberNames() {
+	return /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(CollectionImpl.prototype), ...collectionInstanceMemberNames]);
+}
+const Collection = blindCast(CollectionImpl);
+/**
+* The class behind {@link Collection}, for package-internal prototype-chain
+* checks (`instanceof`) and default construction. The public constructor
+* surface carries a single construct signature returning the intersection,
+* which heritage clauses require; the raw class keeps the `Function` shape
+* those checks need.
+*/
+const CollectionBase = CollectionImpl;
+/**
+* Reject a contributed aggregate operation whose name a collection member
+* already owns. Aggregate operations surface as reducer methods on the
+* collection, in one flat namespace with the builder members, so a same-named
+* operation would shadow the member it collides with — a client-surface
+* concern, enforced here where that surface is assembled.
+*/
+function assertAggregateOperationsNotReserved(registry) {
+	const reserved = reservedCollectionMemberNames();
+	for (const operation of aggregateOperationNames(registry)) {
+		if (!reserved.has(operation)) continue;
+		throw ormError("ORM.AGGREGATE_OPERATION_RESERVED", `Aggregate operation '${operation}' is reserved: the name is a collection builder member.`, {
+			why: "Aggregate operations surface as reducer methods on the collection, in one namespace with the query-builder members; a same-named operation would shadow the member it collides with.",
+			fix: "Rename the contributed aggregate operation.",
+			meta: { operation }
+		});
+	}
+}
 function orm(options) {
 	const { runtime, collections, context } = options;
+	assertAggregateOperationsNotReserved(context.aggregateDescriptors);
 	const contract = context.contract;
 	const ctx = {
 		runtime,
@@ -4611,7 +4657,7 @@ function orm(options) {
 	};
 	const collectionRegistry = createCollectionRegistry(contract, collections);
 	function buildCollection(namespaceId, modelName, tableName) {
-		return new (blindCast(collectionRegistry.get(modelName) ?? Collection))(ctx, modelName, {
+		return new (blindCast(collectionRegistry.get(modelName) ?? CollectionBase))(ctx, modelName, {
 			registry: collectionRegistry,
 			namespaceId,
 			...tableName !== void 0 ? { tableName } : {}
@@ -4665,7 +4711,7 @@ function isCollectionClass(value) {
 	if (typeof value !== "function") return false;
 	const candidate = value;
 	if (!candidate.prototype || typeof candidate.prototype !== "object") return false;
-	return candidate.prototype instanceof Collection;
+	return candidate.prototype instanceof CollectionBase;
 }
 //#endregion
 export { Collection, GroupedCollection, all, and, createModelAccessor, emptyState, not, or, orm };