@prisma-next/sql-orm-client 0.5.0-dev.8 → 0.5.0-dev.85

package/dist/index.mjs

@@ -1,7 +1,6 @@
-import { AsyncIterableResult } from "@prisma-next/runtime-executor";
-import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, EqColJoinOn, ExistsExpr, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst, isWhereExpr } from "@prisma-next/sql-relational-core/ast";
+import { AsyncIterableResult } from "@prisma-next/framework-components/runtime";
+import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, EqColJoinOn, ExistsExpr, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst, collectOrderedParamRefs, isWhereExpr } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
-
 //#region src/collection-contract.ts
 function modelsOf(contract) {
 	return contract.models;
@@ -177,6 +176,13 @@ function resolveModelTableName(contract, modelName) {
 function resolvePrimaryKeyColumn(contract, tableName) {
 	return contract.storage.tables[tableName]?.primaryKey?.columns[0] ?? "id";
 }
+function resolveRowIdentityColumns(contract, tableName) {
+	const table = contract.storage.tables[tableName];
+	if (!table) return [];
+	if (table.primaryKey && table.primaryKey.columns.length > 0) return table.primaryKey.columns;
+	for (const unique of table.uniques) if (unique.columns.length > 0) return unique.columns;
+	return [];
+}
 function assertReturningCapability(contract, action) {
 	if (hasContractCapability(contract, "returning")) return;
 	throw new Error(`${action} requires contract capability "returning"`);
@@ -198,7 +204,6 @@ function capabilityEnabled(value) {
 function isToOneCardinality(cardinality) {
 	return cardinality === "1:1" || cardinality === "N:1";
 }
-
 //#endregion
 //#region src/aggregate-builder.ts
 function createAggregateBuilder(contract, modelName) {
@@ -238,7 +243,6 @@ function createFieldAggregateSelector(fieldToColumn, field, fn) {
 		column: fieldToColumn[fieldName] ?? fieldName
 	};
 }
-
 //#endregion
 //#region src/collection-aggregate-result.ts
 function normalizeAggregateResult(aggregateSpec, row) {
@@ -270,7 +274,6 @@ function normalizeAggregateResult(aggregateSpec, row) {
 	}
 	return result;
 }
-
 //#endregion
 //#region src/collection-column-mapping.ts
 function mapFieldsToColumns(contract, modelName, fieldNames) {
@@ -287,7 +290,6 @@ function mapCursorValuesToColumns(contract, modelName, cursorValues) {
 	}
 	return mappedCursor;
 }
-
 //#endregion
 //#region src/collection-runtime.ts
 function augmentSelectionForJoinColumns(selectedFields, requiredColumns) {
@@ -348,12 +350,12 @@ function mapPolymorphicRow(contract, baseModelName, polyInfo, row, variantName)
 	const variant = variantName ? polyInfo.variants.get(variantName) : polyInfo.variantsByValue.get(row[polyInfo.discriminatorColumn]);
 	if (!variant) {
 		const baseMap = getCompleteColumnToFieldMap(contract, baseModelName);
-		const mapped$1 = {};
+		const mapped = {};
 		for (const [col, val] of Object.entries(row)) {
 			const field = baseMap[col];
-			if (field !== void 0) mapped$1[field] = val;
+			if (field !== void 0) mapped[field] = val;
 		}
-		return mapped$1;
+		return mapped;
 	}
 	const mtiTable = variant.strategy === "mti" ? variant.table : void 0;
 	const mergedMap = getMergedColumnToFieldMap(contract, baseModelName, variant.modelName, mtiTable);
@@ -389,95 +391,78 @@ async function acquireRuntimeScope(runtime) {
 	};
 	return { scope: connection };
 }
-
 //#endregion
 //#region src/execute-query-plan.ts
 function executeQueryPlan(scope, plan) {
 	return scope.execute(plan);
 }
-
 //#endregion
 //#region src/include-strategy.ts
+/**
+* Choose the SQL emission strategy for nested includes based on the
+* contract's declared capabilities.
+*
+* - `'lateral'`: outer SELECT with one LATERAL JOIN per relation,
+*   aggregating to JSON. Requires both `lateral` and `jsonAgg`.
+*   Postgres has both.
+* - `'correlated'`: outer SELECT with one correlated subquery per
+*   relation, aggregating to JSON. Requires `jsonAgg` only.
+*   SQLite has `jsonAgg` (via `json_group_array`) but no LATERAL.
+* - `'multiQuery'`: fallback. One SELECT per relation, stitched
+*   together in JS via `WHERE pk IN (parent-pk-values)`. Always
+*   correct; just N+1 round-trips.
+*
+* The capability flags are looked up under the contract's
+* `targetFamily` and `target` namespaces — the two layers the contract
+* emitter actually populates. Cross-namespace ("`postgres.lateral`
+* found while running SQLite") false positives are impossible because
+* we only inspect the running target's namespaces.
+*/
 function selectIncludeStrategy(contract) {
-	const capabilities = contract.capabilities;
-	const hasLateral = hasCapability(capabilities?.["lateral"]);
-	const hasJsonAgg = hasCapability(capabilities?.["jsonAgg"]);
+	const hasLateral = capabilityFlag(contract, "lateral");
+	const hasJsonAgg = capabilityFlag(contract, "jsonAgg");
 	if (hasLateral && hasJsonAgg) return "lateral";
 	if (hasJsonAgg) return "correlated";
 	return "multiQuery";
 }
-function hasCapability(value) {
-	if (value === true) return true;
-	if (typeof value !== "object" || value === null) return false;
-	const flags = value;
-	return Object.values(flags).some((flag) => flag === true);
+/**
+* Read a capability flag from the contract's target/family namespaces.
+*
+* The contract emitter populates `capabilities[targetFamily]` (universal
+* SQL flags like `jsonAgg`, `returning`) and `capabilities[target]`
+* (target-specific flags like `lateral` on Postgres). Either may
+* declare a given flag; the family namespace declares the floor and the
+* target namespace can extend on top.
+*/
+function capabilityFlag(contract, flag) {
+	return contract.capabilities[contract.targetFamily]?.[flag] === true || contract.capabilities[contract.target]?.[flag] === true;
 }
-
 //#endregion
 //#region src/query-plan-meta.ts
-function resolveProjectionCodecs(contract, ast) {
-	const codecs = {};
-	if (ast.kind === "select") {
-		for (const item of ast.projection) if (item.expr.kind === "column-ref") {
-			const col = contract.storage.tables[item.expr.table]?.columns[item.expr.column];
-			if (col?.codecId) codecs[item.alias] = col.codecId;
-		}
-	} else if (ast.returning) {
-		const tableName = ast.table.name;
-		const table = contract.storage.tables[tableName];
-		if (!table) return void 0;
-		for (const colRef of ast.returning) {
-			const col = table.columns[colRef.column];
-			if (col?.codecId) codecs[colRef.column] = col.codecId;
-		}
-	}
-	return Object.keys(codecs).length > 0 ? codecs : void 0;
-}
 function deriveParamsFromAst(ast) {
-	const collectedParams = [...new Set(ast.collectParamRefs())];
-	return {
-		params: collectedParams.map((p) => p.value),
-		paramDescriptors: collectedParams.map((p) => ({
-			...ifDefined("name", p.name),
-			...ifDefined("codecId", p.codecId),
-			source: "dsl"
-		}))
-	};
+	return { params: collectOrderedParamRefs(ast).map((p) => p.value) };
 }
 function resolveTableColumns(contract, tableName) {
 	const table = contract.storage.tables[tableName];
 	if (!table) throw new Error(`Unknown table "${tableName}" in SQL ORM query planner`);
 	return Object.keys(table.columns);
 }
-function buildOrmPlanMeta(contract, paramDescriptors = []) {
+function buildOrmPlanMeta(contract) {
 	return {
 		target: contract.target,
 		targetFamily: contract.targetFamily,
 		storageHash: contract.storage.storageHash,
 		...contract.profileHash !== void 0 ? { profileHash: contract.profileHash } : {},
-		lane: "orm-client",
-		paramDescriptors: [...paramDescriptors]
+		lane: "orm-client"
 	};
 }
-function buildOrmQueryPlan(contract, ast, params, paramDescriptors = []) {
-	const projectionTypes = resolveProjectionCodecs(contract, ast);
-	const codecAnnotations = projectionTypes ? { codecs: Object.freeze({ ...projectionTypes }) } : void 0;
-	const limitAnnotation = ast.kind === "select" && ast.limit !== void 0 ? { limit: ast.limit } : void 0;
-	const annotations = codecAnnotations || limitAnnotation ? Object.freeze({
-		...codecAnnotations,
-		...limitAnnotation
-	}) : void 0;
+function buildOrmQueryPlan(contract, ast, params) {
 	return Object.freeze({
 		ast,
 		params: [...params],
-		meta: {
-			...buildOrmPlanMeta(contract, paramDescriptors),
-			...ifDefined("projectionTypes", projectionTypes),
-			...ifDefined("annotations", annotations)
-		}
+		meta: buildOrmPlanMeta(contract)
 	});
 }
-
 //#endregion
 //#region src/where-utils.ts
 function combineWhereExprs(filters) {
@@ -485,13 +470,23 @@ function combineWhereExprs(filters) {
 	if (filters.length === 1) return filters[0];
 	return AndExpr.of(filters);
 }
-
 //#endregion
 //#region src/query-plan-aggregate.ts
-function toAggregateExpr(tableName, selector) {
-	if (selector.fn === "count") return AggregateExpr.count();
+function toAggregateProjection(contract, tableName, selector) {
+	if (selector.fn === "count") return {
+		expr: AggregateExpr.count(),
+		codecId: void 0
+	};
 	if (!selector.column) throw new Error(`Aggregate selector "${selector.fn}" requires a field`);
-	return new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+	const expr = new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+	if (selector.fn === "min" || selector.fn === "max") return {
+		expr,
+		codecId: contract.storage.tables[tableName]?.columns[selector.column]?.codecId
+	};
+	return {
+		expr,
+		codecId: void 0
+	};
 }
 function validateGroupedComparable(value) {
 	switch (value.kind) {
@@ -528,53 +523,61 @@ function validateGroupedHavingExpr(expr) {
 			throw new Error("ParamRef is not supported in grouped having expressions");
 		},
 		list: rejectHavingExpr,
-		and(expr$1) {
-			return AndExpr.of(expr$1.exprs.map((child) => validateGroupedHavingExpr(child)));
+		and(expr) {
+			return AndExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
 		},
-		or(expr$1) {
-			return OrExpr.of(expr$1.exprs.map((child) => validateGroupedHavingExpr(child)));
+		or(expr) {
+			return OrExpr.of(expr.exprs.map((child) => validateGroupedHavingExpr(child)));
 		},
-		exists(expr$1) {
-			throw new Error(`Unsupported grouped having expression kind "${expr$1.kind}"`);
+		exists(expr) {
+			throw new Error(`Unsupported grouped having expression kind "${expr.kind}"`);
 		},
-		nullCheck(expr$1) {
-			return new NullCheckExpr(validateGroupedMetricExpr(expr$1.expr), expr$1.isNull);
+		nullCheck(expr) {
+			return new NullCheckExpr(validateGroupedMetricExpr(expr.expr), expr.isNull);
 		},
-		not(expr$1) {
-			return new NotExpr(validateGroupedHavingExpr(expr$1.expr));
+		not(expr) {
+			return new NotExpr(validateGroupedHavingExpr(expr.expr));
 		},
-		binary(expr$1) {
-			return new BinaryExpr(expr$1.op, validateGroupedMetricExpr(expr$1.left), validateGroupedComparable(expr$1.right));
+		binary(expr) {
+			return new BinaryExpr(expr.op, validateGroupedMetricExpr(expr.left), validateGroupedComparable(expr.right));
 		}
 	});
 }
 function compileAggregate(contract, tableName, filters, aggregateSpec) {
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw new Error("aggregate() requires at least one aggregation selector");
-	const projection = entries.map(([alias, selector]) => ProjectionItem.of(alias, toAggregateExpr(tableName, selector)));
+	const projection = entries.map(([alias, selector]) => {
+		const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+		return ProjectionItem.of(alias, expr, codecId);
+	});
 	let ast = SelectAst.from(TableSource.named(tableName)).withProjection(projection);
 	const where = combineWhereExprs(filters);
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileGroupedAggregate(contract, tableName, filters, groupByColumns, aggregateSpec, havingExpr) {
 	if (groupByColumns.length === 0) throw new Error("groupBy() requires at least one field");
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw new Error("groupBy().aggregate() requires at least one aggregation selector");
-	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))), ...entries.map(([alias, selector]) => ProjectionItem.of(alias, toAggregateExpr(tableName, selector)))];
+	const table = contract.storage.tables[tableName];
+	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId)), ...entries.map(([alias, selector]) => {
+		const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+		return ProjectionItem.of(alias, expr, codecId);
+	})];
 	let ast = SelectAst.from(TableSource.named(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, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
-
 //#endregion
 //#region src/query-plan-mutations.ts
 function buildReturningColumns(contract, tableName, returningColumns) {
-	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, tableName)).map((column) => ColumnRef.of(tableName, column));
+	const columns = returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, tableName);
+	const table = contract.storage.tables[tableName];
+	return columns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId));
 }
 function toParamAssignments(contract, tableName, values) {
 	const assignments = {};
@@ -585,7 +588,11 @@ function toParamAssignments(contract, tableName, values) {
 		if (!codecId) throw new Error(`Unknown column "${column}" in table "${tableName}"`);
 		assignments[column] = ParamRef.of(value, {
 			name: column,
-			codecId
+			codecId,
+			refs: {
+				table: tableName,
+				column
+			}
 		});
 	}
 	return { assignments };
@@ -610,7 +617,11 @@ function normalizeInsertRows(contract, tableName, rows) {
 				if (!codecId) throw new Error(`Unknown column "${column}" in table "${tableName}"`);
 				normalizedRow[column] = ParamRef.of(row[column], {
 					name: column,
-					codecId
+					codecId,
+					refs: {
+						table: tableName,
+						column
+					}
 				});
 				continue;
 			}
@@ -622,14 +633,14 @@ function normalizeInsertRows(contract, tableName, rows) {
 function compileInsertReturning(contract, tableName, rows, returningColumns) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, tableName, rows);
 	const ast = InsertAst.into(TableSource.named(tableName)).withRows(normalizedRows).withReturning(buildReturningColumns(contract, tableName, returningColumns));
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileInsertCount(contract, tableName, rows) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, tableName, rows);
 	const ast = InsertAst.into(TableSource.named(tableName)).withRows(normalizedRows);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function stripUndefinedValues(row) {
 	const result = {};
@@ -665,40 +676,39 @@ function compileUpsertReturning(contract, tableName, createValues, updateValues,
 	const updateAssignments = Object.keys(updateValues).length > 0 ? toParamAssignments(contract, tableName, updateValues) : void 0;
 	const onConflict = updateAssignments ? InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doUpdateSet(updateAssignments.assignments) : InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doNothing();
 	const ast = InsertAst.into(TableSource.named(tableName)).withValues(createAssignments.assignments).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, tableName, returningColumns));
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileUpdateReturning(contract, tableName, setValues, filters, returningColumns) {
 	const where = combineWhereExprs(filters);
 	const { assignments } = toParamAssignments(contract, tableName, setValues);
 	let ast = UpdateAst.table(TableSource.named(tableName)).withSet(assignments).withReturning(buildReturningColumns(contract, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileUpdateCount(contract, tableName, setValues, filters) {
 	const where = combineWhereExprs(filters);
 	const { assignments } = toParamAssignments(contract, tableName, setValues);
 	let ast = UpdateAst.table(TableSource.named(tableName)).withSet(assignments);
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileDeleteReturning(contract, tableName, filters, returningColumns) {
 	const where = combineWhereExprs(filters);
 	let ast = DeleteAst.from(TableSource.named(tableName)).withReturning(buildReturningColumns(contract, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileDeleteCount(contract, tableName, filters) {
 	const where = combineWhereExprs(filters);
 	let ast = DeleteAst.from(TableSource.named(tableName));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
-
 //#endregion
 //#region src/where-binding.ts
 function bindWhereExpr(contract, expr) {
@@ -706,55 +716,55 @@ function bindWhereExpr(contract, expr) {
 }
 function bindWhereExprNode(contract, expr) {
 	return expr.accept({
-		columnRef(expr$1) {
-			return bindExpression(contract, expr$1);
+		columnRef(expr) {
+			return bindExpression(contract, expr);
 		},
-		identifierRef(expr$1) {
-			return expr$1;
+		identifierRef(expr) {
+			return expr;
 		},
-		subquery(expr$1) {
-			return bindExpression(contract, expr$1);
+		subquery(expr) {
+			return bindExpression(contract, expr);
 		},
-		operation(expr$1) {
-			return bindExpression(contract, expr$1);
+		operation(expr) {
+			return bindExpression(contract, expr);
 		},
-		aggregate(expr$1) {
-			return bindExpression(contract, expr$1);
+		aggregate(expr) {
+			return bindExpression(contract, expr);
 		},
-		jsonObject(expr$1) {
-			return bindExpression(contract, expr$1);
+		jsonObject(expr) {
+			return bindExpression(contract, expr);
 		},
-		jsonArrayAgg(expr$1) {
-			return bindExpression(contract, expr$1);
+		jsonArrayAgg(expr) {
+			return bindExpression(contract, expr);
 		},
-		literal(expr$1) {
-			return expr$1;
+		literal(expr) {
+			return expr;
 		},
-		param(expr$1) {
-			return expr$1;
+		param(expr) {
+			return expr;
 		},
-		list(expr$1) {
-			return bindExpression(contract, expr$1);
+		list(expr) {
+			return bindExpression(contract, expr);
 		},
-		binary(expr$1) {
-			const left = bindExpression(contract, expr$1.left);
+		binary(expr) {
+			const left = bindExpression(contract, expr.left);
 			const bindingColumn = left.kind === "column-ref" ? left : void 0;
-			return new BinaryExpr(expr$1.op, left, bindComparable(contract, expr$1.right, bindingColumn));
+			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn));
 		},
-		and(expr$1) {
-			return AndExpr.of(expr$1.exprs.map((part) => bindWhereExprNode(contract, part)));
+		and(expr) {
+			return AndExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part)));
 		},
-		or(expr$1) {
-			return OrExpr.of(expr$1.exprs.map((part) => bindWhereExprNode(contract, part)));
+		or(expr) {
+			return OrExpr.of(expr.exprs.map((part) => bindWhereExprNode(contract, part)));
 		},
-		exists(expr$1) {
-			return expr$1.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr$1.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr$1.subquery));
+		exists(expr) {
+			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
 		},
-		nullCheck(expr$1) {
-			return expr$1.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr$1.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr$1.expr));
+		nullCheck(expr) {
+			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
 		},
-		not(expr$1) {
-			return new NotExpr(bindWhereExprNode(contract, expr$1.expr));
+		not(expr) {
+			return new NotExpr(bindWhereExprNode(contract, expr.expr));
 		}
 	});
 }
@@ -767,7 +777,13 @@ function bindComparable(contract, comparable, bindingColumn) {
 function createParamRef(contract, columnRef, value) {
 	const codecId = contract.storage.tables[columnRef.table]?.columns[columnRef.column]?.codecId;
 	if (!codecId) throw new Error(`Unknown column "${columnRef.column}" in table "${columnRef.table}"`);
-	return ParamRef.of(value, { codecId });
+	return ParamRef.of(value, {
+		codecId,
+		refs: {
+			table: columnRef.table,
+			column: columnRef.column
+		}
+	});
 }
 function createExpressionBinder(contract) {
 	return { select: (ast) => bindSelectAst(contract, ast) };
@@ -796,7 +812,7 @@ function bindSelectAst(contract, ast) {
 	return new SelectAst({
 		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: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codecId, projection.refs)),
 		where: ast.where ? bindWhereExprNode(contract, ast.where) : void 0,
 		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
 		distinct: ast.distinct,
@@ -808,11 +824,12 @@ function bindSelectAst(contract, ast) {
 		selectAllIntent: ast.selectAllIntent
 	});
 }
-
 //#endregion
 //#region src/query-plan-select.ts
 function buildProjection(contract, tableName, selectedFields, tableRef = tableName) {
-	return (selectedFields && selectedFields.length > 0 ? [...selectedFields] : resolveTableColumns(contract, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column)));
+	const columns = selectedFields && selectedFields.length > 0 ? [...selectedFields] : resolveTableColumns(contract, tableName);
+	const table = contract.storage.tables[tableName];
+	return columns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column), table?.columns[column]?.codecId));
 }
 function createBoundaryExpr(tableName, entry) {
 	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
@@ -946,10 +963,11 @@ function buildMtiJoins(contract, polyInfo, variantName) {
 		const join = joinType === "inner" ? JoinAst.inner(TableSource.named(variant.table), joinOn) : JoinAst.left(TableSource.named(variant.table), joinOn);
 		joins.push(join);
 		const variantColumns = resolveTableColumns(contract, variant.table);
+		const variantTable = contract.storage.tables[variant.table];
 		for (const col of variantColumns) {
 			if (col === pkColumn) continue;
 			const alias = `${variant.table}__${col}`;
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col)));
+			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), variantTable?.columns[col]?.codecId));
 		}
 	}
 	return {
@@ -967,8 +985,8 @@ function compileSelect(contract, tableName, state, modelName) {
 		joins: mtiArtifacts.joins,
 		includeProjection: mtiArtifacts.projection
 	} : void 0);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileRelationSelect(contract, relatedTableName, targetColumn, parentPks, nestedState) {
 	const inFilter = BinaryExpr.in(ColumnRef.of(relatedTableName, targetColumn), ListExpression.fromValues(parentPks));
@@ -993,9 +1011,9 @@ function compileSelectWithIncludeStrategy(contract, tableName, state, strategy,
 	}
 	for (const include of state.includes) {
 		if (strategy === "lateral") {
-			const artifact$1 = buildLateralIncludeArtifacts(contract, tableName, include);
-			includeJoins.push(artifact$1.join);
-			includeProjection.push(artifact$1.projection);
+			const artifact = buildLateralIncludeArtifacts(contract, tableName, include);
+			includeJoins.push(artifact.join);
+			includeProjection.push(artifact.projection);
 			continue;
 		}
 		const artifact = buildCorrelatedIncludeProjection(contract, tableName, include);
@@ -1009,10 +1027,9 @@ function compileSelectWithIncludeStrategy(contract, tableName, state, strategy,
 		includeProjection,
 		...topLevelWhere ? { where: topLevelWhere } : {}
 	});
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
-
 //#endregion
 //#region src/collection-dispatch.ts
 function dispatchCollectionRows(options) {
@@ -1282,7 +1299,6 @@ function coerceNumericValue(value) {
 	}
 	return null;
 }
-
 //#endregion
 //#region src/collection-mutation-dispatch.ts
 function dispatchMutationRows(options) {
@@ -1364,7 +1380,6 @@ async function executeMutationReturningSingleRow(options) {
 		if (release) await release();
 	}
 }
-
 //#endregion
 //#region src/filters.ts
 function and(...exprs) {
@@ -1401,9 +1416,8 @@ function shorthandToWhereExpr(context, modelName, filters) {
 function assertFieldHasEqualityTrait(context, modelName, fieldName) {
 	const fieldType = modelOf(context.contract, modelName)?.fields?.[fieldName]?.type;
 	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
-	if (!(codecId ? context.codecs.traitsOf(codecId) : []).includes("equality")) throw new Error(`Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`);
+	if (!(codecId ? context.codecDescriptors.descriptorFor(codecId)?.traits ?? [] : []).includes("equality")) throw new Error(`Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`);
 }
-
 //#endregion
 //#region src/grouped-collection.ts
 var GroupedCollection = class GroupedCollection {
@@ -1503,7 +1517,6 @@ function coerceAggregateValue(fn, value) {
 	}
 	return value;
 }
-
 //#endregion
 //#region src/include-descriptors.ts
 const aggregateFns = new Set([
@@ -1548,7 +1561,6 @@ function isCollectionState(value) {
 	const candidate = value;
 	return Array.isArray(candidate.filters) && Array.isArray(candidate.includes);
 }
-
 //#endregion
 //#region src/types.ts
 function emptyState() {
@@ -1565,17 +1577,40 @@ function emptyState() {
 		variantName: void 0
 	};
 }
-function param(codecId, value) {
-	return codecId ? ParamRef.of(value, { codecId }) : ParamRef.of(value);
+/**
+* Resolve the unique column ref carried by `left` so its surrounding `ParamRef` can dispatch through `forColumn`. The previous implementation only matched bare `column-ref` expressions, which lost refs the moment the expression got wrapped (`upper(f.id)`, `BinaryExpr`, function-call expressions, etc.) — and column-aware dispatch (AC-5) silently degraded for any predicate that touched a computed column.
+*
+* Walking via `collectColumnRefs()` and accepting only a single unambiguous ref gives `eq(upper(f.id), value)` and friends correct dispatch without inventing refs for ambiguous shapes (e.g. `eq(concat(f.firstName, f.lastName), value)` returns `undefined` and falls through to the codec-id path, which is correct for non-parameterized comparisons).
+*/
+function refsFromLeft(left) {
+	if (left.kind === "column-ref") return {
+		table: left.table,
+		column: left.column
+	};
+	const columnRefs = left.collectColumnRefs();
+	if (columnRefs.length !== 1) return void 0;
+	const single = columnRefs[0];
+	if (!single) return void 0;
+	return {
+		table: single.table,
+		column: single.column
+	};
+}
+function param(codecId, value, refs) {
+	if (codecId === void 0 && refs === void 0) return ParamRef.of(value);
+	return ParamRef.of(value, {
+		...ifDefined("codecId", codecId),
+		...ifDefined("refs", refs)
+	});
 }
-function paramList(codecId, values) {
-	return ListExpression.of(values.map((value) => param(codecId, value)));
+function paramList(codecId, values, refs) {
+	return ListExpression.of(values.map((value) => param(codecId, value, refs)));
 }
 function scalarComparisonMethod(op) {
-	return ((left, codecId) => (value) => new BinaryExpr(op, left, param(codecId, value)));
+	return ((left, codecId) => (value) => new BinaryExpr(op, left, param(codecId, value, refsFromLeft(left))));
 }
 function listComparisonMethod(op) {
-	return ((left, codecId) => (values) => new BinaryExpr(op, left, paramList(codecId, values)));
+	return ((left, codecId) => (values) => new BinaryExpr(op, left, paramList(codecId, values, refsFromLeft(left))));
 }
 /**
 * Declares trait requirements and runtime factory for each comparison method.
@@ -1637,7 +1672,6 @@ const COMPARISON_METHODS_META = {
 		create: (left) => () => NullCheckExpr.isNotNull(left)
 	}
 };
-
 //#endregion
 //#region src/model-accessor.ts
 function createModelAccessor(context, modelName) {
@@ -1655,12 +1689,13 @@ function createModelAccessor(context, modelName) {
 		existing.push(op);
 	}
 	for (const [name, entry] of Object.entries(context.queryOperations.entries())) {
-		const self = entry.args[0];
 		const op = [name, entry];
-		if (self?.codecId) registerOp(self.codecId, op);
-		else if (self?.traits) for (const codec of context.codecs.values()) {
-			const codecTraits = codec.traits ?? [];
-			if (self.traits.every((t) => codecTraits.includes(t))) registerOp(codec.id, op);
+		const self = entry.self;
+		if (!self) continue;
+		if (self.codecId !== void 0) registerOp(self.codecId, op);
+		else if (self.traits !== void 0) for (const descriptor of context.codecDescriptors.values()) {
+			const descriptorTraits = descriptor.traits;
+			if (self.traits.every((t) => descriptorTraits.includes(t))) registerOp(descriptor.codecId, op);
 		}
 	}
 	return new Proxy({}, { get(_target, prop) {
@@ -1668,48 +1703,51 @@ function createModelAccessor(context, modelName) {
 		const relation = modelRelations[prop];
 		if (relation) return createRelationFilterAccessor(context, modelName, tableName, relation);
 		const columnName = fieldToColumn[prop] ?? prop;
-		const traits = resolveFieldTraits(contract, modelName, prop, context);
-		const codecId = resolveFieldCodecId(contract, tableName, columnName);
-		return createScalarFieldAccessor(tableName, columnName, codecId, traits, codecId ? opsByCodecId.get(codecId) ?? [] : [], context);
+		const column = resolveColumn(contract, tableName, columnName);
+		if (!column) return;
+		const traits = context.codecDescriptors.descriptorFor(column.codecId)?.traits ?? [];
+		const operations = opsByCodecId.get(column.codecId) ?? [];
+		return createScalarFieldAccessor(tableName, columnName, column.codecId, column.nullable, traits, operations, context);
 	} });
 }
-function resolveFieldTraits(contract, modelName, fieldName, context) {
-	const fieldType = modelOf(contract, modelName)?.fields?.[fieldName]?.type;
-	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
-	if (!codecId) return [];
-	return context.codecs.traitsOf(codecId);
-}
-function resolveFieldCodecId(contract, tableName, columnName) {
-	return (contract.storage.tables?.[tableName])?.columns?.[columnName]?.codecId;
+function resolveColumn(contract, tableName, columnName) {
+	const column = contract.storage.tables?.[tableName]?.columns?.[columnName];
+	if (!column) return void 0;
+	return {
+		codecId: column.codecId,
+		nullable: column.nullable
+	};
 }
-function createScalarFieldAccessor(tableName, columnName, codecId, traits, operations, context) {
+function createScalarFieldAccessor(tableName, columnName, codecId, nullable, traits, operations, context) {
 	const column = ColumnRef.of(tableName, columnName);
-	const methods = {};
+	const comparisonEntries = [];
 	for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
 		if (meta.traits.some((t) => !traits.includes(t))) continue;
-		methods[name] = meta.create(column, codecId);
+		comparisonEntries.push([name, meta.create(column, codecId)]);
 	}
-	for (const [name, entry] of operations) methods[name] = createExtensionMethodFactory(column, name, entry, context);
-	return methods;
+	const accessor = {
+		returnType: {
+			codecId,
+			nullable
+		},
+		buildAst: () => column,
+		...Object.fromEntries(comparisonEntries)
+	};
+	for (const [name, entry] of operations) accessor[name] = createExtensionMethodFactory(accessor, entry, context);
+	return accessor;
 }
-function createExtensionMethodFactory(column, methodName, entry, context) {
-	const returnTraits = context.codecs.traitsOf(entry.returns.codecId);
-	const isPredicate = returnTraits.includes("boolean");
+function createExtensionMethodFactory(selfExpr, entry, context) {
 	return (...args) => {
-		const opExpr = new OperationExpr({
-			method: methodName,
-			self: column,
-			args: entry.args.slice(1).map((argSpec, i) => {
-				return ParamRef.of(args[i], argSpec.codecId ? { codecId: argSpec.codecId } : void 0);
-			}),
-			returns: entry.returns,
-			lowering: entry.lowering
-		});
-		if (isPredicate) return opExpr;
+		const impl = entry.impl;
+		const result = impl(selfExpr, ...args);
+		const returnCodecId = result.returnType.codecId;
+		const returnTraits = context.codecDescriptors.descriptorFor(returnCodecId)?.traits ?? [];
+		if (returnTraits.includes("boolean")) return result.buildAst();
+		const resultAst = result.buildAst();
 		const methods = {};
 		for (const [resultMethodName, meta] of Object.entries(COMPARISON_METHODS_META)) {
 			if (meta.traits.some((t) => !returnTraits.includes(t))) continue;
-			methods[resultMethodName] = meta.create(opExpr, entry.returns.codecId);
+			methods[resultMethodName] = meta.create(resultAst, returnCodecId);
 		}
 		return methods;
 	};
@@ -1756,7 +1794,7 @@ function toRelationWhereExpr(context, relatedModelName, predicate) {
 	for (const [fieldName, value] of Object.entries(predicate)) {
 		if (value === void 0) continue;
 		const fieldAccessor = accessor[fieldName];
-		if (!fieldAccessor) continue;
+		if (!fieldAccessor) throw new Error(`Shorthand filter on "${relatedModelName}.${fieldName}": field is not defined on the model`);
 		if (value === null) {
 			if (!fieldAccessor.isNull) throw new Error(`Shorthand filter on "${relatedModelName}.${fieldName}": isNull is unexpectedly missing — this is a bug in trait gating`);
 			exprs.push(fieldAccessor.isNull());
@@ -1791,7 +1829,6 @@ function firstTargetColumn(contract, relation) {
 	if (!firstField) return;
 	return resolveFieldToColumn(contract, relation.to, firstField);
 }
-
 //#endregion
 //#region src/relation-mutator.ts
 function createRelationMutator() {
@@ -1826,7 +1863,6 @@ function isRelationMutationDescriptor(value) {
 function isRelationMutationCallback(value) {
 	return typeof value === "function";
 }
-
 //#endregion
 //#region src/mutation-executor.ts
 function hasNestedMutationCallbacks(contract, modelName, data) {
@@ -1895,9 +1931,16 @@ async function updateFirstGraph(scope, context, modelName, filters, input) {
 	let parentRow = existingRow;
 	const mappedUpdateData = mapModelDataToStorageRow(contract, modelName, scalarData);
 	if (Object.keys(mappedUpdateData).length > 0) {
+		const tableName = resolveModelTableName(contract, modelName);
+		const appliedUpdateDefaults = context.applyMutationDefaults({
+			op: "update",
+			table: tableName,
+			values: mappedUpdateData
+		});
+		for (const def of appliedUpdateDefaults) mappedUpdateData[def.column] = def.value;
 		const pkWhere = shorthandToWhereExpr(context, modelName, buildPrimaryKeyFilterFromRow(contract, modelName, existingRow));
 		if (!pkWhere) throw new Error(`Failed to build primary key filter for model "${modelName}"`);
-		const updatedRaw = (await executeQueryPlan(scope, compileUpdateReturning(contract, resolveModelTableName(contract, modelName), mappedUpdateData, [pkWhere], void 0)).toArray())[0];
+		const updatedRaw = (await executeQueryPlan(scope, compileUpdateReturning(contract, tableName, mappedUpdateData, [pkWhere], void 0)).toArray())[0];
 		if (updatedRaw) parentRow = mapStorageRowToModelFields(contract, modelName, updatedRaw);
 	}
 	for (const relationMutation of childOwned) await applyChildOwnedMutation(scope, context, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
@@ -1990,9 +2033,9 @@ async function applyChildOwnedMutation(scope, context, parentModelName, parentRo
 		for (const criterion of mutation.criteria) {
 			const criterionWhere = shorthandToWhereExpr(context, relation.relatedModelName, criterion);
 			if (!criterionWhere) throw new Error(`connect() nested mutation for relation "${relation.relationName}" requires non-empty criterion`);
-			const setValues$1 = {};
-			for (const [childColumn, parentValue] of parentValues.entries()) setValues$1[childColumn] = parentValue;
-			await executeUpdateCount(scope, contract, relation.relatedTableName, setValues$1, [criterionWhere]);
+			const setValues = {};
+			for (const [childColumn, parentValue] of parentValues.entries()) setValues[childColumn] = parentValue;
+			await executeUpdateCount(scope, contract, relation.relatedTableName, setValues, [criterionWhere]);
 		}
 		return;
 	}
@@ -2092,7 +2135,6 @@ function getRelationDefinitions(contract, modelName) {
 function toFieldName(contract, modelName, columnName) {
 	return getColumnToFieldMap(contract, modelName)[columnName] ?? columnName;
 }
-
 //#endregion
 //#region src/where-interop.ts
 function normalizeWhereArg(arg, options) {
@@ -2105,19 +2147,28 @@ function normalizeWhereArg(arg, options) {
 function isToWhereExpr(arg) {
 	return typeof arg === "object" && arg !== null && "toWhereExpr" in arg && !isWhereExpr(arg);
 }
-
 //#endregion
 //#region src/collection.ts
 function applyCreateDefaults(ctx, tableName, rows) {
+	const defaultValueCache = rows.length > 1 ? /* @__PURE__ */ new Map() : void 0;
 	for (const row of rows) {
 		const applied = ctx.context.applyMutationDefaults({
 			op: "create",
 			table: tableName,
-			values: row
+			values: row,
+			...defaultValueCache ? { defaultValueCache } : {}
 		});
 		for (const def of applied) row[def.column] = def.value;
 	}
 }
+function applyUpdateDefaults(ctx, tableName, values) {
+	const applied = ctx.context.applyMutationDefaults({
+		op: "update",
+		table: tableName,
+		values
+	});
+	for (const def of applied) values[def.column] = def.value;
+}
 function isToWhereExprInput(value) {
 	return typeof value === "object" && value !== null && "toWhereExpr" in value && typeof value.toWhereExpr === "function";
 }
@@ -2480,6 +2531,7 @@ var Collection = class Collection {
 		applyCreateDefaults(this.ctx, this.tableName, [createValues]);
 		const updateValues = mapModelDataToStorageRow(this.contract, this.modelName, input.update);
 		const hasUpdateValues = Object.keys(updateValues).length > 0;
+		if (hasUpdateValues) applyUpdateDefaults(this.ctx, this.tableName, updateValues);
 		const conflictColumns = resolveUpsertConflictColumns(this.contract, this.modelName, input.conflictOn);
 		if (conflictColumns.length === 0) throw new Error(`upsert() for model "${this.modelName}" requires conflict columns`);
 		const parentJoinColumns = this.state.includes.map((include) => include.localColumn);
@@ -2517,7 +2569,12 @@ var Collection = class Collection {
 			const pkCriterion = buildPrimaryKeyFilterFromRow(this.contract, this.modelName, updatedRow);
 			return this.#reloadMutationRowByPrimaryKey(pkCriterion);
 		}
-		return (await this.updateAll(data))[0] ?? null;
+		return withMutationScope(this.ctx.runtime, async (scope) => {
+			const scoped = this.#withRuntime(scope);
+			const identityWhere = await scoped.#findFirstMatchingRowIdentityWhere();
+			if (!identityWhere) return null;
+			return (await scoped.#clone({ filters: [identityWhere] }).updateAll(data))[0] ?? null;
+		});
 	}
 	updateAll(data) {
 		assertReturningCapability(this.contract, "updateAll()");
@@ -2526,6 +2583,7 @@ var Collection = class Collection {
 			const generator = async function* () {};
 			return new AsyncIterableResult(generator());
 		}
+		applyUpdateDefaults(this.ctx, this.tableName, mappedData);
 		const parentJoinColumns = this.state.includes.map((include) => include.localColumn);
 		const { selectedForQuery: selectedForUpdate, hiddenColumns } = augmentSelectionForJoinColumns(this.state.selectedFields, parentJoinColumns);
 		const compiled = compileUpdateReturning(this.contract, this.tableName, mappedData, this.state.filters, selectedForUpdate);
@@ -2542,6 +2600,7 @@ var Collection = class Collection {
 	async updateCount(data) {
 		const mappedData = mapModelDataToStorageRow(this.contract, this.modelName, data);
 		if (Object.keys(mappedData).length === 0) return 0;
+		applyUpdateDefaults(this.ctx, this.tableName, mappedData);
 		const primaryKeyColumn = resolvePrimaryKeyColumn(this.contract, this.tableName);
 		const countState = {
 			...emptyState(),
@@ -2556,10 +2615,18 @@ var Collection = class Collection {
 	}
 	async delete() {
 		assertReturningCapability(this.contract, "delete()");
-		return (await this.deleteAll().toArray())[0] ?? null;
+		return withMutationScope(this.ctx.runtime, async (scope) => {
+			const scoped = this.#withRuntime(scope);
+			const identityWhere = await scoped.#findFirstMatchingRowIdentityWhere();
+			if (!identityWhere) return null;
+			return (await scoped.#clone({ filters: [identityWhere] }).#executeDeleteReturning().toArray())[0] ?? null;
+		});
 	}
 	deleteAll() {
 		assertReturningCapability(this.contract, "deleteAll()");
+		return this.#executeDeleteReturning();
+	}
+	#executeDeleteReturning() {
 		const parentJoinColumns = this.state.includes.map((include) => include.localColumn);
 		const { selectedForQuery: selectedForDelete, hiddenColumns } = augmentSelectionForJoinColumns(this.state.selectedFields, parentJoinColumns);
 		const compiled = compileDeleteReturning(this.contract, this.tableName, this.state.filters, selectedForDelete);
@@ -2596,6 +2663,24 @@ var Collection = class Collection {
 		}
 		return criterion;
 	}
+	async #findFirstMatchingRowIdentityWhere() {
+		const identityColumns = resolveRowIdentityColumns(this.contract, this.tableName);
+		if (identityColumns.length === 0) throw new Error(`update()/delete() on model "${this.modelName}" requires the table to have a primary key or unique constraint`);
+		const firstRow = await this.#clone({
+			selectedFields: [...identityColumns],
+			includes: []
+		}).first();
+		if (!firstRow) return null;
+		const columnToField = getColumnToFieldMap(this.contract, this.modelName);
+		const criterion = {};
+		for (const column of identityColumns) {
+			const fieldName = columnToField[column] ?? column;
+			const value = firstRow[fieldName];
+			if (value === void 0) throw new Error(`Missing identity field "${fieldName}" while resolving single-row scope for model "${this.modelName}"`);
+			criterion[fieldName] = value;
+		}
+		return shorthandToWhereExpr(this.ctx.context, this.modelName, criterion) ?? null;
+	}
 	async #reloadMutationRowByPrimaryKey(criterion) {
 		return this.#reloadMutationRowByCriterion(criterion, "primary key");
 	}
@@ -2627,6 +2712,18 @@ var Collection = class Collection {
 			...overrides
 		});
 	}
+	#withRuntime(runtime) {
+		const Ctor = this.constructor;
+		return new Ctor({
+			...this.ctx,
+			runtime
+		}, this.modelName, {
+			tableName: this.tableName,
+			state: this.state,
+			registry: this.registry,
+			includeRefinementMode: this.includeRefinementMode
+		});
+	}
 	#cloneWithRow(overrides) {
 		return this.#createSelf({
 			...this.state,
@@ -2660,7 +2757,6 @@ var Collection = class Collection {
 		});
 	}
 };
-
 //#endregion
 //#region src/orm.ts
 function orm(options) {
@@ -2702,7 +2798,7 @@ function isCollectionClass(value) {
 	if (!candidate.prototype || typeof candidate.prototype !== "object") return false;
 	return candidate.prototype instanceof Collection;
 }
-
 //#endregion
 export { Collection, GroupedCollection, all, and, emptyState, not, or, orm };
+
 //# sourceMappingURL=index.mjs.map