@prisma/orm-family-sql 0.16.0-dev.36

package/dist/orm-client.mjs

@@ -0,0 +1,4544 @@
+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, V as isWhereExpr, _ 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-BgkZru_1-H7yfikSQ.mjs";
+import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
+import { n as JsonDocumentProjection, r as NativeJsonValueProjection, t as CodecJsonValueProjection } from "./ast-BstHjAoG.mjs";
+import { n as codecRefForStorageColumn } from "./codec-descriptor-registry-BJVJRftS.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { domainModelsAtDefaultNamespace } from "@prisma/orm-framework/contract/types";
+import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+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
+function ormError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function resolveTableForContract(contract, namespaceId, tableName) {
+	return resolveStorageTable(contract.storage, tableName, namespaceId);
+}
+function requireStorageTableForContract(contract, namespaceId, tableName) {
+	const resolved = resolveTableForContract(contract, namespaceId, tableName);
+	if (resolved === void 0) throw ormError("ORM.TABLE_UNKNOWN", `Unknown table "${tableName}"`, { meta: {
+		namespaceId,
+		tableName
+	} });
+	return resolved;
+}
+function storageTableForContract(contract, namespaceId, tableName) {
+	return requireStorageTableForContract(contract, namespaceId, tableName).table;
+}
+function domainModelNamesInNamespace(contract, namespaceId) {
+	const namespace = contract.domain.namespaces[namespaceId];
+	return namespace ? Object.keys(namespace.models) : [];
+}
+function domainModelTableInNamespace(contract, namespaceId, modelName) {
+	const table = (contract.domain.namespaces[namespaceId]?.models[modelName])?.storage["table"];
+	return typeof table === "string" ? table : void 0;
+}
+function tableSourceForContract(contract, namespaceId, tableName, alias) {
+	const resolved = requireStorageTableForContract(contract, namespaceId, tableName);
+	const effectiveAlias = alias !== void 0 && alias !== tableName ? alias : void 0;
+	return TableSource.named(tableName, effectiveAlias, resolved.namespaceId);
+}
+const POLYMORPHIC_DISCRIMINATOR_ALIAS = "__prisma_polymorphic_discriminator";
+function modelsOf(contract, namespaceId) {
+	const namespace = contract.domain.namespaces[namespaceId];
+	if (namespace === void 0) throw new InternalError(`domain namespace "${namespaceId}" is not present on the contract`);
+	return blindCast(namespace.models);
+}
+function metadataCacheKey(namespaceId, modelName) {
+	return `${namespaceId}\u0000${modelName}`;
+}
+function modelOf(contract, namespaceId, name) {
+	const model = contract.domain.namespaces[namespaceId]?.models[name];
+	return model === void 0 ? void 0 : blindCast(model);
+}
+const fieldToColumnCache = /* @__PURE__ */ new WeakMap();
+const columnToFieldCache = /* @__PURE__ */ new WeakMap();
+const polymorphismCache = /* @__PURE__ */ new WeakMap();
+function resolvePolymorphismInfo(contract, namespaceId, modelName) {
+	let perContract = polymorphismCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		polymorphismCache.set(contract, perContract);
+	}
+	const cacheKey = metadataCacheKey(namespaceId, modelName);
+	if (perContract.has(cacheKey)) return perContract.get(cacheKey);
+	const models = modelsOf(contract, namespaceId);
+	const model = models[modelName];
+	if (!model?.discriminator || !model.variants) {
+		perContract.set(cacheKey, void 0);
+		return;
+	}
+	const baseTable = model.storage?.table;
+	if (!baseTable) {
+		perContract.set(cacheKey, void 0);
+		return;
+	}
+	const discriminatorField = model.discriminator.field;
+	const discriminatorColumn = resolveFieldToColumn(contract, namespaceId, modelName, discriminatorField);
+	const variants = /* @__PURE__ */ new Map();
+	const variantsByValue = /* @__PURE__ */ new Map();
+	const mtiVariants = [];
+	for (const [variantModelName, variantEntry] of Object.entries(model.variants)) {
+		const variantModel = models[variantModelName];
+		if (!variantModel) throw new InternalError(`Model "${modelName}" declares variant "${variantModelName}", but that model is missing from the contract`);
+		const variantTable = variantModel.storage?.table ?? baseTable;
+		const strategy = variantTable === baseTable ? "sti" : "mti";
+		const info = {
+			modelName: variantModelName,
+			value: variantEntry.value,
+			table: variantTable,
+			strategy
+		};
+		variants.set(variantModelName, info);
+		variantsByValue.set(variantEntry.value, info);
+		if (strategy === "mti") mtiVariants.push(info);
+	}
+	const result = {
+		discriminatorField,
+		discriminatorColumn,
+		baseTable,
+		variants,
+		variantsByValue,
+		mtiVariants
+	};
+	perContract.set(cacheKey, result);
+	return result;
+}
+function resolveFieldToColumn(contract, namespaceId, modelName, fieldName) {
+	return getFieldToColumnMap(contract, namespaceId, modelName)[fieldName] ?? fieldName;
+}
+/**
+* Map the fields that an MTI variant contributes to `{ table, column }` refs
+* qualified against the variant's own table — the table the read path joins
+* into the correlated child SELECT. STI variants contribute nothing here:
+* their columns live on the base table and resolve through the ordinary
+* 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.
+*/
+function resolveVariantFieldColumns(contract, namespaceId, baseModelName, variantName) {
+	const variant = resolvePolymorphismInfo(contract, namespaceId, baseModelName)?.variants.get(variantName);
+	const result = {};
+	if (variant && variant.strategy === "mti") {
+		const variantFieldToColumn = getFieldToColumnMap(contract, namespaceId, variant.modelName);
+		for (const [field, column] of Object.entries(variantFieldToColumn)) result[field] = {
+			table: variant.table,
+			column
+		};
+	}
+	return result;
+}
+function getFieldToColumnMap(contract, namespaceId, modelName) {
+	let perContract = fieldToColumnCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		fieldToColumnCache.set(contract, perContract);
+	}
+	const cacheKey = metadataCacheKey(namespaceId, modelName);
+	let cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const storageFields = modelsOf(contract, namespaceId)[modelName]?.storage?.fields ?? {};
+	cached = {};
+	for (const [f, s] of Object.entries(storageFields)) if (s?.column) cached[f] = s.column;
+	perContract.set(cacheKey, cached);
+	return cached;
+}
+function getColumnToFieldMap(contract, namespaceId, modelName) {
+	let perContract = columnToFieldCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		columnToFieldCache.set(contract, perContract);
+	}
+	const cacheKey = metadataCacheKey(namespaceId, modelName);
+	let cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const storageFields = modelsOf(contract, namespaceId)[modelName]?.storage?.fields ?? {};
+	cached = {};
+	for (const [f, s] of Object.entries(storageFields)) if (s?.column) cached[s.column] = f;
+	perContract.set(cacheKey, cached);
+	return cached;
+}
+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.
+*/
+function getCompleteColumnToFieldMap(contract, namespaceId, modelName) {
+	let perContract = completeColumnToFieldCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		completeColumnToFieldCache.set(contract, perContract);
+	}
+	const cacheKey = metadataCacheKey(namespaceId, modelName);
+	let cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const storageFields = modelsOf(contract, namespaceId)[modelName]?.storage?.fields ?? {};
+	cached = {};
+	for (const [f, s] of Object.entries(storageFields)) cached[s?.column ?? f] = f;
+	perContract.set(cacheKey, cached);
+	return cached;
+}
+function resolveIncludeRelation(contract, namespaceId, baseModelName, relationName, variantName) {
+	const polymorphism = resolvePolymorphismInfo(contract, namespaceId, baseModelName);
+	const variant = variantName === void 0 ? void 0 : polymorphism?.variants.get(variantName);
+	let declaringModelName = baseModelName;
+	let localTableName = resolveModelTableName(contract, namespaceId, baseModelName);
+	let relation;
+	if (variant !== void 0) {
+		const candidate = resolveModelRelations(contract, namespaceId, variant.modelName)[relationName];
+		if (candidate !== void 0) {
+			relation = candidate;
+			declaringModelName = variant.modelName;
+			localTableName = variant.table;
+		}
+	}
+	relation ??= resolveModelRelations(contract, namespaceId, baseModelName)[relationName];
+	if (!relation) throw ormError("ORM.RELATION_UNKNOWN", `Relation '${relationName}' not found on model '${baseModelName}'`, { meta: {
+		model: baseModelName,
+		relation: relationName
+	} });
+	const localField = relation.on.localFields[0];
+	const targetField = relation.on.targetFields[0];
+	if (!localField || !targetField) throw new InternalError(`Relation '${relationName}' on model '${declaringModelName}' has incomplete join metadata (missing localFields or targetFields)`);
+	const relatedTableName = resolveModelTableName(contract, relation.toNamespace, relation.to);
+	const localColumn = resolveFieldToColumn(contract, namespaceId, declaringModelName, localField);
+	const targetColumn = resolveFieldToColumn(contract, relation.toNamespace, relation.to, targetField);
+	let through;
+	if (relation.through !== void 0) {
+		const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(contract, namespaceId, declaringModelName, field));
+		through = {
+			table: relation.through.table,
+			namespaceId: relation.through.namespaceId,
+			parentColumns: relation.through.parentColumns,
+			childColumns: relation.through.childColumns,
+			targetColumns: relation.through.targetColumns,
+			parentLocalColumns
+		};
+	}
+	return {
+		relatedModelName: relation.to,
+		relatedNamespaceId: relation.toNamespace,
+		relatedTableName,
+		localTableName,
+		targetColumn,
+		localColumn,
+		cardinality: relation.cardinality,
+		...ifDefined("through", through)
+	};
+}
+function resolveThrough(contract, through) {
+	if (!through) return void 0;
+	const { table, namespaceId, parentColumns, childColumns, targetColumns } = through;
+	const junctionTable = contract.storage.namespaces[namespaceId]?.entries.table?.[table];
+	if (!junctionTable) return void 0;
+	const fkColumnSet = /* @__PURE__ */ new Set([...parentColumns, ...childColumns]);
+	const requiredPayloadColumns = [];
+	for (const [colName, col] of Object.entries(junctionTable.columns)) if (!fkColumnSet.has(colName) && !col.nullable && col.default === void 0 && !hasExecutionCreateDefault(contract, namespaceId, table, colName)) requiredPayloadColumns.push(colName);
+	return {
+		table,
+		namespaceId,
+		parentColumns,
+		childColumns,
+		targetColumns,
+		requiredPayloadColumns
+	};
+}
+function hasExecutionCreateDefault(contract, namespace, table, column) {
+	return contract.execution?.mutations.defaults.some((mutationDefault) => mutationDefault.ref.namespace === namespace && mutationDefault.ref.table === table && mutationDefault.ref.column === column && mutationDefault.onCreate !== void 0) ?? false;
+}
+const modelRelationsCache = /* @__PURE__ */ new WeakMap();
+function resolveModelRelations(contract, namespaceId, modelName) {
+	let perContract = modelRelationsCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		modelRelationsCache.set(contract, perContract);
+	}
+	const cacheKey = metadataCacheKey(namespaceId, modelName);
+	const cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const relationMap = modelsOf(contract, namespaceId)[modelName]?.relations ?? {};
+	const resolved = {};
+	for (const [name, value] of Object.entries(relationMap)) {
+		if (!value || typeof value !== "object") continue;
+		const rel = blindCast(value);
+		const localFields = rel.on?.localFields;
+		const targetFields = rel.on?.targetFields;
+		if (!rel.to || typeof rel.to !== "object" || typeof rel.to.model !== "string" || !Array.isArray(localFields) || !Array.isArray(targetFields)) continue;
+		const through = resolveThrough(contract, rel.through);
+		resolved[name] = {
+			to: rel.to.model,
+			toNamespace: rel.to.namespace,
+			cardinality: parseRelationCardinality(rel.cardinality),
+			on: {
+				localFields: blindCast(localFields),
+				targetFields: blindCast(targetFields)
+			},
+			...through !== void 0 ? { through } : {}
+		};
+	}
+	perContract.set(cacheKey, resolved);
+	return resolved;
+}
+function parseRelationCardinality(value) {
+	if (value === "1:1" || value === "N:1" || value === "1:N" || value === "N:M") return value;
+}
+function resolveUpsertConflictColumns(contract, namespaceId, modelName, conflictOn) {
+	if (conflictOn && typeof conflictOn === "object") {
+		const columns = Object.keys(conflictOn).map((fieldName) => resolveFieldToColumn(contract, namespaceId, modelName, fieldName));
+		if (columns.length > 0) return columns;
+	}
+	return [...storageTableForContract(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName)).primaryKey?.columns ?? []];
+}
+function resolveModelTableName(contract, namespaceId, modelName) {
+	const table = domainModelTableInNamespace(contract, namespaceId, modelName);
+	if (table === void 0) throw new InternalError(`Model "${modelName}" has invalid or missing storage.table in namespace "${namespaceId}"`);
+	return table;
+}
+function resolvePrimaryKeyColumn(contract, namespaceId, tableName) {
+	return resolveTableForContract(contract, namespaceId, tableName)?.table.primaryKey?.columns[0] ?? "id";
+}
+function resolveRowIdentityColumns(contract, namespaceId, tableName) {
+	let table;
+	try {
+		table = storageTableForContract(contract, namespaceId, tableName);
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("ambiguous")) throw error;
+		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 ormError("ORM.CAPABILITY_MISSING", `${action} requires contract capability "returning"`, { meta: {
+		capability: "returning",
+		action
+	} });
+}
+function hasContractCapability(contract, capability) {
+	const capabilities = contract.capabilities;
+	const value = capabilities[capability];
+	if (capabilityEnabled(value)) return true;
+	return Object.values(capabilities).some((targetCapabilities) => {
+		if (typeof targetCapabilities !== "object" || targetCapabilities === null) return false;
+		return capabilityEnabled(targetCapabilities[capability]);
+	});
+}
+function capabilityEnabled(value) {
+	if (value === true) return true;
+	if (typeof value !== "object" || value === null) return false;
+	return Object.values(blindCast(value)).some((flag) => flag === true);
+}
+function isToOneCardinality(cardinality) {
+	return cardinality === "1:1" || cardinality === "N:1";
+}
+function createAggregateBuilder(contract, 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");
+		}
+	};
+}
+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";
+}
+function createFieldAggregateSelector(fieldToColumn, field, fn) {
+	const fieldName = field;
+	return {
+		kind: "aggregate",
+		fn,
+		column: fieldToColumn[fieldName] ?? fieldName
+	};
+}
+function normalizeAggregateResult(aggregateSpec, row) {
+	const result = {};
+	for (const [alias, selector] of Object.entries(aggregateSpec)) {
+		const value = row[alias];
+		if (value === null) {
+			result[alias] = null;
+			continue;
+		}
+		if (value === void 0) {
+			result[alias] = selector.fn === "count" ? 0 : null;
+			continue;
+		}
+		if (typeof value === "number") {
+			result[alias] = value;
+			continue;
+		}
+		if (typeof value === "bigint") {
+			result[alias] = Number(value);
+			continue;
+		}
+		if (typeof value === "string") {
+			const numeric = Number(value);
+			result[alias] = Number.isNaN(numeric) ? value : numeric;
+			continue;
+		}
+		result[alias] = value;
+	}
+	return result;
+}
+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);
+	for (const hiddenColumn of hiddenColumns) {
+		const fieldName = columnToField[hiddenColumn] ?? hiddenColumn;
+		delete mapped[fieldName];
+	}
+}
+function mapStorageRowToModelFields(contract, namespaceId, modelName, row) {
+	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
+	if (Object.keys(columnToField).length === 0) return { ...row };
+	const mapped = {};
+	for (const [columnName, value] of Object.entries(row)) mapped[columnToField[columnName] ?? columnName] = value;
+	return mapped;
+}
+const mergedColumnToFieldCache = /* @__PURE__ */ new WeakMap();
+function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variantModelName, variantTable) {
+	const cacheKey = `${namespaceId}:${baseModelName}:${variantModelName}:${variantTable ?? ""}`;
+	let perContract = mergedColumnToFieldCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		mergedColumnToFieldCache.set(contract, perContract);
+	}
+	const cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const baseMap = getCompleteColumnToFieldMap(contract, namespaceId, baseModelName);
+	const variantMap = getCompleteColumnToFieldMap(contract, namespaceId, variantModelName);
+	const merged = { ...baseMap };
+	for (const [col, field] of Object.entries(variantMap)) if (variantTable) merged[`${variantTable}__${col}`] = field;
+	else merged[col] = field;
+	perContract.set(cacheKey, merged);
+	return merged;
+}
+function mapPolymorphicRow(contract, namespaceId, baseModelName, polyInfo, row, variantName) {
+	const discriminatorValue = row[polyInfo.discriminatorColumn] ?? row["__prisma_polymorphic_discriminator"];
+	const variant = variantName ? polyInfo.variants.get(variantName) : typeof discriminatorValue === "string" ? polyInfo.variantsByValue.get(discriminatorValue) : void 0;
+	if (!variant) {
+		const baseMap = getCompleteColumnToFieldMap(contract, namespaceId, baseModelName);
+		const mapped = {};
+		for (const [col, val] of Object.entries(row)) {
+			const field = baseMap[col];
+			if (field !== void 0) mapped[field] = val;
+		}
+		return mapped;
+	}
+	const mtiTable = variant.strategy === "mti" ? variant.table : void 0;
+	const mergedMap = getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, mtiTable);
+	const mapped = {};
+	for (const [col, val] of Object.entries(row)) {
+		const field = mergedMap[col];
+		if (field !== void 0) mapped[field] = val;
+	}
+	return mapped;
+}
+function mapModelDataToStorageRow(contract, namespaceId, modelName, row) {
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const mapped = {};
+	for (const [fieldName, value] of Object.entries(row)) {
+		if (value === void 0) continue;
+		const columnName = fieldToColumn[fieldName] ?? fieldName;
+		mapped[columnName] = value;
+	}
+	return mapped;
+}
+function mapResultRows(result, mapper) {
+	const generator = async function* () {
+		for await (const value of result) yield mapper(value);
+	};
+	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 executeQueryPlan(scope, plan) {
+	return scope.execute(plan);
+}
+function deriveParamsFromAst(ast) {
+	return { params: collectOrderedParamRefs(ast).map((p) => p.kind === "param-ref" ? p.value : void 0) };
+}
+function resolveTableColumns(contract, namespaceId, tableName) {
+	try {
+		return Object.keys(storageTableForContract(contract, namespaceId, tableName).columns);
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("ambiguous")) throw error;
+		throw ormError("ORM.TABLE_UNKNOWN", `Unknown table "${tableName}" in SQL ORM query planner`, { meta: {
+			namespaceId,
+			tableName
+		} });
+	}
+}
+function buildOrmPlanMeta(contract, annotations) {
+	const annotationRecord = annotations !== void 0 && annotations.size > 0 ? Object.freeze(Object.fromEntries(annotations)) : void 0;
+	return {
+		target: contract.target,
+		targetFamily: contract.targetFamily,
+		storageHash: contract.storage.storageHash,
+		...ifDefined("profileHash", contract.profileHash),
+		...ifDefined("annotations", annotationRecord),
+		lane: "orm-client"
+	};
+}
+function buildOrmQueryPlan(contract, ast, params, annotations) {
+	return Object.freeze({
+		ast,
+		params: [...params],
+		meta: buildOrmPlanMeta(contract, annotations)
+	});
+}
+/**
+* Merges annotations into an existing `SqlQueryPlan`'s
+* `meta.annotations` and returns a new frozen plan.
+*
+* Used by the ORM dispatch path to attach terminal-call annotations to
+* plans produced by mutation compile functions (which don't take
+* annotations as parameters). Reads compile through `compileSelect`-
+* family functions that pass `state.annotations` directly to
+* `buildOrmQueryPlan`; this helper is the alternate path for write
+* 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 —
+* see the reserved-namespace policy on `defineAnnotation`.
+*/
+function mergeAnnotations(plan, annotations) {
+	if (annotations === void 0 || annotations.size === 0) return plan;
+	const callerEntries = {};
+	for (const [namespace, value] of annotations) callerEntries[namespace] = value;
+	const mergedAnnotations = Object.freeze({
+		...callerEntries,
+		...plan.meta.annotations ?? {}
+	});
+	return Object.freeze({
+		...plan,
+		meta: Object.freeze({
+			...plan.meta,
+			annotations: mergedAnnotations
+		})
+	});
+}
+function combineWhereExprs(filters) {
+	if (filters.length === 0) return;
+	if (filters.length === 1) return filters[0];
+	return AndExpr.of(filters);
+}
+function toAggregateProjection(contract, namespaceId, tableName, selector) {
+	if (selector.fn === "count") return {
+		expr: AggregateExpr.count(),
+		codec: void 0
+	};
+	if (!selector.column) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `Aggregate selector "${selector.fn}" requires a field`, { meta: { fn: selector.fn } });
+	const expr = new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+	if (selector.fn === "min" || selector.fn === "max") return {
+		expr,
+		codec: codecRefForStorageColumn(contract.storage, namespaceId, tableName, selector.column)
+	};
+	return {
+		expr,
+		codec: void 0
+	};
+}
+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 compileAggregate(contract, 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, 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 compileGroupedAggregate(contract, 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
+	} });
+	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, 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)));
+}
+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) {
+	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 buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName) {
+	if (!variantName || !modelName) return combineWhereExprs(filters);
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	const variant = polyInfo?.variants.get(variantName);
+	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 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));
+	let subquery = SelectAst.from(TableSource.named(tableName, baseTableRef, namespaceId)).withProjection([ProjectionItem.of("_write_filter", ColumnRef.of(baseTableRef, pkColumn))]).withJoins([JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn)]);
+	if (where) subquery = subquery.withWhere(where);
+	return ExistsExpr.exists(subquery);
+}
+function groupRowsByColumnSignature(rows) {
+	const groups = [];
+	let currentKey = "";
+	let currentGroup = [];
+	for (const rawRow of rows) {
+		const row = stripUndefinedValues(rawRow);
+		const key = Object.keys(row).sort().join(",");
+		if (key !== currentKey || currentGroup.length === 0) {
+			if (currentGroup.length > 0) groups.push(currentGroup);
+			currentKey = key;
+			currentGroup = [row];
+		} else currentGroup.push(row);
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	return groups;
+}
+function compileInsertReturningSplit(contract, namespaceId, tableName, rows, returningColumns) {
+	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "create() requires at least one row", { meta: {
+		method: "create",
+		namespaceId,
+		tableName
+	} });
+	return groupRowsByColumnSignature(rows).map((group) => compileInsertReturning(contract, namespaceId, tableName, group, returningColumns));
+}
+function compileInsertCountSplit(contract, namespaceId, tableName, rows) {
+	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "createAndCount() requires at least one row", { meta: {
+		method: "createAndCount",
+		namespaceId,
+		tableName
+	} });
+	return groupRowsByColumnSignature(rows).map((group) => compileInsertCount(contract, namespaceId, tableName, group));
+}
+function compileUpsertReturning(contract, namespaceId, tableName, createValues, updateValues, conflictColumns, returningColumns) {
+	const createAssignments = toParamAssignments(contract, namespaceId, tableName, createValues);
+	const updateAssignments = Object.keys(updateValues).length > 0 ? toParamAssignments(contract, namespaceId, 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(tableSourceForContract(contract, namespaceId, tableName)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileUpdateReturning(contract, namespaceId, tableName, setValues, filters, returningColumns) {
+	const where = combineWhereExprs(filters);
+	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
+	let ast = UpdateAst.table(tableSourceForContract(contract, namespaceId, tableName)).withSet(assignments).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	if (where) ast = ast.withWhere(where);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileUpdateCount(contract, namespaceId, tableName, setValues, filters, variantName, modelName) {
+	const where = buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName);
+	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
+	let ast = UpdateAst.table(tableSourceForContract(contract, namespaceId, tableName)).withSet(assignments);
+	if (where) ast = ast.withWhere(where);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileDeleteReturning(contract, namespaceId, tableName, filters, returningColumns) {
+	const where = combineWhereExprs(filters);
+	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName)).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	if (where) ast = ast.withWhere(where);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function compileDeleteCount(contract, namespaceId, tableName, filters, variantName, modelName) {
+	const where = buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName);
+	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName));
+	if (where) ast = ast.withWhere(where);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
+}
+function augmentSelectionForJoinColumns(selectedFields, requiredColumns) {
+	if (!selectedFields) return {
+		selectedForQuery: selectedFields,
+		hiddenColumns: []
+	};
+	const hiddenColumns = requiredColumns.filter((column) => !selectedFields.includes(column));
+	if (hiddenColumns.length === 0) return {
+		selectedForQuery: selectedFields,
+		hiddenColumns: []
+	};
+	return {
+		selectedForQuery: [...selectedFields, ...hiddenColumns],
+		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
+* through here, and the renderers read the variant to decide how the value
+* reaches JSON.
+*
+* - `codec`: the value is a column whose storage codec is known, so the
+*   renderer can ask that codec's descriptor for the projection producing its
+*   canonical JSON. The `CodecRef` is resolved at planning time by
+*   `codecRefForStorageColumn` and carried on the `ProjectionItem` through
+*   every wrap between the column and here.
+* - `document`: the value is already a JSON document — a nested include's
+*   correlated subquery, a combine branch, or the object a child row set is
+*   aggregated from. Its parts were made canonical at the level that produced
+*   them; this level only nests it.
+* - `native`: the value has no codec identity. An aggregate is the case that
+*   arises today: `COUNT(*)` and `SUM(col)` are computed, and the aggregate's
+*   own result type is not the column's codec. Native is what a value with no
+*   codec identity means, which is a different thing from defaulting a codec
+*   to identity — that, the project forbids.
+*
+* A document never carries a codec and a codec-bearing column is never a
+* document, so the first two cases cannot both apply.
+*/
+function jsonEntryProjection(value, identity) {
+	if (identity.codec !== void 0) return new CodecJsonValueProjection(value, identity.codec);
+	if (identity.document === true) return new JsonDocumentProjection(value);
+	return new NativeJsonValueProjection(value);
+}
+function buildProjection(contract, namespaceId, tableName, selectedFields, tableRef = tableName) {
+	return (selectedFields !== void 0 ? [...selectedFields] : resolveTableColumns(contract, namespaceId, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+}
+function appendUnique(values, value) {
+	if (!values.includes(value)) values.push(value);
+}
+function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) {
+	if (state.selectedFields === void 0) return {
+		baseSelectedFields: void 0,
+		selectedMtiColumnsByTable: void 0,
+		needsHiddenDiscriminator: false
+	};
+	const baseTableColumns = new Set(resolveTableColumns(contract, namespaceId, polyInfo.baseTable));
+	const baseFieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const variantFieldMaps = Array.from(polyInfo.variants.values(), (variant) => ({
+		variant,
+		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 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)
+	};
+}
+function buildStateWhere(contract, tableName, state, options) {
+	const filterTableName = options?.filterTableName;
+	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
+	const remappedFilters = filterTableName && filterTableName !== tableName ? state.filters.map((filter) => filter.rewrite(createTableRefRemapper(filterTableName, tableName))) : state.filters;
+	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 buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
+	if (!childOrderBy || childOrderBy.length === 0) return {
+		childOrderBy: void 0,
+		hiddenOrderProjection: [],
+		aggregateOrderBy: void 0
+	};
+	const hiddenOrderProjection = childOrderBy.map((orderItem, index) => ProjectionItem.of(`${relationName}__order_${index}`, orderItem.expr));
+	return {
+		childOrderBy,
+		hiddenOrderProjection,
+		aggregateOrderBy: hiddenOrderProjection.map((projection, index) => {
+			const orderItem = childOrderBy[index];
+			if (!orderItem) throw new InternalError(`Missing include order metadata at index ${index}`);
+			return new OrderByItem(ColumnRef.of(rowAlias, projection.alias), orderItem.dir);
+		})
+	};
+}
+/**
+* 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];
+}
+function resolveParentLocalRefs(parentSource, include, localColumns) {
+	return localColumns.map((column) => {
+		if (include.localTableName === parentSource.baseTableName) return ColumnRef.of(parentSource.tableRef, column);
+		if (parentSource.variantColumnsProjected) return ColumnRef.of(parentSource.tableRef, `${include.localTableName}__${column}`);
+		return ColumnRef.of(include.localTableName, column);
+	});
+}
+function resolveChildTableSource(include, parentLocalRefs) {
+	const alias = parentLocalRefs.some((ref) => ref.table === include.relatedTableName) ? `${include.relationName}__child` : void 0;
+	return {
+		alias,
+		tableRef: alias ?? include.relatedTableName
+	};
+}
+/**
+* Recursively build the correlated-subquery projections for the nested
+* includes attached to a child SELECT. Used by `buildIncludeChildRowsSelect`
+* to wire depth-2+ aggregates into the inner SELECT at each level.
+*
+* Each nested include contributes a single projection item whose
+* expression is a correlated subquery.
+*/
+function buildNestedIncludeProjections(contract, parentSource, includes) {
+	return includes.map((nested) => buildCorrelatedIncludeProjection(contract, parentSource, nested).projection);
+}
+/**
+* The aliases a level's nested includes contribute. Each such subquery
+* projects a JSON document — an object for a scalar include, an array of
+* objects for a row include — which is what tells the enclosing level to nest
+* the value rather than convert it.
+*/
+function documentAliasesOf(nestedProjections) {
+	return new Set(nestedProjections.map((item) => item.alias));
+}
+/**
+* Resolve the MTI variant joins + `variant_table__column` projection for an
+* include whose target model is polymorphic, mirroring the parent path in
+* `compileSelectWithIncludes`. The discriminator column and any STI
+* variant-specific columns live on the base table and reach the row through
+* the ordinary base-column projection (`buildProjection`); only the MTI
+* variant tables need a join.
+*
+* When the child base table is aliased (self-relations), `buildMtiJoins`
+* emits a join `ON` against the unaliased base table name, which would fall
+* out of scope. Remap it to the child alias — the same remap the row builder
+* already applies to `orderBy`/`where`.
+*/
+function buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef) {
+	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
+	if (!polyInfo) return {
+		joins: [],
+		projection: [],
+		hiddenProjection: [],
+		baseSelectedFields: include.nested.selectedFields
+	};
+	const selection = resolvePolymorphicProjectionSelection(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, include.nested);
+	const { joins, projection } = buildMtiJoins(contract, include.relatedNamespaceId, polyInfo, include.nested.variantName, selection.selectedMtiColumnsByTable);
+	const hiddenProjection = buildHiddenDiscriminatorProjection(contract, include.relatedNamespaceId, polyInfo, childTableRef, selection.needsHiddenDiscriminator);
+	if (!childTableAlias) return {
+		joins,
+		projection,
+		hiddenProjection,
+		baseSelectedFields: selection.baseSelectedFields
+	};
+	const remapper = createTableRefRemapper(polyInfo.baseTable, childTableRef);
+	return {
+		joins: joins.map((join) => join.rewrite(remapper)),
+		projection,
+		hiddenProjection,
+		baseSelectedFields: selection.baseSelectedFields
+	};
+}
+function buildRequiredMtiJoinKeyProjection(contract, include) {
+	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
+	if (!polyInfo) return [];
+	const mtiTables = new Set(polyInfo.mtiVariants.map((variant) => variant.table));
+	const aliases = /* @__PURE__ */ new Set();
+	const projection = [];
+	for (const nested of include.nested.includes) {
+		if (!mtiTables.has(nested.localTableName)) continue;
+		for (const column of localColumnsForRowInclude(nested)) {
+			const alias = `${nested.localTableName}__${column}`;
+			if (aliases.has(alias)) continue;
+			aliases.add(alias);
+			projection.push(ProjectionItem.of(alias, ColumnRef.of(nested.localTableName, column), codecRefForStorageColumn(contract.storage, include.relatedNamespaceId, nested.localTableName, column)));
+		}
+	}
+	return projection;
+}
+function mergeProjectionByAlias(projection, additional) {
+	const aliases = new Set(projection.map((item) => item.alias));
+	const merged = [...projection];
+	for (const item of additional) if (!aliases.has(item.alias)) {
+		aliases.add(item.alias);
+		merged.push(item);
+	}
+	return merged;
+}
+/**
+* Build the correlated WHERE and junction JOIN artifacts for a many-to-many
+* include. The resulting WHERE correlates the junction to the parent rows
+* (AND-ed across all column pairs for composite keys). The junction JOIN
+* connects child rows to the junction via the child columns.
+*/
+function buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, through) {
+	const { table: junctionTable, parentColumns, childColumns, targetColumns, namespaceId } = through;
+	invariant(childColumns.length === targetColumns.length, `M:N junction '${junctionTable}': childColumns (${childColumns.length}) and targetColumns (${targetColumns.length}) must have equal length`);
+	invariant(parentColumns.length === parentLocalRefs.length, `M:N junction '${junctionTable}': parentColumns (${parentColumns.length}) and parentLocalColumns (${parentLocalRefs.length}) must have equal length`);
+	const joinOnPairs = childColumns.map((junctionCol, i) => {
+		const targetCol = targetColumns[i];
+		assertDefined(targetCol, `M:N junction '${junctionTable}': missing target column at index ${i}`);
+		return BinaryExpr.eq(ColumnRef.of(junctionTable, junctionCol), ColumnRef.of(childTableRef, targetCol));
+	});
+	const firstJoinPair = joinOnPairs[0];
+	const joinOn = joinOnPairs.length === 1 && firstJoinPair ? firstJoinPair : AndExpr.of(joinOnPairs);
+	const correlationPairs = parentColumns.map((junctionCol, i) => {
+		const parentLocalRef = parentLocalRefs[i];
+		assertDefined(parentLocalRef, `M:N junction '${junctionTable}': missing parent-local column ref at index ${i}`);
+		return BinaryExpr.eq(ColumnRef.of(junctionTable, junctionCol), parentLocalRef);
+	});
+	const firstCorrelationPair = correlationPairs[0];
+	return {
+		whereExpr: correlationPairs.length === 1 && firstCorrelationPair ? firstCorrelationPair : AndExpr.of(correlationPairs),
+		junctionJoin: JoinAst.inner(TableSource.named(junctionTable, void 0, namespaceId), joinOn, false)
+	};
+}
+function buildIncludeChildRowsSelect(contract, parentSource, include) {
+	const childState = include.nested;
+	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 { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, remappedChildOrderBy);
+	const childWhere = buildStateWhere(contract, childTableRef, childState, {
+		filterTableName: include.relatedTableName,
+		namespaceId: include.relatedNamespaceId
+	});
+	let whereExpr;
+	let junctionJoins = [];
+	if (include.through !== void 0) {
+		const artifacts = buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, include.through);
+		whereExpr = childWhere ? AndExpr.of([artifacts.whereExpr, childWhere]) : artifacts.whereExpr;
+		junctionJoins = [artifacts.junctionJoin];
+	} else {
+		const parentLocalRef = parentLocalRefs[0];
+		assertDefined(parentLocalRef, `Include '${include.relationName}' has no parent-local column ref`);
+		const joinExpr = BinaryExpr.eq(ColumnRef.of(childTableRef, include.targetColumn), parentLocalRef);
+		whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
+	}
+	if (childState.distinct !== void 0 && childState.distinct.length > 0 && childState.includes.length > 0) return buildDistinctNonLeafChildRowsSelect({
+		contract,
+		include,
+		childTableAlias,
+		childTableRef,
+		rowsAlias,
+		childOrderBy,
+		hiddenOrderProjection,
+		aggregateOrderBy,
+		whereExpr,
+		junctionJoins
+	});
+	const polyJoinsAndProjection = buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef);
+	const scalarProjection = buildProjection(contract, include.relatedNamespaceId, include.relatedTableName, polyJoinsAndProjection.baseSelectedFields, childTableRef);
+	const nestedProjections = buildNestedIncludeProjections(contract, {
+		baseTableName: include.relatedTableName,
+		tableRef: childTableRef,
+		variantColumnsProjected: false
+	}, childState.includes);
+	const childProjection = [
+		...scalarProjection,
+		...polyJoinsAndProjection.projection,
+		...polyJoinsAndProjection.hiddenProjection,
+		...nestedProjections
+	];
+	let childRows = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([...childProjection, ...hiddenOrderProjection]).withWhere(whereExpr);
+	if (polyJoinsAndProjection.joins.length > 0) childRows = childRows.withJoins([...polyJoinsAndProjection.joins]);
+	if (junctionJoins.length > 0) childRows = childRows.withJoins(junctionJoins);
+	if (childState.distinctOn && childState.distinctOn.length > 0) {
+		childRows = childRows.withDistinctOn(childState.distinctOn.map((column) => ColumnRef.of(childTableRef, column)));
+		if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy);
+	} else if (childState.distinct && childState.distinct.length > 0) {
+		const rankedAlias = `${include.relationName}__distinct`;
+		childRows = wrapWithRowNumberDedup({
+			base: childRows,
+			distinctColumnRefs: childState.distinct.map((column) => ColumnRef.of(childTableRef, column)),
+			rankingOrderBy: childOrderBy ?? [],
+			rankedAlias
+		});
+		if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+	} else if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy);
+	if (childState.limit !== void 0) childRows = childRows.withLimit(childState.limit);
+	if (childState.offset !== void 0) childRows = childRows.withOffset(childState.offset);
+	return {
+		childRows,
+		childProjection,
+		documentAliases: documentAliasesOf(nestedProjections),
+		rowsAlias,
+		aggregateOrderBy
+	};
+}
+function buildDistinctNonLeafChildRowsSelect(options) {
+	const { contract, include, childTableAlias, childTableRef, rowsAlias, childOrderBy, hiddenOrderProjection, aggregateOrderBy, whereExpr, junctionJoins } = options;
+	const childState = include.nested;
+	const grandchildJoinColumns = Array.from(new Set(childState.includes.flatMap((nested) => nested.localTableName === include.relatedTableName ? localColumnsForRowInclude(nested) : [])));
+	const { selectedForQuery } = augmentSelectionForJoinColumns(childState.selectedFields, grandchildJoinColumns);
+	const visiblePolyProjection = buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef);
+	const queryPolyProjection = buildChildPolymorphismJoinsAndProjection(contract, {
+		...include,
+		nested: {
+			...childState,
+			selectedFields: selectedForQuery
+		}
+	}, childTableAlias, childTableRef);
+	const innerScalarProjection = buildProjection(contract, include.relatedNamespaceId, include.relatedTableName, queryPolyProjection.baseSelectedFields, childTableRef);
+	const innerMtiProjection = mergeProjectionByAlias(queryPolyProjection.projection, buildRequiredMtiJoinKeyProjection(contract, include));
+	let baseInner = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([
+		...innerScalarProjection,
+		...innerMtiProjection,
+		...queryPolyProjection.hiddenProjection,
+		...hiddenOrderProjection
+	]).withWhere(whereExpr);
+	const distinctExtraJoins = [...queryPolyProjection.joins, ...junctionJoins];
+	if (distinctExtraJoins.length > 0) baseInner = baseInner.withJoins(distinctExtraJoins);
+	const distinctColumns = childState.distinct;
+	if (distinctColumns === void 0 || distinctColumns.length === 0) throw new InternalError("buildDistinctNonLeafChildRowsSelect requires a non-empty `distinct` selection");
+	const rankedAlias = `${include.relationName}__ranked`;
+	let innerSelect = wrapWithRowNumberDedup({
+		base: baseInner,
+		distinctColumnRefs: distinctColumns.map((column) => ColumnRef.of(childTableRef, column)),
+		rankingOrderBy: childOrderBy ?? [],
+		rankedAlias
+	});
+	if (childOrderBy) innerSelect = innerSelect.withOrderBy(childOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+	if (childState.limit !== void 0) innerSelect = innerSelect.withLimit(childState.limit);
+	if (childState.offset !== void 0) innerSelect = innerSelect.withOffset(childState.offset);
+	const distinctAlias = `${include.relationName}__distinct`;
+	const outerScalarProjection = buildProjection(contract, include.relatedNamespaceId, include.relatedTableName, visiblePolyProjection.baseSelectedFields, distinctAlias);
+	const outerNestedProjections = buildNestedIncludeProjections(contract, {
+		baseTableName: include.relatedTableName,
+		tableRef: distinctAlias,
+		variantColumnsProjected: true
+	}, childState.includes);
+	const outerPolyProjection = visiblePolyProjection.projection.map((proj) => ProjectionItem.of(proj.alias, ColumnRef.of(distinctAlias, proj.alias), proj.codec));
+	const outerHiddenProjection = visiblePolyProjection.hiddenProjection.map((proj) => ProjectionItem.of(proj.alias, ColumnRef.of(distinctAlias, proj.alias), proj.codec));
+	const outerHiddenOrderProjection = hiddenOrderProjection.map((proj) => ProjectionItem.of(proj.alias, ColumnRef.of(distinctAlias, proj.alias), proj.codec));
+	const childProjection = [
+		...outerScalarProjection,
+		...outerPolyProjection,
+		...outerHiddenProjection,
+		...outerNestedProjections
+	];
+	return {
+		childRows: SelectAst.from(DerivedTableSource.as(distinctAlias, innerSelect)).withProjection([...childProjection, ...outerHiddenOrderProjection]),
+		childProjection,
+		documentAliases: documentAliasesOf(outerNestedProjections),
+		rowsAlias,
+		aggregateOrderBy
+	};
+}
+/**
+* Build the inner SELECT for a scalar include reducer (`count` /
+* `sum` / `avg` / `min` / `max`).
+*
+* Emits one row containing `json_build_object('value', AGG(...))`
+* over the child relation correlated to the parent via the FK. The
+* JSON wrap lets the value flow through the existing include-payload
+* decoder unchanged (it JSON.parses the column and the scalar branch
+* pulls `.value` out).
+*
+* The refine state's pipeline composes through to the aggregate's
+* input set: `where` / `orderBy` / `take` / `skip` / `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`
+*
+* When `take` / `skip` / `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` /
+* `distinct`) is dropped at the SQL level since reordering does not
+* change which rows are aggregated.
+*/
+function buildIncludeChildScalarSelect(contract, parentSource, include, scalar) {
+	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, [include.localColumn]);
+	const parentLocalRef = parentLocalRefs[0];
+	assertDefined(parentLocalRef, `Include '${include.relationName}' has no parent-local column ref`);
+	const childSource = resolveChildTableSource(include, parentLocalRefs);
+	const childTableAlias = childSource.alias;
+	const childTableRef = childSource.tableRef;
+	const state = scalar.state;
+	const joinExpr = BinaryExpr.eq(ColumnRef.of(childTableRef, include.targetColumn), parentLocalRef);
+	const childWhere = buildStateWhere(contract, childTableRef, state, {
+		filterTableName: include.relatedTableName,
+		namespaceId: include.relatedNamespaceId
+	});
+	const 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 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 aggregateExpr = buildIncludeAggregateExpr(scalar, childTableRef);
+		const jsonObjectExpr = JsonObjectExpr.fromEntries([JsonObjectExpr.entry("value", jsonEntryProjection(aggregateExpr, {}))]);
+		return SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([ProjectionItem.of(include.relationName, jsonObjectExpr)]).withWhere(whereExpr);
+	}
+	const innerAlias = `${include.relationName}__scalar`;
+	const hiddenOrderProjection = state.distinct !== void 0 && state.distinct.length > 0 && remappedOrderBy !== void 0 && remappedOrderBy.length > 0 ? remappedOrderBy.map((item, index) => ProjectionItem.of(`${include.relationName}__order_${index}`, item.expr)) : [];
+	const innerProjection = [...scalar.column !== void 0 ? [ProjectionItem.of(scalar.column, ColumnRef.of(childTableRef, scalar.column))] : [ProjectionItem.of("__row", LiteralExpr.of(1))], ...hiddenOrderProjection];
+	let inner = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection(innerProjection).withWhere(whereExpr);
+	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
+		inner = inner.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(childTableRef, column)));
+		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy);
+	} else if (state.distinct !== void 0 && state.distinct.length > 0) {
+		const rankedAlias = `${include.relationName}__scalar_distinct`;
+		inner = wrapWithRowNumberDedup({
+			base: inner,
+			distinctColumnRefs: state.distinct.map((column) => ColumnRef.of(childTableRef, column)),
+			rankingOrderBy: remappedOrderBy ?? [],
+			rankedAlias
+		});
+		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy.map((item, index) => new OrderByItem(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`), item.dir)));
+	} else if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy);
+	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
+	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
+	const outerAggregateExpr = buildIncludeAggregateExpr(scalar, innerAlias);
+	const outerJsonObjectExpr = JsonObjectExpr.fromEntries([JsonObjectExpr.entry("value", jsonEntryProjection(outerAggregateExpr, {}))]);
+	return SelectAst.from(DerivedTableSource.as(innerAlias, inner)).withProjection([ProjectionItem.of(include.relationName, outerJsonObjectExpr)]);
+}
+function buildIncludeAggregateExpr(scalar, childTableRef) {
+	if (scalar.fn === "count") return AggregateExpr.count();
+	if (scalar.column === void 0) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `Aggregate selector "${scalar.fn}" requires a column`, { meta: { fn: scalar.fn } });
+	const columnRef = ColumnRef.of(childTableRef, scalar.column);
+	switch (scalar.fn) {
+		case "sum": return AggregateExpr.sum(columnRef);
+		case "avg": return AggregateExpr.avg(columnRef);
+		case "min": return AggregateExpr.min(columnRef);
+		case "max": return AggregateExpr.max(columnRef);
+		default: return assertNever(scalar.fn);
+	}
+}
+/**
+* Build the inner SELECT for a `combine({ a, b, ... })` include.
+*
+* Each branch produces a self-contained SELECT projecting one row
+* with one column aliased to the relation name. The branches are
+* stitched together as cross-joined derived tables (FROM <first>
+* INNER JOIN <second> ON TRUE ...), and the outer projection packs
+* them into a single `json_build_object` keyed by branch name. The
+* resulting subquery emits exactly one row per parent row containing
+* the combined JSON — embedded as a correlated subquery in the outer
+* projection.
+*
+* 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
+* branch fan out naturally because the row builder is invoked with
+* a synthetic IncludeExpr whose `nested` is the branch's state.
+*/
+function buildIncludeChildCombineSelect(contract, parentSource, include, branches) {
+	const branchEntries = Object.entries(branches);
+	if (branchEntries.length === 0) throw ormError("ORM.INCLUDE_INVALID", `combine() include "${include.relationName}" has no branches`, { meta: { relation: include.relationName } });
+	const compiledBranches = branchEntries.map(([name, branch]) => ({
+		name,
+		alias: `${include.relationName}__combine__${name}`,
+		select: buildIncludeChildCombineBranchSelect(contract, parentSource, include, branch)
+	}));
+	const jsonObjectExpr = JsonObjectExpr.fromEntries(compiledBranches.map((branch) => JsonObjectExpr.entry(branch.name, jsonEntryProjection(ColumnRef.of(branch.alias, include.relationName), { document: true }))));
+	const [firstBranch, ...restBranches] = compiledBranches;
+	if (!firstBranch) throw new InternalError(`combine() include "${include.relationName}" has no branches`);
+	const joins = restBranches.map((branch) => JoinAst.inner(DerivedTableSource.as(branch.alias, branch.select), AndExpr.true(), false));
+	return SelectAst.from(DerivedTableSource.as(firstBranch.alias, firstBranch.select)).withProjection([ProjectionItem.of(include.relationName, jsonObjectExpr)]).withJoins(joins);
+}
+/**
+* Compile one branch of a `combine({ ... })` into a SelectAst that
+* projects exactly one row with one column aliased to the parent
+* relation name. Dispatches to the standalone scalar / row builders
+* with the branch's state spliced into a synthetic IncludeExpr.
+*/
+function buildIncludeChildCombineBranchSelect(contract, parentSource, include, branch) {
+	if (branch.kind === "scalar") return buildIncludeChildScalarSelect(contract, parentSource, include, branch.selector);
+	return buildIncludeChildRowsAggregateSelect(contract, parentSource, {
+		...include,
+		nested: branch.state,
+		scalar: void 0,
+		combine: void 0
+	});
+}
+/**
+* Internal helper: build the inner aggregate SELECT that `json_agg`s
+* child rows into a single JSON-array column aliased to the relation
+* name. Used by both the standalone row correlated-subquery path and
+* by combine's row branches.
+*/
+function buildIncludeChildRowsAggregateSelect(contract, parentSource, include) {
+	const { childRows, childProjection, documentAliases, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, parentSource, include);
+	const jsonObjectExpr = JsonObjectExpr.fromEntries(childProjection.map((item) => JsonObjectExpr.entry(item.alias, jsonEntryProjection(ColumnRef.of(rowsAlias, item.alias), {
+		codec: item.codec,
+		document: documentAliases.has(item.alias)
+	}))));
+	return SelectAst.from(DerivedTableSource.as(rowsAlias, childRows)).withProjection([ProjectionItem.of(include.relationName, JsonArrayAggExpr.of(jsonEntryProjection(jsonObjectExpr, { document: true }), "emptyArray", aggregateOrderBy))]);
+}
+function buildCorrelatedIncludeProjection(contract, parentSource, include) {
+	if (include.scalar) {
+		const scalarSelect = buildIncludeChildScalarSelect(contract, parentSource, include, include.scalar);
+		return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(scalarSelect)) };
+	}
+	if (include.combine) {
+		const combineSelect = buildIncludeChildCombineSelect(contract, parentSource, include, include.combine);
+		return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(combineSelect)) };
+	}
+	const aggregateQuery = buildIncludeChildRowsAggregateSelect(contract, parentSource, include);
+	return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(aggregateQuery)) };
+}
+function buildSelectAst(contract, tableName, state, options) {
+	const namespaceId = options.namespaceId;
+	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);
+	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 (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)));
+	if (state.limit !== void 0) ast = ast.withLimit(state.limit);
+	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, 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, 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 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 dispatchCollectionRows(options) {
+	const { context, runtime, state, tableName, modelName, namespaceId } = options;
+	const { contract } = context;
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	if (state.includes.length === 0) return mapResultRows(executeQueryPlan(runtime, compileSelect(contract, namespaceId, tableName, state, modelName)), polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, rawRow, state.variantName)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow)));
+	return dispatchWithIncludes(options);
+}
+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 executeQueryPlan(scope, compileSelectWithIncludes(contract, 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();
+		}
+	};
+	return new AsyncIterableResult(generator());
+}
+/**
+* Reload the rows a mutation just wrote (create / createAll / update /
+* updateAll / upsert) through the read-path dispatch, so `.include()`
+* relations resolve via the exact same correlated-subquery builder,
+* decoding, and polymorphism mapping a read query uses — there is no
+* parallel mutation read-back implementation.
+*
+* The mutation returns only its identity columns (PK / unique); this
+* re-selects those rows with the caller's projection + includes, keyed
+* by `identity IN (...)`. One round-trip regardless of row count or
+* include depth. The read-back observes the just-written rows because
+* it runs on the same runtime — and therefore the same transaction —
+* the mutation ran on.
+*
+* Delete read-back does NOT come through here: a parent-anchored
+* include query can't observe an already-deleted row, so delete reads
+* its snapshot before issuing the DELETE (see `collection.ts`).
+*/
+function reloadMutationRowsByIdentities(options) {
+	const { context, runtime, tableName, modelName, namespaceId, identityRows, selectedFields, includes } = options;
+	const { contract } = context;
+	if (identityRows.length === 0) return emptyResult();
+	const identityColumns = resolveRowIdentityColumns(contract, namespaceId, tableName);
+	if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `Cannot load includes for the mutation result on model "${modelName}": table "${tableName}" has no primary key or unique constraint to key the include read-back on.`, { meta: {
+		model: modelName,
+		table: tableName
+	} });
+	const identityFilter = buildIdentityInFilter(contract, namespaceId, tableName, identityColumns, identityRows);
+	if (!identityFilter) return emptyResult();
+	return dispatchCollectionRows({
+		context,
+		runtime,
+		state: {
+			...emptyState(),
+			filters: [identityFilter],
+			selectedFields,
+			includes
+		},
+		tableName,
+		modelName,
+		namespaceId
+	});
+}
+function emptyResult() {
+	return new AsyncIterableResult((async function* () {})());
+}
+function buildIdentityInFilter(contract, namespaceId, tableName, identityColumns, identityRows) {
+	const [singleColumn, ...rest] = identityColumns;
+	if (singleColumn !== void 0 && rest.length === 0) {
+		const values = identityRows.map((row) => row[singleColumn]).filter((value) => value !== void 0);
+		if (values.length === 0) return;
+		return bindWhereExpr(contract, BinaryExpr.in(ColumnRef.of(tableName, singleColumn), ListExpression.fromValues(values)), namespaceId);
+	}
+	if (identityRows.length === 0) return;
+	const tuples = identityRows.map((row) => AndExpr.of(identityColumns.map((column) => BinaryExpr.eq(ColumnRef.of(tableName, column), LiteralExpr.of(row[column])))));
+	return bindWhereExpr(contract, OrExpr.of(tuples), namespaceId);
+}
+/**
+* Decode a single-query include payload from a parent row's raw cell
+* into the model-shaped value that downstream consumers see. Recurses
+* through `include.nested.includes` so depth-2+ trees — emitted by the
+* recursive correlated-subquery builder — are decoded symmetrically.
+*
+* The shape produced by the SQL side is one JSON column per top-level
+* include; values nested inside that JSON are already-parsed JS values
+* after the outer `JSON.parse`, so `parseIncludedRows` recognises both
+* the string (top-level) and array (nested) forms.
+*
+* 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.
+*
+* Combine descriptors arrive as a JSON object keyed by branch name;
+* each branch is dispatched to the row or scalar decoder per its
+* declared shape (see `decodeCombineIncludePayload`).
+*/
+async function decodeIncludePayload(contract, context, include, raw) {
+	if (include.scalar) return Promise.resolve(decodeScalarIncludePayload(include, include.scalar, raw));
+	if (include.combine) return decodeCombineIncludePayload(contract, context, include, include.combine, raw);
+	const rawChildren = parseIncludedRows(include, raw);
+	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
+	const mapChildRow = polyInfo ? (childRow) => mapPolymorphicRow(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, childRow, include.nested.variantName) : (childRow) => mapStorageRowToModelFields(contract, include.relatedNamespaceId, include.relatedModelName, childRow);
+	const mappedChildren = [];
+	for (const childRow of rawChildren) {
+		const decodedChildRow = await decodeIncludedStorageRow(contract, context, include, childRow);
+		const mapped = mapChildRow(decodedChildRow);
+		for (const nestedInclude of include.nested.includes) mapped[nestedInclude.relationName] = await decodeIncludePayload(contract, context, nestedInclude, decodedChildRow[nestedInclude.relationName]);
+		mappedChildren.push(mapped);
+	}
+	return coerceSingleQueryIncludeResult(mappedChildren, include.cardinality);
+}
+async function decodeIncludedStorageRow(contract, context, include, row) {
+	const decoded = {};
+	for (const [key, value] of Object.entries(row)) {
+		if (value === null || value === void 0) {
+			decoded[key] = value;
+			continue;
+		}
+		const ref = resolveIncludedColumnRef(contract, include, key);
+		if (!ref) {
+			decoded[key] = value;
+			continue;
+		}
+		const codec = context.contractCodecs.forColumn(include.relatedNamespaceId, ref.table, ref.column);
+		if (!codec) {
+			decoded[key] = value;
+			continue;
+		}
+		decoded[key] = await decodeIncludedColumnValue(ref, context.codecDescriptors.codecRefForColumn(include.relatedNamespaceId, ref.table, ref.column)?.codecId ?? ref.storageColumn.codecId, codec, value);
+	}
+	return decoded;
+}
+function resolveIncludedColumnRef(contract, include, key) {
+	const baseColumn = resolveStorageColumn(contract, include.relatedNamespaceId, include.relatedTableName, key);
+	if (baseColumn) return {
+		table: include.relatedTableName,
+		column: key,
+		storageColumn: baseColumn
+	};
+	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
+	if (!polyInfo) return;
+	for (const variant of polyInfo.mtiVariants) {
+		const prefix = `${variant.table}__`;
+		if (!key.startsWith(prefix)) continue;
+		const column = key.slice(prefix.length);
+		const variantColumn = resolveStorageColumn(contract, include.relatedNamespaceId, variant.table, column);
+		if (variantColumn) return {
+			table: variant.table,
+			column,
+			storageColumn: variantColumn
+		};
+	}
+}
+function resolveStorageColumn(contract, namespaceId, tableName, columnName) {
+	return contract.storage.namespaces[namespaceId]?.entries.table?.[tableName]?.columns[columnName];
+}
+async function decodeIncludedColumnValue(ref, codecId, codec, value) {
+	if (ref.storageColumn.many === true) {
+		if (!Array.isArray(value)) wrapIncludedDecodeFailure(/* @__PURE__ */ new TypeError(`expected an array from the driver for many-typed column, got ${typeof value}`), ref, codecId);
+		const decoded = [];
+		for (const element of value) {
+			if (element === null || element === void 0) {
+				decoded.push(null);
+				continue;
+			}
+			decoded.push(decodeIncludedJsonValue(ref, codecId, codec, element));
+		}
+		return decoded;
+	}
+	return decodeIncludedJsonValue(ref, codecId, codec, value);
+}
+function decodeIncludedJsonValue(ref, codecId, codec, value) {
+	try {
+		return codec.decodeJson(blindCast(value));
+	} catch (error) {
+		if (isRuntimeError(error)) throw error;
+		wrapIncludedDecodeFailure(error, ref, codecId);
+	}
+}
+function wrapIncludedDecodeFailure(error, ref, codecId) {
+	const message = error instanceof Error ? error.message : String(error);
+	const wrapped = runtimeError("RUNTIME.DECODE_FAILED", `Failed to decode column ${ref.table}.${ref.column} with codec '${codecId}': ${message}`, {
+		table: ref.table,
+		column: ref.column,
+		codec: codecId
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+/**
+* Decode the combine payload produced by `buildIncludeChildCombineSelect`.
+*
+* The raw value is a JSON object (already parsed by the SQL layer when
+* top-level, or already a JS object when nested) whose keys are branch
+* names. Each branch value is decoded per its declared kind:
+*  - row branch -> recurse via `decodeIncludePayload` with a synthetic
+*    IncludeExpr carrying the branch's state in `nested`. This walks
+*    nested row-level includes the same way a plain row include would.
+*  - scalar branch -> unwrap the `{value: ...}` envelope via the
+*    standalone scalar decoder.
+*
+* 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,
+* 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.
+*/
+async function decodeCombineIncludePayload(contract, context, include, branches, raw) {
+	const parsed = parseCombineEnvelope(include, raw);
+	const result = {};
+	for (const [branchName, branch] of Object.entries(branches)) {
+		const branchRaw = parsed[branchName];
+		if (branch.kind === "rows") result[branchName] = await decodeIncludePayload(contract, context, {
+			...include,
+			nested: branch.state,
+			scalar: void 0,
+			combine: void 0
+		}, branchRaw);
+		else result[branchName] = decodeScalarIncludePayload(include, branch.selector, branchRaw);
+	}
+	return result;
+}
+function parseCombineEnvelope(include, raw) {
+	if (raw === null || raw === void 0) throw new InternalError(`combine() envelope for include "${include.relationName}" is missing (got ${raw === null ? "null" : "undefined"}); the correlated subquery should always produce a JSON object — this indicates a planner or decoder bug.`);
+	const parsed = parseIncludePayload(raw);
+	if (!isPlainObjectEnvelope(parsed)) throw new InternalError(`combine() envelope for include "${include.relationName}" has unexpected shape (expected object, got ${describeEnvelopeShape(parsed)}); this indicates a planner or decoder bug.`);
+	return parsed;
+}
+function isPlainObjectEnvelope(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeEnvelopeShape(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+/**
+* Pull the primitive scalar value out of the JSON envelope emitted by
+* the correlated scalar builder.
+*
+* 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).
+*
+* Any other shape — array, primitive, string that JSON-parses to
+* non-object — indicates a planner / decoder bug, so we throw
+* loudly naming the include relation rather than soft-handling.
+* Mirrors `parseCombineEnvelope`'s strict shape gate.
+*
+* Values are passed through unchanged — no JS-side `Number()` coercion
+* and no JS-side empty-relation defaulting. 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.
+*/
+function decodeScalarIncludePayload(include, scalar, raw) {
+	if (raw === null || raw === void 0) return emptyScalarResult(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.`);
+	return parsed["value"];
+}
+function parseIncludedRows(include, value) {
+	if (value === null || value === void 0) return [];
+	const parsed = parseIncludePayload(value);
+	if (!Array.isArray(parsed)) return [];
+	const rows = [];
+	for (const item of parsed) {
+		if (!isPlainObjectEnvelope(item)) throw new InternalError(`Include row envelope for relation "${include.relationName}" has unexpected shape (expected object, got ${describeEnvelopeShape(item)}); this indicates a planner or decoder bug.`);
+		rows.push({ ...item });
+	}
+	return rows;
+}
+function parseIncludePayload(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return [];
+	}
+}
+function coerceSingleQueryIncludeResult(rows, cardinality) {
+	return isToOneCardinality(cardinality) ? rows[0] ?? null : rows;
+}
+function emptyScalarResult(fn) {
+	return fn === "count" ? 0 : null;
+}
+function createMutationRowMapper(contract, namespaceId, modelName, variantName) {
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, variantName) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
+}
+function dispatchMutationRows(options) {
+	const { context, runtime, compiled, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { contract } = context;
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	if (includes.length === 0) return mapResultRows(executeQueryPlan(runtime, compiled), (rawRow) => {
+		const mapped = mapStorageRow(rawRow);
+		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
+		return mapRow(mapped);
+	});
+	const generator = async function* () {
+		const identityRows = await executeQueryPlan(runtime, compiled).toArray();
+		yield* reloadMutationRowsByIdentities({
+			context,
+			runtime,
+			tableName,
+			modelName,
+			namespaceId,
+			identityRows,
+			selectedFields,
+			includes
+		});
+	};
+	return new AsyncIterableResult(generator());
+}
+function dispatchSplitMutationRows(options) {
+	const { context, runtime, plans, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { contract } = context;
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	const generator = async function* () {
+		if (includes.length > 0) {
+			const identityRows = [];
+			for (const plan of plans) identityRows.push(...await executeQueryPlan(runtime, plan).toArray());
+			yield* reloadMutationRowsByIdentities({
+				context,
+				runtime,
+				tableName,
+				modelName,
+				namespaceId,
+				identityRows,
+				selectedFields,
+				includes
+			});
+			return;
+		}
+		for (const plan of plans) for await (const rawRow of executeQueryPlan(runtime, plan)) {
+			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 executeQueryPlan(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 executeQueryPlan(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.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.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.namespaceId, this.tableName, this.baseFilters, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters)), annotationsMap);
+		return (await executeQueryPlan(this.ctx.runtime, compiled).toArray()).map((row) => {
+			const mapped = mapStorageRowToModelFields(this.contract, this.namespaceId, this.modelName, row);
+			for (const [alias, selector] of aggregateEntries) mapped[alias] = coerceAggregateValue(selector.fn, row[alias]);
+			return mapped;
+		});
+	}
+};
+function createHavingBuilder(contract, 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));
+		}
+	};
+}
+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 coerceAggregateValue(fn, value) {
+	if (value === null) return null;
+	if (value === void 0) return fn === "count" ? 0 : null;
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "string") {
+		const numeric = Number(value);
+		return Number.isNaN(numeric) ? value : numeric;
+	}
+	return value;
+}
+const aggregateFns = /* @__PURE__ */ new Set([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
+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" && aggregateFns.has(candidate.fn) && 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 hasThrough$1(relation) {
+	return relation.through !== void 0;
+}
+function createModelAccessor(context, namespaceId, modelName, variantName) {
+	const contract = context.contract;
+	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const tableName = resolveModelTableName(contract, namespaceId, modelName);
+	const modelRelations = resolveModelRelations(contract, namespaceId, modelName);
+	const variantFieldColumns = variantName ? resolveVariantFieldColumns(contract, namespaceId, modelName, variantName) : {};
+	const variantCoordinates = variantName ? {
+		name: variantName,
+		relations: resolveModelRelations(contract, namespaceId, variantName),
+		tableName: resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.get(variantName)?.table ?? tableName
+	} : void 0;
+	const opsByCodecId = /* @__PURE__ */ new Map();
+	function registerOp(codecId, op) {
+		let existing = opsByCodecId.get(codecId);
+		if (!existing) {
+			existing = [];
+			opsByCodecId.set(codecId, existing);
+		}
+		existing.push(op);
+	}
+	for (const [name, entry] of Object.entries(context.queryOperations.entries())) {
+		const op = [name, entry];
+		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 blindCast(new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return;
+		if (variantCoordinates) {
+			const variantRelation = variantCoordinates.relations[prop];
+			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, variantCoordinates.tableName, prop, variantRelation);
+		}
+		const relation = modelRelations[prop];
+		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, tableName, prop, relation);
+		const variantField = variantFieldColumns[prop];
+		const resolvedTable = variantField?.table ?? tableName;
+		const columnName = variantField?.column ?? fieldToColumn[prop] ?? prop;
+		const column = resolveColumn(contract, namespaceId, resolvedTable, columnName);
+		if (!column) return;
+		const traits = context.codecDescriptors.descriptorFor(column.codecId)?.traits ?? [];
+		const operations = opsByCodecId.get(column.codecId) ?? [];
+		const codec = codecRefForStorageColumn(contract.storage, namespaceId, resolvedTable, columnName);
+		return createScalarFieldAccessor(resolvedTable, columnName, column.codecId, column.nullable, codec, traits, operations, context);
+	} }));
+}
+function resolveColumn(contract, namespaceId, tableName, columnName) {
+	let table;
+	try {
+		table = storageTableForContract(contract, namespaceId, tableName);
+	} catch {
+		return;
+	}
+	const column = table.columns[columnName];
+	if (!column) return void 0;
+	return {
+		codecId: column.codecId,
+		nullable: column.nullable
+	};
+}
+function createScalarFieldAccessor(tableName, columnName, codecId, nullable, codec, traits, operations, context) {
+	const column = ColumnRef.of(tableName, columnName);
+	const comparisonEntries = [];
+	for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
+		if (meta.traits.some((t) => !traits.includes(t))) continue;
+		comparisonEntries.push([name, meta.create(column, codec)]);
+	}
+	const accessor = blindCast({
+		returnType: {
+			codecId,
+			nullable,
+			codec
+		},
+		codec,
+		buildAst: () => column,
+		...Object.fromEntries(comparisonEntries)
+	});
+	for (const [name, entry] of operations) accessor[name] = createExtensionMethodFactory(accessor, entry, context);
+	return blindCast(accessor);
+}
+function createExtensionMethodFactory(selfExpr, entry, context) {
+	return (...args) => {
+		const result = blindCast(entry.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 returnCodec = { codecId: returnCodecId };
+		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(resultAst, returnCodec);
+		}
+		return methods;
+	};
+}
+function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, parentTableName, relationName, relation) {
+	const relatedTableName = resolveModelTableName(context.contract, relation.toNamespace, relation.to);
+	return {
+		some: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+			mode: "some",
+			predicate
+		}),
+		every: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+			mode: "every",
+			predicate
+		}),
+		none: (predicate) => buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, {
+			mode: "none",
+			predicate
+		})
+	};
+}
+function buildExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options) {
+	if (hasThrough$1(relation)) return buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options);
+	const filterPlan = planRelationFilterMode(buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relation), toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate), options.mode);
+	if (filterPlan.kind === "constantTrue") return AndExpr.true();
+	const selectProjectionColumn = firstTargetColumn(context.contract, relation) ?? "id";
+	const subquery = SelectAst.from(tableSourceForContract(context.contract, relation.toNamespace, relatedTableName)).withProjection([ProjectionItem.of("_exists", ColumnRef.of(relatedTableName, selectProjectionColumn))]).withWhere(filterPlan.where);
+	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
+}
+function buildManyToManyExistsExpr(context, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relationName, relation, options) {
+	const { through } = relation;
+	const junctionTable = through.table;
+	const relatedTableAlias = parentNamespaceId === relation.toNamespace && parentTableName === relatedTableName ? `${relationName}__child` : void 0;
+	const relatedTableRef = relatedTableAlias ?? relatedTableName;
+	const junctionJoinOn = buildPairedColumnExprs(junctionTable, through.childColumns, relatedTableRef, through.targetColumns);
+	const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(context.contract, parentNamespaceId, parentModelName, field));
+	const filterPlan = planRelationFilterMode(buildPairedColumnExprs(junctionTable, through.parentColumns, parentTableName, parentLocalColumns), remapColumnRefs(relatedTableName, relatedTableRef, toRelationWhereExpr(context, relation.toNamespace, relation.to, options.predicate)), options.mode);
+	if (filterPlan.kind === "constantTrue") return AndExpr.true();
+	const firstTargetCol = firstJoinColumn(through.targetColumns, "targetColumns");
+	const subquery = SelectAst.from(tableSourceForContract(context.contract, relation.toNamespace, relatedTableName, relatedTableAlias)).withJoins([JoinAst.inner(TableSource.named(junctionTable, void 0, through.namespaceId), junctionJoinOn)]).withProjection([ProjectionItem.of("_exists", ColumnRef.of(relatedTableRef, firstTargetCol))]).withWhere(filterPlan.where);
+	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
+}
+function planRelationFilterMode(joinWhere, childWhere, mode) {
+	if (mode === "every") {
+		if (!childWhere) return { kind: "constantTrue" };
+		return {
+			kind: "exists",
+			notExists: true,
+			where: and(joinWhere, not(childWhere))
+		};
+	}
+	if (mode === "none") return {
+		kind: "exists",
+		notExists: true,
+		where: childWhere ? and(joinWhere, childWhere) : joinWhere
+	};
+	return {
+		kind: "exists",
+		notExists: false,
+		where: childWhere ? and(joinWhere, childWhere) : joinWhere
+	};
+}
+function remapColumnRefs(tableName, tableRef, expr) {
+	if (!expr || tableName === tableRef) return expr;
+	return expr.rewrite({ columnRef: (column) => column.table === tableName ? ColumnRef.of(tableRef, column.column) : column });
+}
+function firstJoinColumn(columns, label) {
+	const first = columns[0];
+	if (!first) throw new InternalError(`Relation metadata is missing ${label}`);
+	return first;
+}
+function buildPairedColumnExprs(leftTable, leftColumns, rightTable, rightColumns) {
+	if (leftColumns.length !== rightColumns.length) throw new InternalError(`Relation metadata has mismatched join column counts: ${leftColumns.length} left column(s), ${rightColumns.length} right column(s)`);
+	if (leftColumns.length === 0) throw new InternalError("Relation metadata is missing join columns");
+	const exprs = [];
+	for (let i = 0; i < leftColumns.length; i++) {
+		const left = leftColumns[i];
+		const right = rightColumns[i];
+		if (!left || !right) throw new InternalError(`Relation metadata is missing a join column pair at index ${i}`);
+		exprs.push(BinaryExpr.eq(ColumnRef.of(leftTable, left), ColumnRef.of(rightTable, right)));
+	}
+	if (exprs.length === 1 && exprs[0]) return exprs[0];
+	return and(...exprs);
+}
+function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, predicate) {
+	if (!predicate) return;
+	const accessor = createModelAccessor(context, relatedNamespaceId, relatedModelName);
+	if (typeof predicate === "function") return predicate(accessor);
+	const exprs = [];
+	for (const [fieldName, value] of Object.entries(predicate)) {
+		if (value === void 0) continue;
+		const fieldAccessor = blindCast(accessor)[fieldName];
+		if (!fieldAccessor) throw ormError("ORM.FIELD_UNKNOWN", `Shorthand filter on "${relatedModelName}.${fieldName}": field is not defined on the model`, { meta: {
+			model: relatedModelName,
+			field: fieldName
+		} });
+		if (value === null) {
+			if (!fieldAccessor.isNull) throw new InternalError(`Shorthand filter on "${relatedModelName}.${fieldName}": isNull is unexpectedly missing — this is a bug in trait gating`);
+			exprs.push(fieldAccessor.isNull());
+			continue;
+		}
+		if (!fieldAccessor.eq) throw ormError("ORM.FILTER_UNSUPPORTED", `Shorthand filter on "${relatedModelName}.${fieldName}": field does not support equality comparisons`, { meta: {
+			model: relatedModelName,
+			field: fieldName,
+			trait: "equality"
+		} });
+		exprs.push(fieldAccessor.eq(value));
+	}
+	if (exprs.length === 0) return;
+	return exprs.length === 1 ? exprs[0] : and(...exprs);
+}
+function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTableName, relatedTableName, relation) {
+	const localFields = relation.on?.localFields ?? [];
+	const targetFields = relation.on?.targetFields ?? [];
+	const joinExprs = [];
+	const count = Math.min(localFields.length, targetFields.length);
+	for (let i = 0; i < count; i++) {
+		const localField = localFields[i];
+		const targetField = targetFields[i];
+		if (!localField || !targetField) continue;
+		const localColumn = resolveFieldToColumn(contract, parentNamespaceId, parentModelName, localField);
+		const targetColumn = resolveFieldToColumn(contract, relation.toNamespace, relation.to, targetField);
+		joinExprs.push(BinaryExpr.eq(ColumnRef.of(relatedTableName, targetColumn), ColumnRef.of(parentTableName, localColumn)));
+	}
+	if (joinExprs.length === 0) throw new InternalError("Relation metadata is missing join columns");
+	const firstExpr = joinExprs[0];
+	if (joinExprs.length === 1 && firstExpr !== void 0) return firstExpr;
+	return and(...joinExprs);
+}
+function firstTargetColumn(contract, relation) {
+	const firstField = (relation.on?.targetFields)?.[0];
+	if (!firstField) return;
+	return resolveFieldToColumn(contract, relation.toNamespace, relation.to, firstField);
+}
+function createRelationMutator() {
+	return {
+		create(data) {
+			return {
+				kind: "create",
+				data: Array.isArray(data) ? [...data] : [data]
+			};
+		},
+		connect(criteria) {
+			return {
+				kind: "connect",
+				criteria: Array.isArray(criteria) ? [...criteria] : [criteria]
+			};
+		},
+		disconnect(criteria) {
+			if (!criteria) return { kind: "disconnect" };
+			return {
+				kind: "disconnect",
+				criteria: [...criteria]
+			};
+		}
+	};
+}
+function isRelationMutationDescriptor(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	if (candidate.kind !== "create" && candidate.kind !== "connect" && candidate.kind !== "disconnect") return false;
+	return true;
+}
+function isRelationMutationCallback(value) {
+	return typeof value === "function";
+}
+function hasThrough(relation) {
+	return relation.through !== void 0;
+}
+function hasNestedMutationCallbacks(contract, namespaceId, modelName, data) {
+	const relationNames = new Set(Object.keys(resolveModelRelations(contract, namespaceId, modelName)));
+	for (const [fieldName, value] of Object.entries(data)) {
+		if (!relationNames.has(fieldName)) continue;
+		if (isRelationMutationCallback(value)) return true;
+	}
+	return false;
+}
+async function executeNestedCreateMutation(options) {
+	return withMutationScope(options.runtime, async (scope) => createGraph(scope, options.context, options.namespaceId, options.modelName, options.data));
+}
+async function executeNestedUpdateMutation(options) {
+	return withMutationScope(options.runtime, async (scope) => updateFirstGraph(scope, options.context, options.namespaceId, options.modelName, options.filters, options.data));
+}
+function buildPrimaryKeyFilterFromRow(contract, namespaceId, modelName, row) {
+	const fieldName = toFieldName(contract, namespaceId, modelName, resolvePrimaryKeyColumn(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName)));
+	const value = row[fieldName];
+	if (value === void 0) throw new InternalError(`Missing primary key field "${fieldName}" while reloading model "${modelName}"`);
+	return { [fieldName]: value };
+}
+async function withMutationScope(runtime, run) {
+	if (typeof runtime.transaction === "function") return runInTransaction(await runtime.transaction(), run);
+	if (typeof runtime.connection === "function") {
+		const connection = await runtime.connection();
+		try {
+			if (typeof connection.transaction === "function") return await runInTransaction(await connection.transaction(), run);
+			return await run(connection);
+		} finally {
+			await connection.release?.();
+		}
+	}
+	return run(runtime);
+}
+async function runInTransaction(transaction, run) {
+	try {
+		const result = await run(transaction);
+		if (typeof transaction.commit === "function") await transaction.commit();
+		return result;
+	} catch (error) {
+		if (typeof transaction.rollback === "function") await transaction.rollback();
+		throw error;
+	}
+}
+async function createGraph(scope, context, namespaceId, modelName, input) {
+	const contract = context.contract;
+	const parsed = parseMutationInput(contract, namespaceId, modelName, input);
+	const { parentOwned, childOwned, junctionOwned } = partitionByOwnership(parsed.relationMutations);
+	const scalarData = { ...parsed.scalarData };
+	for (const relationMutation of parentOwned) {
+		if (relationMutation.mutation.kind === "disconnect") throw ormError("ORM.RELATION_MUTATION_UNSUPPORTED", "disconnect() is only supported in update() nested mutations", { meta: {
+			kind: "disconnect",
+			relation: relationMutation.relation.relationName
+		} });
+		await applyParentOwnedMutation(scope, context, namespaceId, modelName, scalarData, relationMutation.relation, relationMutation.mutation);
+	}
+	for (const relationMutation of junctionOwned) {
+		if (relationMutation.mutation.kind === "disconnect") throw ormError("ORM.RELATION_MUTATION_UNSUPPORTED", "disconnect() is only supported in update() nested mutations", { meta: {
+			kind: "disconnect",
+			relation: relationMutation.relation.relationName
+		} });
+		await preflightJunctionOwnedCreateMutation(scope, context, relationMutation);
+	}
+	const parentRow = await insertSingleRow(scope, context, namespaceId, modelName, scalarData);
+	for (const relationMutation of childOwned) {
+		if (relationMutation.mutation.kind === "disconnect") throw ormError("ORM.RELATION_MUTATION_UNSUPPORTED", "disconnect() is only supported in update() nested mutations", { meta: {
+			kind: "disconnect",
+			relation: relationMutation.relation.relationName
+		} });
+		await applyChildOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
+	}
+	for (const relationMutation of junctionOwned) await applyJunctionOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
+	return parentRow;
+}
+async function updateFirstGraph(scope, context, namespaceId, modelName, filters, input) {
+	const contract = context.contract;
+	const existingRow = await findFirstByFilters(scope, contract, namespaceId, modelName, filters);
+	if (!existingRow) return null;
+	const parsed = parseMutationInput(contract, namespaceId, modelName, input);
+	const { parentOwned, childOwned, junctionOwned } = partitionByOwnership(parsed.relationMutations);
+	const scalarData = { ...parsed.scalarData };
+	for (const relationMutation of parentOwned) await applyParentOwnedMutation(scope, context, namespaceId, modelName, scalarData, relationMutation.relation, relationMutation.mutation);
+	for (const relationMutation of junctionOwned) await preflightJunctionOwnedCreateMutation(scope, context, relationMutation);
+	let parentRow = existingRow;
+	const mappedUpdateData = mapModelDataToStorageRow(contract, namespaceId, modelName, scalarData);
+	if (Object.keys(mappedUpdateData).length > 0) {
+		const tableName = resolveModelTableName(contract, namespaceId, modelName);
+		const appliedUpdateDefaults = context.applyMutationDefaults({
+			op: "update",
+			table: tableName,
+			namespace: namespaceId,
+			values: mappedUpdateData
+		});
+		for (const def of appliedUpdateDefaults) mappedUpdateData[def.column] = def.value;
+		const pkWhere = shorthandToWhereExpr(context, namespaceId, modelName, castAs(buildPrimaryKeyFilterFromRow(contract, namespaceId, modelName, existingRow)));
+		if (!pkWhere) throw new InternalError(`Failed to build primary key filter for model "${modelName}"`);
+		const updatedRaw = (await executeQueryPlan(scope, compileUpdateReturning(contract, namespaceId, tableName, mappedUpdateData, [pkWhere], void 0)).toArray())[0];
+		if (updatedRaw) parentRow = mapStorageRowToModelFields(contract, namespaceId, modelName, updatedRaw);
+	}
+	for (const relationMutation of childOwned) await applyChildOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
+	for (const relationMutation of junctionOwned) await applyJunctionOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
+	return parentRow;
+}
+function parseMutationInput(contract, namespaceId, modelName, input) {
+	const scalarData = {};
+	const relationDefinitions = new Map(getRelationDefinitions(contract, namespaceId, modelName).map((relation) => [relation.relationName, relation]));
+	const relationMutations = [];
+	for (const [fieldName, value] of Object.entries(input)) {
+		const relation = relationDefinitions.get(fieldName);
+		if (!relation) {
+			scalarData[fieldName] = value;
+			continue;
+		}
+		if (!isRelationMutationCallback(value)) throw ormError("ORM.RELATION_MUTATION_INVALID", `Relation field "${fieldName}" on model "${modelName}" expects a mutator callback`, { meta: {
+			relation: fieldName,
+			model: modelName,
+			problem: "missing-callback"
+		} });
+		const mutation = value(createRelationMutator());
+		if (!isRelationMutationDescriptor(mutation)) throw ormError("ORM.RELATION_MUTATION_INVALID", `Relation field "${fieldName}" on model "${modelName}" returned an invalid mutation descriptor`, { meta: {
+			relation: fieldName,
+			model: modelName,
+			problem: "invalid-descriptor"
+		} });
+		relationMutations.push({
+			relation,
+			mutation
+		});
+	}
+	return {
+		scalarData,
+		relationMutations
+	};
+}
+function partitionByOwnership(relationMutations) {
+	const parentOwned = [];
+	const childOwned = [];
+	const junctionOwned = [];
+	for (const relationMutation of relationMutations) {
+		if (hasThrough(relationMutation.relation)) {
+			junctionOwned.push({
+				relation: relationMutation.relation,
+				mutation: relationMutation.mutation
+			});
+			continue;
+		}
+		if (relationMutation.relation.cardinality === "N:1") {
+			parentOwned.push(relationMutation);
+			continue;
+		}
+		childOwned.push(relationMutation);
+	}
+	return {
+		parentOwned,
+		childOwned,
+		junctionOwned
+	};
+}
+async function applyParentOwnedMutation(scope, context, parentNamespaceId, parentModelName, scalarData, relation, mutation) {
+	const contract = context.contract;
+	if (mutation.kind === "disconnect") {
+		for (const localColumn of relation.localColumns) {
+			const parentFieldName = toFieldName(contract, parentNamespaceId, parentModelName, localColumn);
+			scalarData[parentFieldName] = null;
+		}
+		return;
+	}
+	if (mutation.kind === "create") {
+		const row = mutation.data[0];
+		if (!row) throw ormError("ORM.RELATION_MUTATION_INVALID", `create() nested mutation for relation "${relation.relationName}" requires data`, { meta: {
+			kind: "create",
+			relation: relation.relationName,
+			problem: "missing-data"
+		} });
+		copyRelatedValuesToParent(contract, parentNamespaceId, parentModelName, relation, scalarData, await createGraph(scope, context, relation.relatedNamespaceId, relation.relatedModelName, castAs(row)));
+		return;
+	}
+	const criterion = mutation.criteria[0];
+	if (!criterion) throw ormError("ORM.RELATION_MUTATION_INVALID", `connect() nested mutation for relation "${relation.relationName}" requires criterion`, { meta: {
+		kind: "connect",
+		relation: relation.relationName,
+		problem: "missing-criterion"
+	} });
+	const relatedRow = await findRowByCriterion(scope, context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion));
+	if (!relatedRow) throw ormError("ORM.RELATION_ROW_MISSING", `connect() nested mutation for relation "${relation.relationName}" did not find a matching row`, { meta: {
+		kind: "connect",
+		relation: relation.relationName
+	} });
+	copyRelatedValuesToParent(contract, parentNamespaceId, parentModelName, relation, scalarData, relatedRow);
+}
+function copyRelatedValuesToParent(contract, parentNamespaceId, parentModelName, relation, scalarData, relatedRow) {
+	for (let i = 0; i < relation.localColumns.length; i++) {
+		const localColumn = relation.localColumns[i];
+		const targetColumn = relation.targetColumns[i];
+		if (!localColumn || !targetColumn) continue;
+		const parentFieldName = toFieldName(contract, parentNamespaceId, parentModelName, localColumn);
+		scalarData[parentFieldName] = relatedRow[toFieldName(contract, relation.relatedNamespaceId, relation.relatedModelName, targetColumn)];
+	}
+}
+async function applyChildOwnedMutation(scope, context, parentNamespaceId, parentModelName, parentRow, relation, mutation) {
+	const contract = context.contract;
+	const parentValues = readParentColumnValues(contract, parentNamespaceId, parentModelName, relation, parentRow);
+	if (mutation.kind === "create") {
+		for (const childInput of mutation.data) {
+			const payload = { ...castAs(childInput) };
+			for (const [childColumn, parentValue] of parentValues.entries()) {
+				const childFieldName = toFieldName(contract, relation.relatedNamespaceId, relation.relatedModelName, childColumn);
+				payload[childFieldName] = parentValue;
+			}
+			await createGraph(scope, context, relation.relatedNamespaceId, relation.relatedModelName, castAs(payload));
+		}
+		return;
+	}
+	if (mutation.kind === "connect") {
+		for (const criterion of mutation.criteria) {
+			const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion));
+			if (!criterionWhere) throw ormError("ORM.RELATION_MUTATION_INVALID", `connect() nested mutation for relation "${relation.relationName}" requires non-empty criterion`, { meta: {
+				kind: "connect",
+				relation: relation.relationName,
+				problem: "empty-criterion"
+			} });
+			const setValues = {};
+			for (const [childColumn, parentValue] of parentValues.entries()) setValues[childColumn] = parentValue;
+			await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [criterionWhere]);
+		}
+		return;
+	}
+	const setValues = {};
+	for (const childColumn of parentValues.keys()) setValues[childColumn] = null;
+	if (!mutation.criteria || mutation.criteria.length === 0) {
+		const parentJoinWhere = buildChildJoinWhere(relation, parentValues);
+		await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [parentJoinWhere]);
+		return;
+	}
+	for (const criterion of mutation.criteria) {
+		const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion));
+		if (!criterionWhere) throw ormError("ORM.RELATION_MUTATION_INVALID", `disconnect() nested mutation for relation "${relation.relationName}" requires non-empty criterion`, { meta: {
+			kind: "disconnect",
+			relation: relation.relationName,
+			problem: "empty-criterion"
+		} });
+		const parentJoinWhere = buildChildJoinWhere(relation, parentValues);
+		await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [and(parentJoinWhere, criterionWhere)]);
+	}
+}
+async function applyJunctionOwnedMutation(scope, context, parentNamespaceId, parentModelName, parentRow, relation, mutation) {
+	const contract = context.contract;
+	const parentPkValues = readJunctionParentValues(contract, parentNamespaceId, parentModelName, relation, parentRow);
+	assertJunctionPayloadWritable(relation, mutation.kind);
+	if (mutation.kind === "create") {
+		for (const childInput of mutation.data) await insertJunctionLink(scope, context, relation, parentPkValues, readJunctionTargetValues(contract, relation, await createGraph(scope, context, relation.relatedNamespaceId, relation.relatedModelName, castAs(childInput))), "create");
+		return;
+	}
+	if (mutation.kind === "connect") {
+		for (const criterion of mutation.criteria) await insertJunctionLink(scope, context, relation, parentPkValues, await resolveJunctionTargetValues(scope, context, relation, "connect", criterion), "connect");
+		return;
+	}
+	if (!mutation.criteria || mutation.criteria.length === 0) throw ormError("ORM.RELATION_MUTATION_INVALID", `disconnect() nested mutation for relation "${relation.relationName}" requires criterion`, { meta: {
+		kind: "disconnect",
+		relation: relation.relationName,
+		problem: "missing-criterion"
+	} });
+	for (const criterion of mutation.criteria) await deleteJunctionLink(scope, context, relation, parentPkValues, await resolveJunctionTargetValues(scope, context, relation, "disconnect", criterion));
+}
+async function preflightJunctionOwnedCreateMutation(scope, context, relationMutation) {
+	const { relation, mutation } = relationMutation;
+	assertJunctionMetadataShape(relation);
+	assertJunctionPayloadWritable(relation, mutation.kind);
+	if (mutation.kind !== "connect") return;
+	const seenTargetKeys = /* @__PURE__ */ new Set();
+	for (const criterion of mutation.criteria) {
+		const targetValues = await resolveJunctionTargetValues(scope, context, relation, "connect", criterion);
+		const targetKey = JSON.stringify([...targetValues.entries()]);
+		if (seenTargetKeys.has(targetKey)) throw ormError("ORM.RELATION_MUTATION_INVALID", `connect() nested mutation for relation "${relation.relationName}" resolved duplicate junction link targets; remove the duplicate criteria`, { meta: {
+			kind: "connect",
+			relation: relation.relationName,
+			problem: "duplicate-criteria"
+		} });
+		seenTargetKeys.add(targetKey);
+	}
+}
+function assertJunctionPayloadWritable(relation, mutationKind) {
+	const through = relation.through;
+	if (mutationKind !== "create" && mutationKind !== "connect" || through.requiredPayloadColumns.length === 0) return;
+	const cols = through.requiredPayloadColumns.map((c) => `\`${c}\``).join(", ");
+	throw ormError("ORM.RELATION_MUTATION_UNSUPPORTED", `Cannot \`${mutationKind}\` on relation \`${relation.relationName}\`: its junction \`${through.table}\` has required column(s) ${cols} the relation API can't populate. Write the \`${through.table}\` junction directly or use the SQL builder.`, { meta: {
+		kind: mutationKind,
+		relation: relation.relationName,
+		reason: "junction-required-columns",
+		junction: through.table
+	} });
+}
+async function resolveJunctionTargetValues(scope, context, relation, kind, criterion) {
+	const relatedRow = await findRowByCriterion(scope, context, relation.relatedNamespaceId, relation.relatedModelName, criterion);
+	if (!relatedRow) throw ormError("ORM.RELATION_ROW_MISSING", `${kind}() nested mutation for relation "${relation.relationName}" did not find a matching row`, { meta: {
+		kind,
+		relation: relation.relationName
+	} });
+	return readJunctionTargetValues(context.contract, relation, relatedRow);
+}
+function readJunctionParentValues(contract, parentNamespaceId, parentModelName, relation, parentRow) {
+	const values = /* @__PURE__ */ new Map();
+	assertJunctionParentMetadataLength(relation);
+	for (let i = 0; i < relation.through.parentColumns.length; i++) {
+		const junctionColumn = relation.through.parentColumns[i];
+		const parentColumn = relation.localColumns[i];
+		if (junctionColumn === void 0 || parentColumn === void 0) throw new InternalError(`Relation "${relation.relationName}" has incomplete junction metadata for parent columns`);
+		const parentFieldName = toFieldName(contract, parentNamespaceId, parentModelName, parentColumn);
+		const parentValue = parentRow[parentFieldName];
+		if (parentValue === void 0) throw new InternalError(`Nested mutation requires parent field "${parentFieldName}" to be present in returned row`);
+		values.set(junctionColumn, parentValue);
+	}
+	return values;
+}
+function readJunctionTargetValues(contract, relation, relatedRow) {
+	const values = /* @__PURE__ */ new Map();
+	assertJunctionTargetMetadataLength(relation);
+	for (let i = 0; i < relation.through.childColumns.length; i++) {
+		const junctionColumn = relation.through.childColumns[i];
+		const targetColumn = relation.through.targetColumns[i];
+		if (junctionColumn === void 0 || targetColumn === void 0) throw new InternalError(`Relation "${relation.relationName}" has incomplete junction metadata for target columns`);
+		const targetFieldName = toFieldName(contract, relation.relatedNamespaceId, relation.relatedModelName, targetColumn);
+		const targetValue = relatedRow[targetFieldName];
+		if (targetValue === void 0) throw new InternalError(`Nested mutation requires target field "${targetFieldName}" to be present in returned row`);
+		values.set(junctionColumn, targetValue);
+	}
+	return values;
+}
+function assertJunctionMetadataLength(relation, throughColumnName, throughColumns, pairedColumnName, pairedColumns) {
+	if (throughColumns.length === pairedColumns.length) return;
+	throw new InternalError(`Relation "${relation.relationName}" has invalid junction metadata: ${throughColumnName} has ${throughColumns.length} column(s), but ${pairedColumnName} has ${pairedColumns.length}`);
+}
+function assertJunctionParentMetadataLength(relation) {
+	assertJunctionMetadataLength(relation, "parentColumns", relation.through.parentColumns, "localColumns", relation.localColumns);
+}
+function assertJunctionTargetMetadataLength(relation) {
+	assertJunctionMetadataLength(relation, "childColumns", relation.through.childColumns, "targetColumns", relation.through.targetColumns);
+}
+function assertJunctionMetadataShape(relation) {
+	assertJunctionParentMetadataLength(relation);
+	assertJunctionTargetMetadataLength(relation);
+}
+function writeJunctionColumn(junctionRow, through, column, value, relationName) {
+	if (Object.hasOwn(junctionRow, column) && !Object.is(junctionRow[column], value)) throw ormError("ORM.RELATION_MUTATION_INVALID", `Cannot write junction "${through.table}": conflicting values for junction column "${column}"`, { meta: {
+		relation: relationName,
+		junction: through.table,
+		column
+	} });
+	junctionRow[column] = value;
+}
+async function insertJunctionLink(scope, context, relation, parentPkValues, targetPkValues, mutationKind) {
+	const through = relation.through;
+	const junctionRow = {};
+	for (const [column, value] of parentPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
+	for (const [column, value] of targetPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
+	const applied = context.applyMutationDefaults({
+		op: "create",
+		table: through.table,
+		namespace: through.namespaceId,
+		values: junctionRow
+	});
+	for (const def of applied) junctionRow[def.column] = def.value;
+	const compiled = compileInsertCount(context.contract, through.namespaceId, through.table, [junctionRow]);
+	try {
+		await executeQueryPlan(scope, compiled).toArray();
+	} catch (error) {
+		if (mutationKind === "connect" && isUniqueConstraintViolation(error)) throw ormError("ORM.RELATION_LINK_DUPLICATE", `connect() nested mutation for relation "${relation.relationName}" violated a unique constraint on junction "${through.table}"; the junction link may already be present`, {
+			meta: {
+				relation: relation.relationName,
+				junction: through.table
+			},
+			cause: error
+		});
+		throw error;
+	}
+}
+async function deleteJunctionLink(scope, context, relation, parentPkValues, targetPkValues) {
+	const through = relation.through;
+	const junctionRow = {};
+	for (const [column, value] of parentPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
+	for (const [column, value] of targetPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
+	const exprs = [];
+	for (const [column, value] of Object.entries(junctionRow)) exprs.push(BinaryExpr.eq(ColumnRef.of(through.table, column), LiteralExpr.of(value)));
+	const first = exprs[0];
+	const where = exprs.length === 1 && first !== void 0 ? first : and(...exprs);
+	await executeQueryPlan(scope, compileDeleteCount(context.contract, through.namespaceId, through.table, [where])).toArray();
+}
+function readParentColumnValues(contract, parentNamespaceId, parentModelName, relation, parentRow) {
+	const values = /* @__PURE__ */ new Map();
+	for (let i = 0; i < relation.localColumns.length; i++) {
+		const localColumn = relation.localColumns[i];
+		const targetColumn = relation.targetColumns[i];
+		if (!localColumn || !targetColumn) continue;
+		const parentFieldName = toFieldName(contract, parentNamespaceId, parentModelName, localColumn);
+		const parentValue = parentRow[parentFieldName];
+		if (parentValue === void 0) throw new InternalError(`Nested mutation requires parent field "${parentFieldName}" to be present in returned row`);
+		values.set(targetColumn, parentValue);
+	}
+	return values;
+}
+function buildChildJoinWhere(relation, childValues) {
+	const exprs = [];
+	for (const [childColumn, parentValue] of childValues.entries()) exprs.push(BinaryExpr.eq(ColumnRef.of(relation.relatedTableName, childColumn), LiteralExpr.of(parentValue)));
+	const first = exprs[0];
+	if (exprs.length === 1 && first !== void 0) return first;
+	return and(...exprs);
+}
+async function insertSingleRow(scope, context, namespaceId, modelName, data) {
+	const contract = context.contract;
+	const tableName = resolveModelTableName(contract, namespaceId, modelName);
+	const mappedData = mapModelDataToStorageRow(contract, namespaceId, modelName, data);
+	const applied = context.applyMutationDefaults({
+		op: "create",
+		table: tableName,
+		namespace: namespaceId,
+		values: mappedData
+	});
+	for (const def of applied) mappedData[def.column] = def.value;
+	const firstRow = (await executeQueryPlan(scope, compileInsertReturning(contract, namespaceId, tableName, [mappedData], void 0)).toArray())[0];
+	if (!firstRow) throw ormError("ORM.MUTATION_ROW_MISSING", `Nested create for model "${modelName}" did not return a row`, { meta: {
+		operation: "create",
+		model: modelName,
+		phase: "nested"
+	} });
+	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
+}
+async function findRowByCriterion(scope, context, namespaceId, modelName, criterion) {
+	const contract = context.contract;
+	const whereExpr = shorthandToWhereExpr(context, namespaceId, modelName, castAs(criterion));
+	if (!whereExpr) throw ormError("ORM.RELATION_MUTATION_INVALID", `Nested connect for model "${modelName}" requires non-empty criterion`, { meta: {
+		kind: "connect",
+		model: modelName,
+		problem: "empty-criterion"
+	} });
+	const firstRow = (await executeQueryPlan(scope, compileSelect(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName), {
+		...emptyState(),
+		filters: [whereExpr],
+		limit: 1
+	})).toArray())[0];
+	if (!firstRow) return null;
+	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
+}
+async function findFirstByFilters(scope, contract, namespaceId, modelName, filters) {
+	const firstRow = (await executeQueryPlan(scope, compileSelect(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName), {
+		...emptyState(),
+		filters,
+		limit: 1
+	})).toArray())[0];
+	if (!firstRow) return null;
+	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
+}
+async function executeUpdateCount(scope, contract, namespaceId, tableName, setValues, filters) {
+	await executeQueryPlan(scope, compileUpdateCount(contract, namespaceId, tableName, setValues, filters)).toArray();
+}
+const relationDefsCache = /* @__PURE__ */ new WeakMap();
+function getRelationDefinitions(contract, namespaceId, modelName) {
+	let perContract = relationDefsCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		relationDefsCache.set(contract, perContract);
+	}
+	const cacheKey = `${namespaceId}\u0000${modelName}`;
+	const cached = perContract.get(cacheKey);
+	if (cached) return cached;
+	const relations = resolveModelRelations(contract, namespaceId, modelName);
+	const definitions = Object.entries(relations).map(([relationName, relation]) => ({
+		relationName,
+		relatedModelName: relation.to,
+		relatedNamespaceId: relation.toNamespace,
+		relatedTableName: resolveModelTableName(contract, relation.toNamespace, relation.to),
+		cardinality: relation.cardinality,
+		localColumns: relation.on.localFields.map((f) => resolveFieldToColumn(contract, namespaceId, modelName, f)),
+		targetColumns: relation.on.targetFields.map((f) => resolveFieldToColumn(contract, relation.toNamespace, relation.to, f)),
+		through: relation.through ? {
+			table: relation.through.table,
+			namespaceId: relation.through.namespaceId,
+			parentColumns: relation.through.parentColumns,
+			childColumns: relation.through.childColumns,
+			targetColumns: relation.through.targetColumns,
+			requiredPayloadColumns: relation.through.requiredPayloadColumns
+		} : void 0
+	}));
+	perContract.set(cacheKey, definitions);
+	return definitions;
+}
+function toFieldName(contract, namespaceId, modelName, columnName) {
+	return getColumnToFieldMap(contract, namespaceId, modelName)[columnName] ?? columnName;
+}
+function normalizeWhereArg(arg, options) {
+	if (arg === void 0) return;
+	if (arg === null) throw ormError("ORM.ARGUMENT_INVALID", "WhereArg cannot be null. Pass undefined or a valid WhereExpr/ToWhereExpr payload.", { meta: { argument: "where" } });
+	if (isToWhereExpr(arg)) return arg.toWhereExpr();
+	if (options?.contract) return bindWhereExpr(options.contract, arg, options.namespaceId);
+	return arg;
+}
+function isToWhereExpr(arg) {
+	return typeof arg === "object" && arg !== null && "toWhereExpr" in arg && !isWhereExpr(arg);
+}
+function applyCreateDefaults(ctx, namespaceId, 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,
+			namespace: namespaceId,
+			values: row,
+			...defaultValueCache ? { defaultValueCache } : {}
+		});
+		for (const def of applied) row[def.column] = def.value;
+	}
+}
+function applyUpdateDefaults(ctx, namespaceId, tableName, values) {
+	const applied = ctx.context.applyMutationDefaults({
+		op: "update",
+		table: tableName,
+		namespace: namespaceId,
+		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";
+}
+function isWhereDirectInput(value) {
+	return isWhereExpr(value) && typeof value === "object" && value !== null && "accept" in value && typeof value.accept === "function" || isToWhereExprInput(value);
+}
+function isMtiVariantInfo(variant) {
+	return variant?.strategy === "mti";
+}
+var Collection = class Collection {
+	/** @internal */
+	ctx;
+	/** @internal */
+	contract;
+	/** @internal */
+	modelName;
+	/** @internal */
+	tableName;
+	/** @internal */
+	namespaceId;
+	/** @internal */
+	state;
+	/** @internal */
+	registry;
+	/** @internal */
+	includeRefinementMode;
+	constructor(ctx, modelName, options) {
+		this.ctx = ctx;
+		this.contract = ctx.context.contract;
+		this.modelName = modelName;
+		this.namespaceId = options.namespaceId;
+		this.tableName = options.tableName ?? resolveModelTableName(this.contract, options.namespaceId, modelName);
+		this.state = options.state ?? emptyState();
+		this.registry = options.registry ?? /* @__PURE__ */ new Map();
+		this.includeRefinementMode = options.includeRefinementMode ?? false;
+	}
+	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), {
+			contract: this.contract,
+			namespaceId: this.namespaceId
+		});
+		if (!filter) return blindCast(this);
+		return this.#clone({ filters: [...this.state.filters, filter] });
+	}
+	/**
+	* Narrow a polymorphic model to a specific variant. The returned
+	* collection has the variant's row shape and a discriminator filter
+	* is automatically applied. Chaining `.variant(...)` again replaces
+	* the previous variant filter.
+	*
+	* ```typescript
+	* // Read only admin users (STI):
+	* const admins = await db.orm.User.variant('Admin').all();
+	*
+	* // Iterate the rows:
+	* for await (const admin of db.orm.User.variant('Admin').all()) {
+	*   console.log(admin.role);
+	* }
+	*
+	* // Insert under a variant — discriminator is injected automatically:
+	* await db.orm.User.variant('Admin').create({ name: 'Ada', role: 'super' });
+	* ```
+	*/
+	variant(variantName) {
+		const model = modelOf(this.contract, this.namespaceId, this.modelName);
+		const discriminator = model?.discriminator;
+		const variants = model?.variants;
+		if (!discriminator || !variants) return blindCast(this);
+		const variantEntry = variants[variantName];
+		if (!variantEntry) return blindCast(this);
+		const columnName = resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, discriminator.field);
+		const filter = BinaryExpr.eq(ColumnRef.of(this.tableName, columnName), LiteralExpr.of(variantEntry.value));
+		const filtersWithoutPreviousVariant = this.state.variantName ? this.state.filters.filter((f) => !(f instanceof BinaryExpr && f.left instanceof ColumnRef && f.left.column === columnName && f.left.table === this.tableName)) : this.state.filters;
+		return this.#cloneWithRow({
+			filters: [...filtersWithoutPreviousVariant, filter],
+			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();
+		let scalarSelector;
+		let combineBranches;
+		if (refineFn) {
+			const refined = refineFn(this.#createCollection(blindCast(relation.relatedModelName), {
+				tableName: relation.relatedTableName,
+				namespaceId: relation.relatedNamespaceId,
+				state: emptyState(),
+				includeRefinementMode: true
+			}));
+			if (isIncludeScalar(refined)) {
+				if (isToOneCardinality(relation.cardinality)) throw ormError("ORM.INCLUDE_UNSUPPORTED", `include('${relationName}') scalar aggregations are only supported for to-many relations`, { meta: {
+					relation: relationName,
+					kind: "scalar"
+				} });
+				scalarSelector = refined;
+				nestedState = refined.state;
+			} else if (isIncludeCombine(refined)) {
+				if (isToOneCardinality(relation.cardinality)) throw ormError("ORM.INCLUDE_UNSUPPORTED", `include('${relationName}') combine() is only supported for to-many relations`, { meta: {
+					relation: relationName,
+					kind: "combine"
+				} });
+				combineBranches = refined.branches;
+			} else if (isCollectionStateCarrier(refined)) nestedState = refined.state;
+			else throw ormError("ORM.INCLUDE_INVALID", `include('${relationName}') refinement must return a collection, include scalar selector, or combine() descriptor`, { meta: { relation: relationName } });
+		}
+		const includeExpr = {
+			relationName,
+			relatedModelName: relation.relatedModelName,
+			relatedNamespaceId: relation.relatedNamespaceId,
+			relatedTableName: relation.relatedTableName,
+			localTableName: relation.localTableName,
+			targetColumn: relation.targetColumn,
+			localColumn: relation.localColumn,
+			cardinality: relation.cardinality,
+			...ifDefined("through", relation.through),
+			nested: nestedState,
+			scalar: scalarSelector,
+			combine: combineBranches
+		};
+		return this.#cloneWithRow({ includes: [...this.state.includes, includeExpr] });
+	}
+	/**
+	* Project the row down to a subset of scalar fields. Previously
+	* included relations are preserved on the resulting row shape; only
+	* scalar columns are narrowed.
+	*
+	* ```typescript
+	* const summaries = await db.orm.User.select('id', 'email').all();
+	* // typeof summaries[number] === { id: ...; email: ... }
+	*
+	* for await (const row of db.orm.User.select('id', 'email').all()) {
+	*   console.log(row.id, row.email);
+	* }
+	* ```
+	*/
+	select(...fields) {
+		const selectedFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
+		return this.#cloneWithRow({ selectedFields });
+	}
+	/**
+	* Append an `ORDER BY` clause. Pass a single selector callback or an
+	* array of callbacks; each receives a typed model accessor whose
+	* columns expose `.asc()` and `.desc()`. Multiple calls append to the
+	* existing list (left-to-right ordering preserved).
+	*
+	* Calling `orderBy(...)` unlocks `cursor(...)` and `distinctOn(...)`,
+	* which both require a defined sort order.
+	*
+	* ```typescript
+	* const newest = await db.orm.User.orderBy((u) => u.createdAt.desc()).all();
+	*
+	* const byName = await db.orm.User
+	*   .orderBy([(u) => u.lastName.asc(), (u) => u.firstName.asc()])
+	*   .all();
+	* ```
+	*/
+	orderBy(selection) {
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, this.state.variantName);
+		const nextOrders = (Array.isArray(selection) ? selection : [selection]).map((selector) => selector(accessor));
+		const existing = this.state.orderBy ?? [];
+		return this.#clone({ orderBy: [...existing, ...nextOrders] });
+	}
+	/**
+	* Switch to grouped-aggregate mode. Returns a `GroupedCollection`
+	* whose `.aggregate(...)` terminal produces one row per group with
+	* the chosen key columns plus the requested aggregates.
+	*
+	* ```typescript
+	* const stats = await db.orm.Post
+	*   .where({ published: true })
+	*   .groupBy('userId')
+	*   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum('views') }));
+	* // [{ userId: 1, count: 3, totalViews: 120 }, ...]
+	* ```
+	*/
+	groupBy(...fields) {
+		const groupByColumns = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
+		return new GroupedCollection(this.ctx, this.modelName, {
+			tableName: this.tableName,
+			namespaceId: this.namespaceId,
+			baseFilters: this.state.filters,
+			groupByFields: [...fields],
+			groupByColumns,
+			havingFilters: []
+		});
+	}
+	/**
+	* 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: number }
+	* ```
+	*/
+	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: number | null }
+	* ```
+	*/
+	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: number | null }
+	* ```
+	*/
+	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
+	* reducer such as `count()`/`sum(...)`. Only valid inside an
+	* `include(...)` refinement callback for to-many relations.
+	*
+	* ```typescript
+	* const users = await db.orm.User.include('posts', (posts) =>
+	*   posts.combine({
+	*     recent: posts.where({ published: true }).take(3),
+	*     total: posts.count(),
+	*     averageViews: posts.avg('views'),
+	*   }),
+	* ).all();
+	* // each user row: {
+	* //   ...user,
+	* //   posts: { recent: Post[]; total: number; averageViews: number | null };
+	* // }
+	* ```
+	*/
+	combine(spec) {
+		this.#assertIncludeRefinementMode("combine()");
+		const branches = {};
+		for (const [name, value] of Object.entries(spec)) {
+			if (isIncludeScalar(value)) {
+				branches[name] = {
+					kind: "scalar",
+					selector: value
+				};
+				continue;
+			}
+			if (isCollectionStateCarrier(value)) {
+				branches[name] = {
+					kind: "rows",
+					state: value.state
+				};
+				continue;
+			}
+			throw ormError("ORM.INCLUDE_INVALID", `include().combine() branch "${name}" is invalid`, { meta: { branch: name } });
+		}
+		return createIncludeCombine(branches);
+	}
+	/**
+	* Resume pagination from a known cursor position. Requires a prior
+	* `orderBy(...)` so the cursor has a stable basis; provide a value
+	* for every column referenced by the active `orderBy(...)` so each
+	* ordered axis has a defined boundary.
+	*
+	* ```typescript
+	* const page1 = await db.orm.Post
+	*   .orderBy((p) => p.createdAt.desc())
+	*   .take(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)
+	*   .all();
+	* ```
+	*/
+	cursor(cursorValues) {
+		const mappedCursor = mapCursorValuesToColumns(this.contract, this.namespaceId, this.modelName, cursorValues);
+		if (Object.keys(mappedCursor).length === 0) return this;
+		return this.#clone({ cursor: mappedCursor });
+	}
+	/**
+	* Emit `SELECT DISTINCT` keyed on the given fields. Replaces any
+	* previous `distinct(...)` / `distinctOn(...)` selection.
+	*
+	* ```typescript
+	* const groups = await db.orm.User.distinct('country', 'role').all();
+	* ```
+	*/
+	distinct(...fields) {
+		const distinctFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
+		return this.#clone({
+			distinct: distinctFields,
+			distinctOn: void 0
+		});
+	}
+	/**
+	* Emit `SELECT DISTINCT ON (fields)` — keep the first row per
+	* distinct key according to the current `orderBy(...)`. Requires a
+	* prior `orderBy(...)`; replaces any previous `distinct(...)` /
+	* `distinctOn(...)` selection.
+	*
+	* ```typescript
+	* // Latest post per user:
+	* const latestPerUser = await db.orm.Post
+	*   .orderBy([(p) => p.userId.asc(), (p) => p.createdAt.desc()])
+	*   .distinctOn('userId')
+	*   .all();
+	* ```
+	*/
+	distinctOn(...fields) {
+		const distinctOnFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
+		return this.#clone({
+			distinct: void 0,
+			distinctOn: distinctOnFields
+		});
+	}
+	/**
+	* 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();
+	* ```
+	*/
+	take(n) {
+		return this.#clone({ limit: n });
+	}
+	/**
+	* Apply `OFFSET n`. Replaces any previous offset set on this collection.
+	*
+	* ```typescript
+	* const page2 = await db.orm.User
+	*   .orderBy((u) => u.id.asc())
+	*   .skip(10)
+	*   .take(10)
+	*   .all();
+	* ```
+	*/
+	skip(n) {
+		return this.#clone({ offset: n });
+	}
+	/**
+	* Read terminal: execute the query and stream every matching row.
+	*
+	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+	* resolves to `Row[]` (so `await` collects all rows into an array)
+	* AND an async iterable (so `for await` streams rows as they
+	* arrive, without buffering the whole result set in memory). Pick
+	* 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.
+	*
+	* ```typescript
+	* // Thenable — collect to an array:
+	* const users = await db.orm.User.all();
+	* for (const user of users) console.log(user.id);
+	*
+	* // Async iterable — stream rows as they arrive:
+	* for await (const user of db.orm.User.all()) {
+	*   console.log(user.id);
+	* }
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'read'>` so the caller can attach typed user
+	* annotations to the executed plan. `meta.annotate(...)` enforces
+	* applicability at the type level and at runtime; annotations are
+	* merged into `plan.meta.annotations` at compile time.
+	*
+	* ```typescript
+	* await db.orm.User.all((meta) => meta.annotate(cacheAnnotation({ ttl: 60 })));
+	* ```
+	*/
+	all(configure) {
+		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;
+	}
+	/**
+	* Read terminal: run an aggregate query (count, sum, avg, min, max)
+	* built via the `AggregateBuilder` callback. Returns one object
+	* with the requested aggregate values keyed by the aliases supplied
+	* in the spec.
+	*
+	* ```typescript
+	* const stats = await db.orm.Post
+	*   .where({ published: true })
+	*   .aggregate((agg) => ({
+	*     total: agg.count(),
+	*     averageViews: agg.avg('views'),
+	*     maxViews: agg.max('views'),
+	*   }));
+	* // { total: 42, averageViews: 17.3, maxViews: 9001 }
+	* ```
+	*
+	* 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.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",
+			model: this.modelName
+		} });
+		for (const [alias, selector] of entries) if (!isAggregateSelector(selector)) throw ormError("ORM.AGGREGATE_SELECTOR_INVALID", `aggregate() selector "${alias}" is invalid`, { meta: {
+			method: "aggregate",
+			model: this.modelName,
+			alias
+		} });
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "read", "aggregate");
+		const compiled = mergeAnnotations(compileAggregate(this.contract, this.namespaceId, this.tableName, this.state.filters, aggregateSpec), annotationsMap);
+		return normalizeAggregateResult(aggregateSpec, (await executeQueryPlan(this.ctx.runtime, compiled).toArray())[0] ?? {});
+	}
+	async create(data, configure) {
+		assertReturningCapability(this.contract, "create()");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "create");
+		if (hasNestedMutationCallbacks(this.contract, this.namespaceId, this.modelName, blindCast(data))) {
+			const createdRow = await executeNestedCreateMutation({
+				context: this.ctx.context,
+				runtime: this.ctx.runtime,
+				namespaceId: this.namespaceId,
+				modelName: this.modelName,
+				data: blindCast(data)
+			});
+			const pkCriterion = buildPrimaryKeyFilterFromRow(this.contract, this.namespaceId, this.modelName, createdRow);
+			const reloaded = await this.#reloadMutationRowByPrimaryKey(pkCriterion);
+			if (!reloaded) throw ormError("ORM.MUTATION_ROW_MISSING", `create() for model "${this.modelName}" did not return a row`, { meta: {
+				operation: "create",
+				model: this.modelName
+			} });
+			return reloaded;
+		}
+		const created = (await this.#createAllWithAnnotations([blindCast(data)], annotationsMap))[0];
+		if (created) return created;
+		throw ormError("ORM.MUTATION_ROW_MISSING", `create() for model "${this.modelName}" did not return a row`, { meta: {
+			operation: "create",
+			model: this.modelName
+		} });
+	}
+	/**
+	* Write terminal: insert many rows and stream the inserted rows.
+	*
+	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+	* resolves to `Row[]` AND an async iterable that streams inserted
+	* rows as they arrive. Use whichever shape fits the caller — but
+	* only consume it once. Streaming is the default; some
+	* driver/plan combinations may still buffer internally before
+	* yielding.
+	*
+	* ```typescript
+	* // Thenable — collect all inserted rows into an array:
+	* const created = await db.orm.User.createAll([
+	*   { email: 'a@example.com' },
+	*   { email: 'b@example.com' },
+	* ]);
+	*
+	* // Async iterable — stream inserted rows as they arrive:
+	* for await (const row of db.orm.User.createAll(seedUsers)) {
+	*   console.log('inserted', row.id);
+	* }
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'write'>` for attaching typed annotations to the
+	* compiled insert plan.
+	*/
+	createAll(data, configure) {
+		return this.#createAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "createAll"));
+	}
+	#createAllWithAnnotations(data, annotationsMap) {
+		if (data.length === 0) {
+			const generator = async function* () {};
+			return new AsyncIterableResult(generator());
+		}
+		assertReturningCapability(this.contract, "createAll()");
+		const rows = blindCast(data);
+		const mtiContext = this.#resolveMtiCreateContext();
+		if (mtiContext) return this.#executeMtiCreate(rows, mtiContext);
+		const mappedRows = this.#mapCreateRows(rows);
+		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
+		const { selectedForQuery: selectedForInsert, hiddenColumns } = this.#augmentMutationSelection();
+		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
+			const plans = compileInsertReturningSplit(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert).map((plan) => mergeAnnotations(plan, annotationsMap));
+			return dispatchSplitMutationRows({
+				context: this.ctx.context,
+				runtime: this.ctx.runtime,
+				plans,
+				tableName: this.tableName,
+				modelName: this.modelName,
+				namespaceId: this.namespaceId,
+				variantName: this.state.variantName,
+				includes: this.state.includes,
+				selectedFields: this.state.selectedFields,
+				hiddenColumns,
+				mapRow: (mapped) => blindCast(mapped)
+			});
+		}
+		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert), annotationsMap);
+		return dispatchMutationRows({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			compiled,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId,
+			variantName: this.state.variantName,
+			includes: this.state.includes,
+			selectedFields: this.state.selectedFields,
+			hiddenColumns,
+			mapRow: (mapped) => blindCast(mapped)
+		});
+	}
+	#assertNotMtiVariant(method) {
+		if (this.#resolveMtiCreateContext()) throw ormError("ORM.OPERATION_UNSUPPORTED", `${method} is not supported for MTI variant "${this.state.variantName}" on model "${this.modelName}". Use createAll() instead.`, { meta: {
+			method,
+			model: this.modelName,
+			variant: this.state.variantName,
+			reason: "mti-variant"
+		} });
+	}
+	#resolveMtiCreateContext() {
+		const variantName = this.state.variantName;
+		if (!variantName) return null;
+		const polyInfo = resolvePolymorphismInfo(this.contract, this.namespaceId, this.modelName);
+		if (!polyInfo) return null;
+		const variant = polyInfo.variants.get(variantName);
+		if (!isMtiVariantInfo(variant)) return null;
+		return {
+			polyInfo,
+			variant,
+			baseFieldToColumn: getFieldToColumnMap(this.contract, this.namespaceId, this.modelName),
+			variantFieldToColumn: getFieldToColumnMap(this.contract, this.namespaceId, variant.modelName),
+			pkColumn: resolvePrimaryKeyColumn(this.contract, this.namespaceId, this.tableName)
+		};
+	}
+	#executeMtiCreate(data, mtiCtx) {
+		const { polyInfo, variant, baseFieldToColumn, variantFieldToColumn, pkColumn } = mtiCtx;
+		const contract = this.contract;
+		const collectionCtx = this.ctx;
+		const runtime = collectionCtx.runtime;
+		const tableName = this.tableName;
+		const modelName = this.modelName;
+		const namespaceId = this.namespaceId;
+		const baseFieldColumns = new Set(Object.values(baseFieldToColumn));
+		const variantFieldColumns = new Set(Object.values(variantFieldToColumn));
+		const mergedFieldToColumn = {
+			...baseFieldToColumn,
+			...variantFieldToColumn
+		};
+		const generator = async function* () {
+			for (const row of data) {
+				const allMapped = {};
+				for (const [fieldName, value] of Object.entries(row)) {
+					if (value === void 0) continue;
+					const columnName = mergedFieldToColumn[fieldName] ?? fieldName;
+					allMapped[columnName] = value;
+				}
+				allMapped[polyInfo.discriminatorColumn] = variant.value;
+				const baseRow = {};
+				const variantRow = {};
+				for (const [col, val] of Object.entries(allMapped)) {
+					if (baseFieldColumns.has(col) || col === polyInfo.discriminatorColumn) baseRow[col] = val;
+					if (variantFieldColumns.has(col)) variantRow[col] = val;
+				}
+				yield blindCast(await withMutationScope(runtime, async (scope) => {
+					applyCreateDefaults(collectionCtx, namespaceId, tableName, [baseRow]);
+					const baseCreated = (await executeQueryPlan(scope, compileInsertReturning(contract, namespaceId, tableName, [baseRow], void 0)).toArray())[0];
+					if (!baseCreated) throw ormError("ORM.MUTATION_ROW_MISSING", `MTI base INSERT for model "${modelName}" did not return a row`, { meta: {
+						operation: "create",
+						model: modelName,
+						table: tableName,
+						phase: "mti-base"
+					} });
+					const pkValue = baseCreated[pkColumn];
+					variantRow[pkColumn] = pkValue;
+					applyCreateDefaults(collectionCtx, namespaceId, variant.table, [variantRow]);
+					const variantCreated = (await executeQueryPlan(scope, compileInsertReturning(contract, namespaceId, variant.table, [variantRow], void 0)).toArray())[0];
+					if (!variantCreated) throw ormError("ORM.MUTATION_ROW_MISSING", `MTI variant INSERT for model "${modelName}" into "${variant.table}" did not return a row`, { meta: {
+						operation: "create",
+						model: modelName,
+						table: variant.table,
+						phase: "mti-variant"
+					} });
+					const prefixedVariant = {};
+					for (const [col, val] of Object.entries(variantCreated)) {
+						if (col === pkColumn) continue;
+						prefixedVariant[`${variant.table}__${col}`] = val;
+					}
+					return mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, {
+						...baseCreated,
+						...prefixedVariant
+					}, variant.modelName);
+				}));
+			}
+		};
+		return new AsyncIterableResult(generator());
+	}
+	#mapCreateRows(data) {
+		const variantName = this.state.variantName;
+		if (!variantName) return data.map((row) => mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, row));
+		const polyInfo = resolvePolymorphismInfo(this.contract, this.namespaceId, this.modelName);
+		if (!polyInfo) return data.map((row) => mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, row));
+		const variant = polyInfo.variants.get(variantName);
+		if (!variant) return data.map((row) => mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, row));
+		const baseFieldToColumn = getFieldToColumnMap(this.contract, this.namespaceId, this.modelName);
+		const variantFieldToColumn = getFieldToColumnMap(this.contract, this.namespaceId, variant.modelName);
+		const mergedFieldToColumn = {
+			...baseFieldToColumn,
+			...variantFieldToColumn
+		};
+		return data.map((row) => {
+			const mapped = {};
+			for (const [fieldName, value] of Object.entries(row)) {
+				if (value === void 0) continue;
+				const columnName = mergedFieldToColumn[fieldName] ?? fieldName;
+				mapped[columnName] = value;
+			}
+			mapped[polyInfo.discriminatorColumn] = variant.value;
+			return mapped;
+		});
+	}
+	/**
+	* Write terminal: insert many rows without materializing the
+	* inserted rows, returning the number of inserted records.
+	*
+	* Prefer `createAll(...)` when you need the returned rows; prefer
+	* this when you only need to know how many rows were inserted (the
+	* compiled plan skips `RETURNING`).
+	*
+	* ```typescript
+	* const inserted = await db.orm.User.createAndCount([
+	*   { email: 'a@example.com' },
+	*   { email: 'b@example.com' },
+	* ]);
+	* // inserted === 2
+	* ```
+	*
+	* Not supported on MTI variants — use `createAll(...)` instead.
+	*/
+	async createAndCount(data, configure) {
+		if (data.length === 0) return 0;
+		this.#assertNotMtiVariant("createAndCount()");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "createAndCount");
+		const rows = blindCast(data);
+		const mappedRows = this.#mapCreateRows(rows);
+		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, mappedRows);
+		if (this.contract.capabilities?.["sql"]?.["defaultInInsert"] !== true) {
+			const plans = compileInsertCountSplit(this.contract, this.namespaceId, this.tableName, mappedRows).map((plan) => mergeAnnotations(plan, annotationsMap));
+			for (const plan of plans) await executeQueryPlan(this.ctx.runtime, plan).toArray();
+			return data.length;
+		}
+		const compiled = mergeAnnotations(compileInsertCount(this.contract, this.namespaceId, this.tableName, mappedRows), annotationsMap);
+		await executeQueryPlan(this.ctx.runtime, compiled).toArray();
+		return data.length;
+	}
+	/**
+	* Write terminal: insert a row, or update the existing row on
+	* conflict. Returns the resulting row (the inserted one or the
+	* updated/existing one).
+	*
+	* `conflictOn` selects which unique constraint drives the conflict
+	* resolution — omit to use the model's primary key.
+	*
+	* ```typescript
+	* // Insert-or-update on email uniqueness:
+	* await db.orm.User.upsert({
+	*   create: { email: 'alice@example.com', name: 'Alice' },
+	*   update: { name: 'Alice (updated)' },
+	*   conflictOn: { email: 'alice@example.com' },
+	* });
+	*
+	* // Conditional create — `update: {}` keeps the existing row
+	* // unchanged. `conflictOn` must reference the constraint that
+	* // makes the row "already exist"; omit only when the conflict is
+	* // on the primary key. On conflict,
+	* // `ON CONFLICT DO NOTHING RETURNING ...` may return zero rows,
+	* // so a follow-up reload is issued to fetch and return the
+	* // existing row.
+	* await db.orm.User.upsert({
+	*   create: { email: 'alice@example.com', name: 'Alice' },
+	*   update: {},
+	*   conflictOn: { email: 'alice@example.com' },
+	* });
+	* ```
+	*
+	* Not supported on MTI variants.
+	*/
+	async upsert(input, configure) {
+		assertReturningCapability(this.contract, "upsert()");
+		this.#assertNotMtiVariant("upsert()");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "upsert");
+		const createValues = this.#mapCreateRows([blindCast(input.create)])[0] ?? {};
+		applyCreateDefaults(this.ctx, this.namespaceId, this.tableName, [createValues]);
+		const updateValues = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, input.update);
+		const hasUpdateValues = Object.keys(updateValues).length > 0;
+		if (hasUpdateValues) applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, updateValues);
+		const conflictColumns = resolveUpsertConflictColumns(this.contract, this.namespaceId, this.modelName, blindCast(input.conflictOn));
+		if (conflictColumns.length === 0) throw ormError("ORM.ARGUMENT_INVALID", `upsert() for model "${this.modelName}" requires conflict columns`, { meta: {
+			method: "upsert",
+			model: this.modelName
+		} });
+		const { selectedForQuery: selectedForUpsert, hiddenColumns } = this.#augmentMutationSelection();
+		const compiled = mergeAnnotations(compileUpsertReturning(this.contract, this.namespaceId, this.tableName, createValues, updateValues, conflictColumns, selectedForUpsert), annotationsMap);
+		const row = await executeMutationReturningSingleRow({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			compiled,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId,
+			variantName: this.state.variantName,
+			includes: this.state.includes,
+			selectedFields: this.state.selectedFields,
+			hiddenColumns,
+			mapRow: (mapped) => blindCast(mapped),
+			operation: "upsert",
+			onMissingRowMessage: `upsert() for model "${this.modelName}" did not return a row`
+		});
+		if (row) return row;
+		if (!hasUpdateValues) {
+			const conflictCriterion = this.#buildUpsertConflictCriterion(createValues, conflictColumns);
+			const existing = await this.#reloadMutationRowByCriterion(conflictCriterion, "upsert conflict");
+			if (existing) return existing;
+		}
+		throw ormError("ORM.MUTATION_ROW_MISSING", `upsert() for model "${this.modelName}" did not return a row`, { meta: {
+			operation: "upsert",
+			model: this.modelName
+		} });
+	}
+	/**
+	* Write terminal: update matching rows and return the first one (or
+	* `null` when no row matched). 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.
+	*
+	* ```typescript
+	* // Update one row by id:
+	* const updated = await db.orm.User
+	*   .where({ id: 1 })
+	*   .update({ name: 'Alice Renamed' });
+	*
+	* // Update + relink — runs as a graph of internal mutations:
+	* await db.orm.User
+	*   .where({ id: 1 })
+	*   .update({
+	*     name: 'Alice',
+	*     posts: (posts) => posts.connect([{ id: 5 }]),
+	*   });
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'write'>` for attaching typed annotations.
+	*
+	* 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.
+	*/
+	async update(data, configure) {
+		assertReturningCapability(this.contract, "update()");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "update");
+		if (hasNestedMutationCallbacks(this.contract, this.namespaceId, this.modelName, blindCast(data))) {
+			const updatedRow = await executeNestedUpdateMutation({
+				context: this.ctx.context,
+				runtime: this.ctx.runtime,
+				namespaceId: this.namespaceId,
+				modelName: this.modelName,
+				filters: this.state.filters,
+				data: blindCast(data)
+			});
+			if (!updatedRow) return null;
+			const pkCriterion = buildPrimaryKeyFilterFromRow(this.contract, this.namespaceId, this.modelName, updatedRow);
+			return this.#reloadMutationRowByPrimaryKey(pkCriterion);
+		}
+		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] }).#updateAllWithAnnotations(blindCast(data), annotationsMap))[0] ?? null;
+		});
+	}
+	/**
+	* Write terminal: update every matching row and stream the updated
+	* rows. Requires a prior `.where(...)` filter.
+	*
+	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+	* resolves to `Row[]` AND an async iterable that streams updated
+	* rows as they arrive. Use whichever fits; a result can only be
+	* consumed once. Streaming is the default; some driver/plan
+	* combinations may still buffer internally before yielding.
+	*
+	* ```typescript
+	* // Thenable — collect updated rows into an array:
+	* const updated = await db.orm.Post
+	*   .where({ published: false })
+	*   .updateAll({ published: true });
+	*
+	* // Async iterable — stream updated rows as they arrive:
+	* for await (const row of db.orm.Post.where({ draft: true }).updateAll({ draft: false })) {
+	*   console.log('published', row.id);
+	* }
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'write'>` for attaching typed annotations.
+	*/
+	updateAll(data, configure) {
+		return this.#updateAllWithAnnotations(data, this.#collectAnnotationsFromMeta(configure, "write", "updateAll"));
+	}
+	#updateAllWithAnnotations(data, annotationsMap) {
+		assertReturningCapability(this.contract, "updateAll()");
+		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
+		if (Object.keys(mappedData).length === 0) {
+			const generator = async function* () {};
+			return new AsyncIterableResult(generator());
+		}
+		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
+		const { selectedForQuery: selectedForUpdate, hiddenColumns } = this.#augmentMutationSelection();
+		const compiled = mergeAnnotations(compileUpdateReturning(this.contract, this.namespaceId, this.tableName, mappedData, this.state.filters, selectedForUpdate), annotationsMap);
+		return dispatchMutationRows({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			compiled,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId,
+			variantName: this.state.variantName,
+			includes: this.state.includes,
+			selectedFields: this.state.selectedFields,
+			hiddenColumns,
+			mapRow: (mapped) => blindCast(mapped)
+		});
+	}
+	/**
+	* Write terminal: update every matching row without returning them,
+	* resolving to the count of rows that were updated. Requires a prior
+	* `.where(...)` filter.
+	*
+	* Prefer `updateAll(...)` when you need the updated rows; prefer
+	* this when you only need the affected-row count.
+	*
+	* ```typescript
+	* const count = await db.orm.Post
+	*   .where({ published: false })
+	*   .updateAndCount({ published: true });
+	* ```
+	*/
+	async updateAndCount(data, configure) {
+		const mappedData = mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, data);
+		if (Object.keys(mappedData).length === 0) return 0;
+		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "updateAndCount");
+		const primaryKeyColumn = resolvePrimaryKeyColumn(this.contract, this.namespaceId, this.tableName);
+		const countState = {
+			...emptyState(),
+			filters: this.state.filters,
+			selectedFields: [primaryKeyColumn],
+			variantName: this.state.variantName
+		};
+		const countCompiled = compileSelect(this.contract, this.namespaceId, this.tableName, countState, this.modelName);
+		const matchingRows = await executeQueryPlan(this.ctx.runtime, countCompiled).toArray();
+		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.namespaceId, this.tableName, mappedData, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
+		await executeQueryPlan(this.ctx.runtime, compiled).toArray();
+		return matchingRows.length;
+	}
+	/**
+	* Write terminal: delete matching rows and return the first deleted
+	* row (or `null` when no row matched). Requires a prior `.where(...)`
+	* — calling `delete()` on an unfiltered collection is a type error.
+	*
+	* ```typescript
+	* const deleted = await db.orm.User.where({ id: 1 }).delete();
+	* if (deleted) console.log('deleted', deleted.email);
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'write'>` for attaching typed annotations.
+	*/
+	async delete(configure) {
+		assertReturningCapability(this.contract, "delete()");
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "delete");
+		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(annotationsMap).toArray())[0] ?? null;
+		});
+	}
+	/**
+	* Write terminal: delete every matching row and stream the deleted
+	* rows. Requires a prior `.where(...)` filter.
+	*
+	* The returned `AsyncIterableResult<Row>` is BOTH a thenable that
+	* resolves to `Row[]` AND an async iterable that streams deleted
+	* rows as they arrive. Use whichever fits; a result can only be
+	* consumed once. Streaming is the default; some driver/plan
+	* combinations may still buffer internally before yielding.
+	*
+	* ```typescript
+	* // Thenable — collect the deleted rows into an array:
+	* const deleted = await db.orm.Post.where({ archived: true }).deleteAll();
+	*
+	* // Async iterable — stream deleted rows as they arrive:
+	* for await (const row of db.orm.Post.where({ archived: true }).deleteAll()) {
+	*   console.log('removed', row.id);
+	* }
+	* ```
+	*
+	* Accepts an optional `configure` callback that receives a
+	* `MetaBuilder<'write'>` for attaching typed annotations.
+	*/
+	deleteAll(configure) {
+		return blindCast(this).#deleteAllWithAnnotations(this.#collectAnnotationsFromMeta(configure, "write", "deleteAll"));
+	}
+	#deleteAllWithAnnotations(annotationsMap) {
+		assertReturningCapability(this.contract, "deleteAll()");
+		return this.#executeDeleteReturning(annotationsMap);
+	}
+	#executeDeleteReturning(annotationsMap) {
+		if (this.state.includes.length > 0) return this.#executeDeleteReturningWithIncludes(annotationsMap);
+		const { selectedForQuery: selectedForDelete, hiddenColumns } = this.#augmentMutationSelection();
+		const compiled = mergeAnnotations(compileDeleteReturning(this.contract, this.namespaceId, this.tableName, this.state.filters, selectedForDelete), annotationsMap);
+		return dispatchMutationRows({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			compiled,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId,
+			variantName: this.state.variantName,
+			includes: this.state.includes,
+			selectedFields: this.state.selectedFields,
+			hiddenColumns,
+			mapRow: (mapped) => blindCast(mapped)
+		});
+	}
+	/**
+	* Delete read-back with includes.
+	*
+	* A parent-anchored single-query include read can't observe a row
+	* that has already been deleted, so this reads the rows together with
+	* their relations BEFORE issuing the DELETE. The snapshot is fully
+	* drained into a plain array with `.toArray()` while the rows still
+	* exist; only then does the DELETE run. The yielded `for..of` walks
+	* that in-memory array, not a live cursor, so nothing reads from the
+	* deleted rows after the fact. Snapshot read and delete share one
+	* `withMutationScope` so they are atomic; the returned relations
+	* reflect the row's state at delete time.
+	*/
+	#executeDeleteReturningWithIncludes(annotationsMap) {
+		const collection = this;
+		const generator = async function* () {
+			const snapshot = await withMutationScope(collection.ctx.runtime, async (scope) => {
+				const rows = await dispatchCollectionRows({
+					context: collection.ctx.context,
+					runtime: scope,
+					state: collection.state,
+					tableName: collection.tableName,
+					modelName: collection.modelName,
+					namespaceId: collection.namespaceId
+				}).toArray();
+				await executeQueryPlan(scope, mergeAnnotations(compileDeleteCount(collection.contract, collection.namespaceId, collection.tableName, collection.state.filters, collection.state.variantName, collection.modelName), annotationsMap)).toArray();
+				return rows;
+			});
+			for (const row of snapshot) yield row;
+		};
+		return new AsyncIterableResult(generator());
+	}
+	/**
+	* Write terminal: delete every matching row without returning them,
+	* resolving to the count of rows that were deleted. Requires a prior
+	* `.where(...)` filter.
+	*
+	* Prefer `deleteAll(...)` when you need the deleted rows; prefer
+	* this when you only need the affected-row count.
+	*
+	* ```typescript
+	* const removed = await db.orm.Post.where({ archived: true }).deleteAndCount();
+	* ```
+	*/
+	async deleteAndCount(configure) {
+		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "deleteAndCount");
+		const primaryKeyColumn = resolvePrimaryKeyColumn(this.contract, this.namespaceId, this.tableName);
+		const countState = {
+			...emptyState(),
+			filters: this.state.filters,
+			selectedFields: [primaryKeyColumn],
+			variantName: this.state.variantName
+		};
+		const countCompiled = compileSelect(this.contract, this.namespaceId, this.tableName, countState, this.modelName);
+		const matchingRows = await executeQueryPlan(this.ctx.runtime, countCompiled).toArray();
+		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.namespaceId, this.tableName, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
+		await executeQueryPlan(this.ctx.runtime, compiled).toArray();
+		return matchingRows.length;
+	}
+	#buildUpsertConflictCriterion(createValues, conflictColumns) {
+		const columnToField = getColumnToFieldMap(this.contract, this.namespaceId, this.modelName);
+		const criterion = {};
+		for (const columnName of conflictColumns) {
+			if (!(columnName in createValues)) throw ormError("ORM.ARGUMENT_INVALID", `upsert() for model "${this.modelName}" requires create value for conflict column "${columnName}"`, { meta: {
+				method: "upsert",
+				model: this.modelName,
+				column: columnName
+			} });
+			const fieldName = columnToField[columnName] ?? columnName;
+			criterion[fieldName] = createValues[columnName];
+		}
+		return criterion;
+	}
+	/**
+	* Shape the projection for a mutation's `RETURNING` clause.
+	*
+	* Without includes, the mutation returns the caller's projection
+	* directly. With includes, it returns only the row identity columns
+	* (PK / unique): those rows are reloaded through the read path
+	* (`reloadMutationRowsByIdentities`), which re-selects the caller's
+	* projection together with the relations, so the `RETURNING` clause
+	* need only carry enough to key that read-back.
+	*/
+	#augmentMutationSelection() {
+		if (this.state.includes.length > 0) {
+			const identityColumns = resolveRowIdentityColumns(this.contract, this.namespaceId, this.tableName);
+			if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `Cannot load includes for the mutation result on model "${this.modelName}": table "${this.tableName}" has no primary key or unique constraint to key the include read-back on.`, { meta: {
+				model: this.modelName,
+				table: this.tableName
+			} });
+			return {
+				selectedForQuery: identityColumns,
+				hiddenColumns: []
+			};
+		}
+		return {
+			selectedForQuery: this.state.selectedFields,
+			hiddenColumns: []
+		};
+	}
+	async #findFirstMatchingRowIdentityWhere() {
+		const identityColumns = resolveRowIdentityColumns(this.contract, this.namespaceId, this.tableName);
+		if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `update()/delete() on model "${this.modelName}" requires the table to have a primary key or unique constraint`, { meta: {
+			model: this.modelName,
+			table: this.tableName
+		} });
+		const firstRow = await this.#clone({
+			selectedFields: [...identityColumns],
+			includes: []
+		}).first();
+		if (!firstRow) return null;
+		const columnToField = getColumnToFieldMap(this.contract, this.namespaceId, this.modelName);
+		const criterion = {};
+		for (const column of identityColumns) {
+			const fieldName = columnToField[column] ?? column;
+			const value = blindCast(firstRow)[fieldName];
+			if (value === void 0) throw new InternalError(`Missing identity field "${fieldName}" while resolving single-row scope for model "${this.modelName}"`);
+			criterion[fieldName] = value;
+		}
+		return shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion)) ?? null;
+	}
+	async #reloadMutationRowByPrimaryKey(criterion) {
+		return this.#reloadMutationRowByCriterion(criterion, "primary key");
+	}
+	async #reloadMutationRowByCriterion(criterion, criterionLabel) {
+		const whereExpr = shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion));
+		if (!whereExpr) throw new InternalError(`Failed to build ${criterionLabel} filter for mutation result on model "${this.modelName}"`);
+		const resultState = {
+			...emptyState(),
+			filters: [whereExpr],
+			includes: this.state.includes,
+			selectedFields: this.state.selectedFields,
+			limit: 1
+		};
+		return (await dispatchCollectionRows({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			state: resultState,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId
+		}))[0] ?? null;
+	}
+	#assertIncludeRefinementMode(action) {
+		if (this.includeRefinementMode) return;
+		throw ormError("ORM.INCLUDE_INVALID", `${action} is only available inside include() refinement callbacks`, { meta: { action } });
+	}
+	#clone(overrides) {
+		return this.#createSelf({
+			...this.state,
+			...overrides
+		});
+	}
+	#withRuntime(runtime) {
+		return blindCast(new (blindCast(this.constructor))({
+			...this.ctx,
+			runtime
+		}, this.modelName, {
+			tableName: this.tableName,
+			namespaceId: this.namespaceId,
+			state: this.state,
+			registry: this.registry,
+			includeRefinementMode: this.includeRefinementMode
+		}));
+	}
+	#cloneWithRow(overrides) {
+		return this.#createSelf({
+			...this.state,
+			...overrides
+		});
+	}
+	#createSelf(state) {
+		return blindCast(new (blindCast(this.constructor))(this.ctx, this.modelName, {
+			tableName: this.tableName,
+			namespaceId: this.namespaceId,
+			state,
+			registry: this.registry,
+			includeRefinementMode: this.includeRefinementMode
+		}));
+	}
+	#createCollection(modelName, options) {
+		return blindCast(new ((this.registry.get(modelName)) ?? (blindCast(Collection)))(this.ctx, modelName, {
+			tableName: options.tableName,
+			namespaceId: options.namespaceId,
+			state: options.state,
+			registry: options.registry ?? this.registry,
+			includeRefinementMode: options.includeRefinementMode ?? this.includeRefinementMode
+		}));
+	}
+	#dispatch() {
+		return dispatchCollectionRows({
+			context: this.ctx.context,
+			runtime: this.ctx.runtime,
+			state: this.state,
+			tableName: this.tableName,
+			modelName: this.modelName,
+			namespaceId: this.namespaceId
+		});
+	}
+	/**
+	* Invokes the user-supplied configurator (if any) against a freshly
+	* constructed read meta builder, and returns a clone whose
+	* `state.annotations` carries the recorded map. Used by read
+	* terminals that flow annotations through state (`all`, `first`).
+	*
+	* Returns the receiver unchanged when no configurator was supplied
+	* or when the configurator did not call `meta.annotate(...)`. The
+	* meta builder's `annotate` method enforces applicability at the
+	* type level and at runtime, so terminal code does not need to
+	* re-validate.
+	*/
+	#withAnnotationsFromMeta(configure, terminalName) {
+		if (configure === void 0) return this;
+		const meta = createMetaBuilder("read", terminalName);
+		configure(meta);
+		if (meta.annotations.size === 0) return this;
+		const next = new Map(this.state.annotations);
+		for (const [namespace, value] of meta.annotations) next.set(namespace, value);
+		return blindCast(this.#clone({ annotations: next }));
+	}
+	/**
+	* Invokes the user-supplied configurator (if any) against a freshly
+	* constructed meta builder of the given operation kind, and returns
+	* the recorded annotation map (or `undefined` when empty). Used by
+	* terminals where annotations don't flow through `state` — the
+	* 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`.
+	* The meta builder's `annotate` method enforces applicability at the
+	* type level and at runtime.
+	*/
+	#collectAnnotationsFromMeta(configure, kind, terminalName) {
+		if (configure === void 0) return;
+		const meta = createMetaBuilder(kind, terminalName);
+		configure(meta);
+		return meta.annotations.size === 0 ? void 0 : meta.annotations;
+	}
+};
+function orm(options) {
+	const { runtime, collections, context } = options;
+	const contract = context.contract;
+	const ctx = {
+		runtime,
+		context
+	};
+	const collectionRegistry = createCollectionRegistry(contract, collections);
+	function buildCollection(namespaceId, modelName, tableName) {
+		return new (blindCast(collectionRegistry.get(modelName) ?? Collection))(ctx, modelName, {
+			registry: collectionRegistry,
+			namespaceId,
+			...tableName !== void 0 ? { tableName } : {}
+		});
+	}
+	const namespaceFacets = /* @__PURE__ */ new Map();
+	function namespaceFacet(namespaceId) {
+		const cached = namespaceFacets.get(namespaceId);
+		if (cached) return cached;
+		const facetModelNames = new Set(domainModelNamesInNamespace(contract, namespaceId));
+		const facetCache = /* @__PURE__ */ new Map();
+		const facet = new Proxy({}, { get(_facetTarget, modelProp) {
+			if (typeof modelProp !== "string") return;
+			if (!facetModelNames.has(modelProp)) return;
+			const hit = facetCache.get(modelProp);
+			if (hit) return hit;
+			const collection = buildCollection(namespaceId, modelProp, domainModelTableInNamespace(contract, namespaceId, modelProp));
+			facetCache.set(modelProp, collection);
+			return collection;
+		} });
+		namespaceFacets.set(namespaceId, facet);
+		return facet;
+	}
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return;
+		if (!Object.hasOwn(contract.domain.namespaces, prop)) return;
+		return namespaceFacet(prop);
+	} });
+}
+function createCollectionRegistry(contract, collections) {
+	const registry = /* @__PURE__ */ new Map();
+	if (!collections) return registry;
+	const models = domainModelsAtDefaultNamespace(contract.domain);
+	for (const [key, collectionClass] of Object.entries(collections)) {
+		if (!collectionClass) continue;
+		if (!isCollectionClass(collectionClass)) throw ormError("ORM.ARGUMENT_INVALID", `Custom collection '${key}' must be a Collection class (constructor), not an instance`, { meta: {
+			method: "orm",
+			argument: "collections",
+			key
+		} });
+		if (!Object.hasOwn(models, key)) throw ormError("ORM.ARGUMENT_INVALID", `No model found for custom collection '${key}'. Available models: ${Object.keys(models).join(", ")}`, { meta: {
+			method: "orm",
+			argument: "collections",
+			key
+		} });
+		registry.set(key, collectionClass);
+	}
+	return registry;
+}
+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;
+}
+//#endregion
+export { Collection, GroupedCollection, all, and, createModelAccessor, emptyState, not, or, orm };
+
+//# sourceMappingURL=orm-client.mjs.map