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

package/dist/orm-client.mjs

@@ -33,6 +33,20 @@ function aggregateOperationNames(registry) {
 	operationNamesByRegistry.set(registry, names);
 	return names;
 }
+const contractCache = /* @__PURE__ */ new WeakMap();
+/** Builds a value derived from `contract` once per contract and key. Every key starts with a name that only one function uses, and that function stores its own result type under it. */
+function cachedFor(contract, key, build) {
+	let perContract = contractCache.get(contract);
+	if (!perContract) {
+		perContract = /* @__PURE__ */ new Map();
+		contractCache.set(contract, perContract);
+	}
+	const cacheKey = JSON.stringify(key);
+	if (perContract.has(cacheKey)) return blindCast(perContract.get(cacheKey));
+	const built = build();
+	perContract.set(cacheKey, built);
+	return built;
+}
 function ormError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -76,8 +90,6 @@ 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);
@@ -99,7 +111,7 @@ function resolvePolymorphismInfo(contract, namespaceId, modelName) {
 		return;
 	}
 	const discriminatorField = model.discriminator.field;
-	const discriminatorColumn = resolveFieldToColumn(contract, namespaceId, modelName, discriminatorField);
+	const discriminatorColumn = columnOfContractField(contract, namespaceId, modelName, discriminatorField);
 	const variants = /* @__PURE__ */ new Map();
 	const variantsByValue = /* @__PURE__ */ new Map();
 	const mtiVariants = [];
@@ -129,81 +141,235 @@ function resolvePolymorphismInfo(contract, namespaceId, modelName) {
 	perContract.set(cacheKey, result);
 	return result;
 }
-function resolveFieldToColumn(contract, namespaceId, modelName, fieldName) {
-	return getFieldToColumnMap(contract, namespaceId, modelName)[fieldName] ?? fieldName;
+/** The column each of the model's own fields maps, keyed by field name. */
+function getOwnFieldColumns(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"ownFieldColumns",
+		namespaceId,
+		modelName
+	], () => {
+		const storageFields = modelsOf(contract, namespaceId)[modelName]?.storage?.fields ?? {};
+		const columns = {};
+		for (const [field, storage] of Object.entries(storageFields)) if (storage?.column) columns[field] = storage.column;
+		return columns;
+	});
 }
 /**
-* 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.
+* A model's fields, keyed by field name, with the table and column each maps: its own fields on its own table, and the fields it inherits from its base model on the base model's table. This is the one list of a model's fields; a column no field maps has no entry.
+*/
+function getModelFields(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"modelFields",
+		namespaceId,
+		modelName
+	], () => {
+		const model = modelOf(contract, namespaceId, modelName);
+		const table = model?.storage?.table;
+		const own = table === void 0 ? {} : Object.fromEntries(Object.entries(getOwnFieldColumns(contract, namespaceId, modelName)).map(([field, column]) => [field, {
+			table,
+			column
+		}]));
+		const base = model?.base;
+		return {
+			...base === void 0 ? {} : getModelFields(contract, base.namespace, base.model),
+			...own
+		};
+	});
+}
+/** The column each of a model's own and inherited fields maps, keyed by field name. */
+function getModelFieldColumns(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"modelFieldColumns",
+		namespaceId,
+		modelName
+	], () => Object.fromEntries(Object.entries(getModelFields(contract, namespaceId, modelName)).map(([field, { column }]) => [field, column])));
+}
+/**
+* The column each field of the model and of the variant `variantName` maps, keyed by field name. Without a variant, the model's fields alone.
 *
-* 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.
+* A surface accepts a variant's field only when it can place that field's column on the variant's table. A collection narrowed to a variant reads that variant's table, so `select`, the `where` and `orderBy` accessor and a variant create accept the narrowed variant's fields. A collection that is not narrowed reads the base table only, so only `select`, whose polymorphic projection joins each variant's table, accepts variant fields there (`getModelAndEveryVariantFieldColumns`).
+*/
+function getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantName) {
+	return cachedFor(contract, [
+		"modelAndVariantFieldColumns",
+		namespaceId,
+		modelName,
+		variantName ?? null
+	], () => ({
+		...variantName === void 0 ? {} : getOwnFieldColumns(contract, namespaceId, variantName),
+		...getModelFieldColumns(contract, namespaceId, modelName)
+	}));
+}
+/**
+* Every column each field of the model and of every one of its variants maps, keyed by field name. Two variants may map one field name to different columns, so a name can map several columns.
+*/
+function getModelAndEveryVariantFieldColumns(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"modelAndEveryVariantFieldColumns",
+		namespaceId,
+		modelName
+	], () => {
+		const columns = {};
+		const add = (fieldColumns) => {
+			for (const [field, column] of Object.entries(fieldColumns)) {
+				const existing = columns[field] ?? [];
+				if (!existing.includes(column)) existing.push(column);
+				columns[field] = existing;
+			}
+		};
+		add(getModelFieldColumns(contract, namespaceId, modelName));
+		const modelFields = new Set(Object.keys(columns));
+		for (const variant of resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.keys() ?? []) add(Object.fromEntries(Object.entries(getOwnFieldColumns(contract, namespaceId, variant)).filter(([field]) => !modelFields.has(field))));
+		return columns;
+	});
+}
+/** The field each column of the model's own fields maps, keyed by column. */
+function getOwnColumnFields(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"ownColumnFields",
+		namespaceId,
+		modelName
+	], () => invert(getOwnFieldColumns(contract, namespaceId, modelName)));
+}
+/** The field each column of the model's own and inherited fields maps, keyed by column. */
+function getModelColumnFields(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"modelColumnFields",
+		namespaceId,
+		modelName
+	], () => invert(getModelFieldColumns(contract, namespaceId, modelName)));
+}
+function invert(map) {
+	return Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
+}
+/**
+* The column a name a caller passed maps in `fieldColumns`. A name that is not a field is refused with `ORM.FIELD_UNKNOWN`, so no caller reaches a column by its column name, including a column no field maps.
+*/
+function columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName) {
+	const column = Object.hasOwn(fieldColumns, fieldName) ? fieldColumns[fieldName] : void 0;
+	if (column === void 0) throw callerFieldUnknown(contract, namespaceId, fieldColumns, modelName, fieldName);
+	return column;
+}
+/**
+* The refusal of a name a caller passed that is not a field of the model it addressed. When the name is the column of one of the fields in `fieldColumns`, or a column that no field maps on a table of the model's hierarchy, the message says so and names the table.
+*/
+function callerFieldUnknown(contract, namespaceId, fieldColumns, modelName, fieldName) {
+	const unknown = `Model "${modelName}" has no field "${fieldName}"`;
+	const fieldForColumn = Object.entries(fieldColumns).find(([, columns]) => typeof columns === "string" ? columns === fieldName : columns.includes(fieldName))?.[0];
+	if (fieldForColumn !== void 0) return ormError("ORM.FIELD_UNKNOWN", `${unknown}. "${fieldName}" is the column of field "${fieldForColumn}"; pass the field name.`, { meta: {
+		model: modelName,
+		field: fieldName,
+		fieldForColumn
+	} });
+	const unmapped = getUnmappedColumns(contract, namespaceId, modelName).find(({ column }) => column === fieldName);
+	return ormError("ORM.FIELD_UNKNOWN", `${unknown}${unmapped === void 0 ? "" : `. Table "${unmapped.table}" has a column "${fieldName}" that no field maps, so the ORM cannot read or write it.`}`, { meta: {
+		model: modelName,
+		field: fieldName
+	} });
+}
+/** The columns of the tables of a model's hierarchy that no field of the hierarchy maps. */
+function getUnmappedColumns(contract, namespaceId, modelName) {
+	return cachedFor(contract, [
+		"unmappedColumns",
+		namespaceId,
+		modelName
+	], () => {
+		const root = hierarchyRootName(contract, namespaceId, modelName);
+		const rootTable = domainModelTableInNamespace(contract, namespaceId, root);
+		if (rootTable === void 0) return [];
+		const variants = resolvePolymorphismInfo(contract, namespaceId, root)?.variants.values();
+		return [.../* @__PURE__ */ new Set([rootTable, ...[...variants ?? []].map((variant) => variant.table)])].flatMap((table) => {
+			const read = new Set(getColumnsReadOnTable(contract, namespaceId, root, table));
+			return getAllTableColumns(contract, namespaceId, table).filter((column) => !read.has(column)).map((column) => ({
+				table,
+				column
+			}));
+		});
+	});
+}
+function hierarchyRootName(contract, namespaceId, modelName) {
+	const base = modelOf(contract, namespaceId, modelName)?.base;
+	return base === void 0 || base.namespace !== namespaceId ? modelName : hierarchyRootName(contract, namespaceId, base.model);
+}
+/**
+* The column a field name the contract itself gives maps among the model's own and inherited fields, such as a relation's join field or a discriminator. The contract was validated, so a name that is not a field is an internal error.
+*/
+function columnOfContractField(contract, namespaceId, modelName, fieldName) {
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
+	const column = Object.hasOwn(fieldColumns, fieldName) ? fieldColumns[fieldName] : void 0;
+	if (column === void 0) throw new InternalError(`Model "${modelName}" has no field "${fieldName}" the contract names`);
+	return column;
+}
+/**
+* The field that maps `column` in `columnFields`. The ORM only asks this for a column it chose itself, such as a key column or a column it projected, so a column no field maps is an internal error.
+*/
+function fieldOfColumn(columnFields, modelName, column) {
+	const field = Object.hasOwn(columnFields, column) ? columnFields[column] : void 0;
+	if (field === void 0) throw new InternalError(`Column "${column}" of model "${modelName}" is mapped by no field`);
+	return field;
+}
+/**
+* The columns a relation's target fields name. A relation through a junction table names the junction's columns there, not fields of the target model.
+*/
+function resolveRelationTargetColumns(contract, relation) {
+	if (relation.through !== void 0) return [...relation.on.targetFields];
+	return relation.on.targetFields.map((field) => columnOfContractField(contract, relation.toNamespace, relation.to, field));
+}
+/**
+* The fields a multi-table variant declares, with the table and column each maps, which is the variant's own table the read path joins. A single-table variant's columns are on the base table, and inherited fields are on the base model's table, so neither appears here.
 */
 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;
+	if (variant?.strategy !== "mti") return {};
+	return Object.fromEntries(Object.entries(getModelFields(contract, namespaceId, variant.modelName)).filter(([, field]) => field.table === variant.table));
 }
-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);
+/** Every column of a table, in table order. */
+function getAllTableColumns(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
+		} });
 	}
-	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();
+function isMultiTableVariantTable(contract, namespaceId, modelName, tableName) {
+	const base = modelOf(contract, namespaceId, modelName)?.base;
+	return base !== void 0 && domainModelTableInNamespace(contract, namespaceId, modelName) === tableName && domainModelTableInNamespace(contract, base.namespace, base.model) !== tableName;
+}
 /**
-* Like getColumnToFieldMap, but a field without a storage `column` maps under its own name.
+* The columns of `tableName` a query on `modelName` reads, in table order: the columns on that table of the model's own and inherited fields and of its variants' fields, and, on a multi-table variant's table, the key the variant inherits. Any other column of the table is storage the model does not map, and the ORM never reads it into a row.
 */
-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 getColumnsReadOnTable(contract, namespaceId, modelName, tableName) {
+	return cachedFor(contract, [
+		"columnsReadOnTable",
+		namespaceId,
+		modelName,
+		tableName
+	], () => {
+		const read = /* @__PURE__ */ new Set();
+		const addFieldsOnTable = (name) => {
+			for (const field of Object.values(getModelFields(contract, namespaceId, name))) if (field.table === tableName) read.add(field.column);
+		};
+		const addInheritedKey = () => {
+			for (const column of resolvePrimaryKeyColumns(contract, namespaceId, tableName)) read.add(column);
+		};
+		addFieldsOnTable(modelName);
+		if (isMultiTableVariantTable(contract, namespaceId, modelName, tableName)) addInheritedKey();
+		const variants = resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.values();
+		for (const variant of variants ?? []) {
+			if (variant.table !== tableName) continue;
+			addFieldsOnTable(variant.modelName);
+			if (variant.strategy === "mti") addInheritedKey();
+		}
+		return getAllTableColumns(contract, namespaceId, tableName).filter((column) => read.has(column));
+	});
+}
+/** The model a query or write addresses: the variant it is narrowed to, otherwise the collection's model. */
+function addressedModelName(modelName, variantName) {
+	return variantName ?? modelName;
 }
 function resolveIncludeRelation(contract, namespaceId, baseModelName, relationName, variantName) {
 	const polymorphism = resolvePolymorphismInfo(contract, namespaceId, baseModelName);
@@ -212,22 +378,24 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 	let localTableName = resolveModelTableName(contract, namespaceId, baseModelName);
 	let relation;
 	if (variant !== void 0) {
-		const candidate = resolveModelRelations(contract, namespaceId, variant.modelName)[relationName];
+		const variantRelations = resolveModelRelations(contract, namespaceId, variant.modelName);
+		const candidate = Object.hasOwn(variantRelations, relationName) ? variantRelations[relationName] : void 0;
 		if (candidate !== void 0) {
 			relation = candidate;
 			declaringModelName = variant.modelName;
 			localTableName = variant.table;
 		}
 	}
-	relation ??= resolveModelRelations(contract, namespaceId, baseModelName)[relationName];
+	const baseRelations = resolveModelRelations(contract, namespaceId, baseModelName);
+	relation ??= Object.hasOwn(baseRelations, relationName) ? baseRelations[relationName] : void 0;
 	if (!relation) throw ormError("ORM.RELATION_UNKNOWN", `Relation '${relationName}' not found on model '${baseModelName}'`, { meta: {
 		model: baseModelName,
 		relation: relationName
 	} });
 	const { localFields, targetFields } = relation.on;
 	if (localFields.length === 0 || localFields.length !== targetFields.length) throw new InternalError(`Relation '${relationName}' on model '${declaringModelName}' has incomplete join metadata: ${localFields.length} local field(s), ${targetFields.length} target field(s)`);
-	const localColumns = localFields.map((field) => resolveFieldToColumn(contract, namespaceId, declaringModelName, field));
-	const targetColumns = targetFields.map((field) => resolveFieldToColumn(contract, relation.toNamespace, relation.to, field));
+	const localColumns = localFields.map((field) => columnOfContractField(contract, namespaceId, declaringModelName, field));
+	const targetColumns = resolveRelationTargetColumns(contract, relation);
 	const relatedTableName = resolveModelTableName(contract, relation.toNamespace, relation.to);
 	let through;
 	if (relation.through !== void 0) through = {
@@ -307,7 +475,8 @@ function parseRelationCardinality(value) {
 }
 function resolveUpsertConflictColumns(contract, namespaceId, modelName, conflictOn) {
 	if (conflictOn && typeof conflictOn === "object") {
-		const columns = Object.keys(conflictOn).map((fieldName) => resolveFieldToColumn(contract, namespaceId, modelName, fieldName));
+		const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
+		const columns = Object.keys(conflictOn).map((fieldName) => columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName));
 		if (columns.length > 0) return columns;
 	}
 	return [...storageTableForContract(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName)).primaryKey?.columns ?? []];
@@ -352,17 +521,9 @@ function requireCapability(contract, action, capability) {
 		action
 	} });
 }
-function resolveInsertConflictColumns(contract, namespaceId, modelName, conflictOn, action) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	return conflictOn.map((fieldName) => {
-		const column = fieldToColumn[fieldName];
-		if (column === void 0) throw ormError("ORM.ARGUMENT_INVALID", `${action} conflictOn field "${fieldName}" is not a scalar field of model "${modelName}"`, { meta: {
-			action,
-			model: modelName,
-			field: fieldName
-		} });
-		return column;
-	});
+function resolveInsertConflictColumns(contract, namespaceId, modelName, conflictOn) {
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
+	return conflictOn.map((fieldName) => columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName));
 }
 function assertDistinctOnCapability(contract, methodName) {
 	if (contract.capabilities["postgres"]?.["distinctOn"] === true) return;
@@ -405,10 +566,10 @@ function isToOneCardinality(cardinality) {
 * to the same registry.
 */
 function createAggregateBuilder(contract, aggregates, namespaceId, modelName) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
 	const builder = {};
 	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
-		const column = field === void 0 ? void 0 : fieldToColumn[field] ?? field;
+		const column = field === void 0 ? void 0 : columnOfCallerField(contract, namespaceId, fieldColumns, modelName, field);
 		return {
 			kind: "aggregate",
 			fn: operation,
@@ -486,41 +647,48 @@ function inputCodecRef(query) {
 function emptyAggregateResult(result, codec) {
 	return result.nullable ? null : codec.decodeJson(result.emptyResultJson);
 }
+/** The columns of a model's own and inherited fields, for operations that apply each column to the model's table: `groupBy`, `distinct` and `distinctOn`. */
 function mapFieldsToColumns(contract, namespaceId, modelName, fieldNames) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
-	return fieldNames.map((fieldName) => fieldToColumn[fieldName] ?? fieldName);
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
+	return fieldNames.map((fieldName) => columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName));
+}
+/** The columns a `select` names: the narrowed variant's fields too, or, when the collection is not narrowed, every variant's fields, each name reading every column a variant maps it to. See `getModelAndVariantFieldColumns` for why `select` accepts more than other surfaces. */
+function mapSelectedFieldsToColumns(contract, namespaceId, modelName, variantName, fieldNames) {
+	const addressed = addressedModelName(modelName, variantName);
+	if (variantName !== void 0) {
+		const fieldColumns = getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantName);
+		return fieldNames.map((fieldName) => columnOfCallerField(contract, namespaceId, fieldColumns, addressed, fieldName));
+	}
+	const fieldColumns = getModelAndEveryVariantFieldColumns(contract, namespaceId, modelName);
+	return fieldNames.flatMap((fieldName) => {
+		const columns = Object.hasOwn(fieldColumns, fieldName) ? fieldColumns[fieldName] : void 0;
+		if (columns === void 0) throw callerFieldUnknown(contract, namespaceId, fieldColumns, addressed, fieldName);
+		return [...columns];
+	});
 }
 function mapCursorValuesToColumns(contract, namespaceId, modelName, cursorValues) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelFieldColumns(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;
+		mappedCursor[columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName)] = value;
 	}
 	return mappedCursor;
 }
 function stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns) {
 	if (hiddenColumns.length === 0) return;
-	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
+	const columnToField = getModelColumnFields(contract, namespaceId, modelName);
 	for (const hiddenColumn of hiddenColumns) {
-		const fieldName = columnToField[hiddenColumn] ?? hiddenColumn;
-		delete mapped[fieldName];
+		const fieldName = Object.hasOwn(columnToField, hiddenColumn) ? columnToField[hiddenColumn] : void 0;
+		if (fieldName !== void 0) delete mapped[fieldName];
 	}
 }
 function mapStorageRowToModelFields(contract, namespaceId, modelName, row) {
-	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
-	if (Object.keys(columnToField).length === 0) return { ...row };
-	return mapColumnNames(row, columnToField);
+	return mapKnownColumnNames(row, getModelColumnFields(contract, namespaceId, modelName));
 }
 function createStorageRowMapper(contract, namespaceId, modelName) {
-	const columnToField = getColumnToFieldMap(contract, namespaceId, modelName);
-	return Object.keys(columnToField).length === 0 ? (row) => ({ ...row }) : (row) => mapColumnNames(row, columnToField);
-}
-function mapColumnNames(row, columnToField) {
-	const mapped = {};
-	for (const [columnName, value] of Object.entries(row)) mapped[columnToField[columnName] ?? columnName] = value;
-	return mapped;
+	const columnToField = getModelColumnFields(contract, namespaceId, modelName);
+	return (row) => mapKnownColumnNames(row, columnToField);
 }
 const mergedColumnToFieldCache = /* @__PURE__ */ new WeakMap();
 function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variantModelName, variantTable) {
@@ -532,8 +700,8 @@ function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant
 	}
 	const cached = perContract.get(cacheKey);
 	if (cached) return cached;
-	const baseMap = getCompleteColumnToFieldMap(contract, namespaceId, baseModelName);
-	const variantMap = getCompleteColumnToFieldMap(contract, namespaceId, variantModelName);
+	const baseMap = getModelColumnFields(contract, namespaceId, baseModelName);
+	const variantMap = getOwnColumnFields(contract, namespaceId, variantModelName);
 	const merged = { ...baseMap };
 	for (const [col, field] of Object.entries(variantMap)) if (variantTable) merged[`${variantTable}__${col}`] = field;
 	else merged[col] = field;
@@ -543,12 +711,12 @@ function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant
 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) return mapKnownColumnNames(row, getCompleteColumnToFieldMap(contract, namespaceId, baseModelName));
+	if (!variant) return mapKnownColumnNames(row, getModelColumnFields(contract, namespaceId, baseModelName));
 	const mtiTable = variant.strategy === "mti" ? variant.table : void 0;
 	return mapKnownColumnNames(row, getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, mtiTable));
 }
 function createPolymorphicRowMapper(contract, namespaceId, baseModelName, polyInfo, variantName) {
-	const baseMapper = captureColumnMapper(() => getCompleteColumnToFieldMap(contract, namespaceId, baseModelName));
+	const baseMapper = captureColumnMapper(() => getModelColumnFields(contract, namespaceId, baseModelName));
 	const mappersByValue = /* @__PURE__ */ new Map();
 	let pinnedMapper = baseMapper;
 	for (const [name, variant] of polyInfo.variants) {
@@ -573,21 +741,26 @@ function captureColumnMapper(resolve) {
 		};
 	}
 }
+/** Maps a row from columns to fields. A column no field maps is dropped. */
 function mapKnownColumnNames(row, columns) {
 	const mapped = {};
 	for (const [col, val] of Object.entries(row)) {
-		const field = columns[col];
+		const field = Object.hasOwn(columns, col) ? columns[col] : void 0;
 		if (field !== void 0) mapped[field] = val;
 	}
 	return mapped;
 }
+/** Refuses any name in `data` with a value that is not a field of the model, as `mapModelDataToStorageRow` would, before anything reads or writes a row. */
+function assertModelFieldNames(contract, namespaceId, modelName, data) {
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
+	for (const [fieldName, value] of Object.entries(data)) if (value !== void 0) columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName);
+}
 function mapModelDataToStorageRow(contract, namespaceId, modelName, row) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelFieldColumns(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;
+		mapped[columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName)] = value;
 	}
 	return mapped;
 }
@@ -647,17 +820,6 @@ function checkedOrderByItem(dir, expr, options) {
 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 {
@@ -973,7 +1135,7 @@ function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedCol
 		const joinOn = buildPrimaryKeyJoinOn(polyInfo.baseTable, variant.table, pkColumns);
 		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 variantColumns = getColumnsReadOnTable(contract, namespaceId, variant.modelName, variant.table);
 		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
 		for (const col of variantColumns) {
 			if (pkColumns.includes(col)) continue;
@@ -1303,8 +1465,8 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, p
 	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 buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns) {
+	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : getColumnsReadOnTable(contract, namespaceId, modelName, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
 }
 function toParamAssignments(contract, namespaceId, tableName, values) {
 	const assignments = {};
@@ -1360,9 +1522,9 @@ function conflictSkipClause(tableName, conflictSkip) {
 	if (conflictSkip.columns.length === 0) return InsertOnConflict.doNothing();
 	return InsertOnConflict.on(conflictSkip.columns.map((column) => ColumnRef.of(tableName, column))).doNothing();
 }
-function compileInsertReturning(contract, namespaceId, tableName, rows, returningColumns, conflictSkip) {
+function compileInsertReturning(contract, namespaceId, modelName, tableName, rows, returningColumns, conflictSkip) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withOnConflict(conflictSkipClause(tableName, conflictSkip)).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withOnConflict(conflictSkipClause(tableName, conflictSkip)).withReturning(buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1419,13 +1581,13 @@ function groupRowsByColumnSignature(rows) {
 	if (currentGroup.length > 0) groups.push(currentGroup);
 	return groups;
 }
-function compileInsertReturningSplit(contract, namespaceId, tableName, rows, returningColumns, conflictSkip) {
+function compileInsertReturningSplit(contract, namespaceId, modelName, tableName, rows, returningColumns, conflictSkip) {
 	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, conflictSkip));
+	return groupRowsByColumnSignature(rows).map((group) => compileInsertReturning(contract, namespaceId, modelName, tableName, group, returningColumns, conflictSkip));
 }
 function compileInsertCountSplit(contract, namespaceId, tableName, rows, conflictSkip) {
 	if (rows.length === 0) throw ormError("ORM.MUTATION_DATA_MISSING", "createAndCount() requires at least one row", { meta: {
@@ -1435,18 +1597,18 @@ function compileInsertCountSplit(contract, namespaceId, tableName, rows, conflic
 	} });
 	return groupRowsByColumnSignature(rows).map((group) => compileInsertCount(contract, namespaceId, tableName, group, conflictSkip));
 }
-function compileUpsertReturning(contract, namespaceId, tableName, createValues, updateValues, conflictColumns, returningColumns) {
+function compileUpsertReturning(contract, namespaceId, modelName, 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 ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileUpdateReturning(contract, namespaceId, tableName, setValues, filters, returningColumns) {
+function compileUpdateReturning(contract, namespaceId, modelName, 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));
+	let ast = UpdateAst.table(tableSourceForContract(contract, namespaceId, tableName)).withSet(assignments).withReturning(buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
@@ -1459,9 +1621,9 @@ function compileUpdateCount(contract, namespaceId, tableName, setValues, filters
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileDeleteReturning(contract, namespaceId, tableName, filters, returningColumns) {
+function compileDeleteReturning(contract, namespaceId, modelName, tableName, filters, returningColumns) {
 	const where = combineWhereExprs(filters);
-	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName)).withReturning(buildReturningColumns(contract, namespaceId, tableName, returningColumns));
+	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName)).withReturning(buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
@@ -1542,8 +1704,8 @@ function jsonEntryProjection(value, identity) {
 	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 buildProjection(contract, namespaceId, modelName, tableName, selectedFields, tableRef = tableName) {
+	return (selectedFields !== void 0 ? [...selectedFields] : getColumnsReadOnTable(contract, namespaceId, modelName, 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);
@@ -1554,22 +1716,21 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 		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) => ({
+	const baseColumnToField = getModelColumnFields(contract, namespaceId, modelName);
+	const variantColumnMaps = Array.from(polyInfo.variants.values(), (variant) => ({
 		variant,
-		columnToField: getCompleteColumnToFieldMap(contract, namespaceId, variant.modelName)
+		columnToField: getOwnColumnFields(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;
+	for (const column of state.selectedFields) {
+		const isBaseColumn = Object.hasOwn(baseColumnToField, column);
+		if (isBaseColumn) appendUnique(baseSelectedFields, column);
+		let isVariantColumn = false;
+		for (const { variant, columnToField } of variantColumnMaps) {
+			if (!Object.hasOwn(columnToField, column)) continue;
+			isVariantColumn = true;
 			hasVariantOwnedSelection = true;
 			if (variant.strategy === "sti") {
 				appendUnique(baseSelectedFields, column);
@@ -1582,7 +1743,7 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 			}
 			selectedColumns.add(column);
 		}
-		if (baseColumn === void 0 && !matchedVariantField) appendUnique(baseSelectedFields, selectedField);
+		if (!isBaseColumn && !isVariantColumn) throw new InternalError(`Selected column "${column}" is mapped by no field of model "${modelName}" or its variants; select() resolves field names before they reach the projection`);
 	}
 	return {
 		baseSelectedFields,
@@ -1792,7 +1953,7 @@ function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include
 		junctionJoins
 	});
 	const polyJoinsAndProjection = buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef);
-	const scalarProjection = buildProjection(contract, include.relatedNamespaceId, include.relatedTableName, polyJoinsAndProjection.baseSelectedFields, childTableRef);
+	const scalarProjection = buildProjection(contract, include.relatedNamespaceId, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName, polyJoinsAndProjection.baseSelectedFields, childTableRef);
 	const nestedProjections = buildNestedIncludeProjections(contract, aggregates, {
 		baseTableName: include.relatedTableName,
 		tableRef: childTableRef,
@@ -1843,7 +2004,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 			selectedFields: selectedForQuery
 		}
 	}, childTableAlias, childTableRef);
-	const innerScalarProjection = buildProjection(contract, include.relatedNamespaceId, include.relatedTableName, queryPolyProjection.baseSelectedFields, childTableRef);
+	const innerScalarProjection = buildProjection(contract, include.relatedNamespaceId, addressedModelName(include.relatedModelName, include.nested.variantName), 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,
@@ -1866,7 +2027,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 	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 outerScalarProjection = buildProjection(contract, include.relatedNamespaceId, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName, visiblePolyProjection.baseSelectedFields, distinctAlias);
 	const outerNestedProjections = buildNestedIncludeProjections(contract, aggregates, {
 		baseTableName: include.relatedTableName,
 		tableRef: distinctAlias,
@@ -2063,14 +2224,15 @@ function buildCorrelatedIncludeProjection(contract, aggregates, parentSource, in
 	const aggregateQuery = buildIncludeChildRowsAggregateSelect(contract, aggregates, parentSource, include);
 	return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(aggregateQuery)) };
 }
-function buildSelectAst(contract, tableName, state, options) {
+function buildSelectAst(contract, modelName, tableName, state, options) {
 	const namespaceId = options.namespaceId;
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
 	}
-	const projection = [...buildProjection(contract, namespaceId, tableName, state.selectedFields, tableName), ...options.includeProjection ?? []];
-	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, options.where ?? buildStateWhere(contract, tableName, state, { namespaceId }), resolveTableColumns(contract, namespaceId, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))));
+	const addressed = addressedModelName(modelName, state.variantName);
+	const projection = [...buildProjection(contract, namespaceId, addressed, tableName, state.selectedFields, tableName), ...options.includeProjection ?? []];
+	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, options.where ?? buildStateWhere(contract, tableName, state, { namespaceId }), getColumnsReadOnTable(contract, namespaceId, addressed, tableName).map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))));
 	let ast = SelectAst.from(fromSource).withProjection(projection);
 	if (effectiveWhere) ast = ast.withWhere(effectiveWhere);
 	if (state.orderBy) ast = ast.withOrderBy(state.orderBy);
@@ -2082,18 +2244,18 @@ function buildSelectAst(contract, tableName, state, options) {
 	if (state.locking !== void 0) ast = ast.withLocking(state.locking);
 	return ast;
 }
-function compileSelect(contract, namespaceId, tableName, state, modelName) {
+function compileSelect(contract, namespaceId, modelName, tableName, state) {
 	assertLockCompatible(state);
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
-	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const selection = polyInfo && modelName ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	const selection = polyInfo ? 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, {
+	const ast = buildSelectAst(contract, modelName, tableName, {
 		...projectionState,
 		includes: []
 	}, {
@@ -2104,13 +2266,13 @@ function compileSelect(contract, namespaceId, tableName, state, modelName) {
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params, state.annotations);
 }
-function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName, state, modelName) {
+function compileSelectWithIncludes(contract, aggregates, namespaceId, modelName, tableName, state) {
 	assertLockCompatible(state);
 	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 polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	const selection = polyInfo ? resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) : void 0;
 	const projectionState = selection ? {
 		...state,
 		selectedFields: selection.baseSelectedFields
@@ -2132,7 +2294,7 @@ function compileSelectWithIncludes(contract, aggregates, namespaceId, tableName,
 		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, parentSource, include);
 		includeProjection.push(artifact.projection);
 	}
-	const ast = buildSelectAst(contract, tableName, {
+	const ast = buildSelectAst(contract, modelName, tableName, {
 		...projectionState,
 		includes: []
 	}, {
@@ -2158,7 +2320,7 @@ function describeExecutionRows(options) {
 	const { contract } = context;
 	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
 	if (state.includes.length === 0) {
-		const compiled = compileSelect(contract, namespaceId, tableName, state, modelName);
+		const compiled = compileSelect(contract, namespaceId, modelName, tableName, state);
 		const mapper = polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, rawRow, state.variantName)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow));
 		return {
 			plan: compiled,
@@ -2166,7 +2328,7 @@ function describeExecutionRows(options) {
 		};
 	}
 	return {
-		plan: compileSelectWithIncludes(contract, context.aggregateDescriptors, namespaceId, tableName, state, modelName),
+		plan: compileSelectWithIncludes(contract, context.aggregateDescriptors, namespaceId, modelName, tableName, state),
 		consume: (rows) => consumeIncludeRows(context, state, namespaceId, modelName, rows)
 	};
 }
@@ -2231,10 +2393,10 @@ function createPreparedIncludeConsumer(context, include) {
 	}
 	const mapRow = createPreparedMapper(contract, include.relatedNamespaceId, include.relatedModelName, include.nested.variantName);
 	const bindings = deferResolution(() => {
-		const tables = contract.storage.namespaces[include.relatedNamespaceId]?.entries.table;
-		const keys = new Set(Object.keys(tables?.[include.relatedTableName]?.columns ?? {}));
-		const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
-		for (const variant of polyInfo?.mtiVariants ?? []) for (const column of Object.keys(tables?.[variant.table]?.columns ?? {})) keys.add(`${variant.table}__${column}`);
+		const namespace = include.relatedNamespaceId;
+		const keys = new Set(getColumnsReadOnTable(contract, namespace, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName));
+		const polyInfo = resolvePolymorphismInfo(contract, namespace, include.relatedModelName);
+		for (const variant of polyInfo?.mtiVariants ?? []) for (const column of getColumnsReadOnTable(contract, namespace, variant.modelName, variant.table)) keys.add(`${variant.table}__${column}`);
 		return new Map([...keys].map((key) => [key, deferResolution(() => resolveIncludedColumnBinding(contract, context, include, key))]));
 	});
 	const bindingFor = (key) => bindings().get(key)?.() ?? null;
@@ -2261,19 +2423,19 @@ function createPreparedIncludedRowDecoder(contract, include, bindingFor) {
 	const namespace = include.relatedNamespaceId;
 	const model = include.relatedModelName;
 	if (resolvePolymorphismInfo(contract, namespace, model)) return void 0;
-	const fieldToColumn = getFieldToColumnMap(contract, namespace, model);
-	const columnToField = getColumnToFieldMap(contract, namespace, model);
-	const columns = (include.nested.selectedFields ?? Object.keys(fieldToColumn)).map((field) => Object.hasOwn(fieldToColumn, field) ? fieldToColumn[field] ?? field : field);
+	const columnToField = getModelColumnFields(contract, namespace, model);
+	const columns = include.nested.selectedFields ?? getColumnsReadOnTable(contract, namespace, model, include.relatedTableName);
 	const aliases = include.nested.includes.map((child) => child.relationName);
 	const table = contract.storage.namespaces[namespace]?.entries.table?.[include.relatedTableName];
 	if (aliases.some((alias) => table?.columns[alias] !== void 0)) return void 0;
 	const keys = [...columns, ...aliases];
 	if (keys.includes("__proto__") || new Set(keys).size !== keys.length) return void 0;
+	const fieldOf = (key) => aliases.includes(key) ? key : fieldOfColumn(columnToField, model, key);
 	const operations = keys.map((key) => {
 		const binding = deferResolution(() => bindingFor(key));
 		return {
 			key,
-			field: Object.hasOwn(columnToField, key) ? columnToField[key] ?? key : key,
+			field: fieldOf(key),
 			decode(value) {
 				if (value === null || value === void 0) return value;
 				const resolved = binding();
@@ -2766,12 +2928,11 @@ function all() {
 function shorthandToWhereExpr(context, namespaceId, modelName, filters) {
 	const contract = context.contract;
 	const tableName = resolveModelTableName(contract, namespaceId, modelName);
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelFieldColumns(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);
+		const left = ColumnRef.of(tableName, columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName));
 		if (value === null) {
 			exprs.push(NullCheckExpr.isNull(left));
 			continue;
@@ -2931,7 +3092,7 @@ function assertDeclaredFieldsFragmentFields(collection, fields) {
 	const { contract } = collection.ctx.context;
 	const { modelName, namespaceId } = collection;
 	const label = modelLabel(collection);
-	const model = modelOf(contract, namespaceId, modelName);
+	const modelFields = getModelFields(contract, namespaceId, modelName);
 	for (const [name, spec] of fields) {
 		const declared = `The fragment was declared for models that have a ${spec.many === false ? "field" : "list field"} ${name} ${describeField(spec)}.`;
 		const meta = {
@@ -2942,14 +3103,14 @@ function assertDeclaredFieldsFragmentFields(collection, fields) {
 			nullable: spec.nullable,
 			many: spec.many
 		};
-		const modelFields = model?.fields ?? {};
-		if (!Object.hasOwn(modelFields, name)) throw ormError("ORM.FIELD_UNKNOWN", `Cannot apply a fragment to ${label}: it has no field ${name}`, {
+		const fieldColumn = Object.hasOwn(modelFields, name) ? modelFields[name] : void 0;
+		if (fieldColumn === void 0) throw ormError("ORM.FIELD_UNKNOWN", `Cannot apply a fragment to ${label}: it has no field ${name}`, {
 			why: declared,
 			fix: `Apply the fragment to a model that has a field ${name}, or remove ${name} from the declaration in the fragment.`,
 			meta
 		});
-		const fieldMany = multiplicity(modelFields[name]?.many);
-		const column = resolveColumn(contract, namespaceId, collection.tableName, resolveFieldToColumn(contract, namespaceId, modelName, name));
+		const fieldMany = multiplicity(domainFieldOf(contract, namespaceId, modelName, name)?.many);
+		const column = resolveColumn(contract, namespaceId, fieldColumn.table, fieldColumn.column);
 		const actual = column === void 0 ? `${label}.${name} has no column.` : fieldMany === false ? `${label}.${name} has codec ${column.codecId} and ${nullability(column.nullable)}.` : `${label}.${name} is a list ${describeField({
 			codecId: column.codecId,
 			nullable: column.nullable,
@@ -2998,23 +3159,35 @@ function cutNote(subject, value) {
 }
 function fieldCodecId(collection, field) {
 	const { contract } = collection.ctx.context;
-	const column = resolveFieldToColumn(contract, collection.namespaceId, collection.modelName, field);
-	return resolveColumn(contract, collection.namespaceId, collection.tableName, column)?.codecId;
+	const modelFields = getModelFields(contract, collection.namespaceId, collection.modelName);
+	const fieldColumn = Object.hasOwn(modelFields, field) ? modelFields[field] : void 0;
+	if (fieldColumn === void 0) return void 0;
+	return resolveColumn(contract, collection.namespaceId, fieldColumn.table, fieldColumn.column)?.codecId;
+}
+/** The domain declaration of a model's own or inherited field. */
+function domainFieldOf(contract, namespaceId, modelName, name) {
+	let model = modelOf(contract, namespaceId, modelName);
+	while (model !== void 0) {
+		const fields = model.fields ?? {};
+		if (Object.hasOwn(fields, name)) return fields[name];
+		const base = model.base;
+		model = base === void 0 ? void 0 : modelOf(contract, base.namespace, base.model);
+	}
 }
 function canOrder(collection, field) {
 	const codecId = fieldCodecId(collection, field);
 	return codecId !== void 0 && hasTrait(collection.ctx.context, codecId, "order");
 }
 function orderableFieldNames(collection) {
-	const model = modelOf(collection.ctx.context.contract, collection.namespaceId, collection.modelName);
-	return Object.keys(model?.fields ?? {}).filter((field) => canOrder(collection, field));
+	const modelFields = getModelFields(collection.ctx.context.contract, collection.namespaceId, collection.modelName);
+	return Object.keys(modelFields).filter((field) => canOrder(collection, field));
 }
 function whyNotOrderable(collection, name) {
 	const { modelName } = collection;
 	const model = modelOf(collection.ctx.context.contract, collection.namespaceId, modelName);
 	const quoted = shown(name).text;
 	if (Object.hasOwn(model?.relations ?? {}, name)) return `${quoted} is a relation of ${modelName}, not a field.`;
-	if (!Object.hasOwn(model?.fields ?? {}, name)) return `${modelName} has no field ${quoted}.`;
+	if (!Object.hasOwn(getModelFields(collection.ctx.context.contract, collection.namespaceId, modelName), name)) return `${modelName} has no field ${quoted}.`;
 	return canOrder(collection, name) ? `${quoted} is not one of the fields allowed for ordering.` : `The codec ${fieldCodecId(collection, name)} of ${modelName}.${name} cannot be ordered.`;
 }
 /**
@@ -3177,7 +3350,7 @@ function createModelAccessor(context, namespaceId, modelName, variantName) {
 }
 function createModelAccessorInScope(context, namespaceId, modelName, variantName, scope) {
 	const contract = context.contract;
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantName);
 	const tableName = resolveModelTableName(contract, namespaceId, modelName);
 	const modelRelations = resolveModelRelations(contract, namespaceId, modelName);
 	const variantFieldColumns = variantName ? resolveVariantFieldColumns(contract, namespaceId, modelName, variantName) : {};
@@ -3205,20 +3378,23 @@ function createModelAccessorInScope(context, namespaceId, modelName, variantName
 			if (self.traits.every((t) => descriptorTraits.includes(t))) registerOp(descriptor.codecId, op);
 		}
 	}
-	return blindCast(new Proxy({}, { get(_target, prop) {
+	return blindCast(new Proxy({}, { get(target, prop) {
 		if (typeof prop !== "string") return;
-		if (variantCoordinates) {
+		if (variantCoordinates && Object.hasOwn(variantCoordinates.relations, prop)) {
 			const variantRelation = variantCoordinates.relations[prop];
 			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, scope.forJoinedSource(namespaceId, variantCoordinates.tableName), variantRelation);
 		}
-		const relation = modelRelations[prop];
+		const relation = Object.hasOwn(modelRelations, prop) ? modelRelations[prop] : void 0;
 		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, scope, relation);
-		const variantField = variantFieldColumns[prop];
+		const variantField = Object.hasOwn(variantFieldColumns, prop) ? variantFieldColumns[prop] : void 0;
+		if (variantField === void 0 && !Object.hasOwn(fieldColumns, prop)) {
+			if (isProbedByRuntime(prop)) return probedValue(target, prop);
+		}
 		const resolvedTable = variantField?.table ?? tableName;
 		const fieldBinding = scope.forJoinedSource(namespaceId, resolvedTable).current;
-		const columnName = variantField?.column ?? fieldToColumn[prop] ?? prop;
+		const columnName = variantField?.column ?? columnOfCallerField(contract, namespaceId, fieldColumns, addressedModelName(modelName, variantName), prop);
 		const column = resolveColumn(contract, namespaceId, resolvedTable, columnName);
-		if (!column) return;
+		if (!column) throw new InternalError(`Field "${modelName}.${prop}" maps column "${columnName}", which table "${resolvedTable}" does not have`);
 		const traits = codecTraits(context, column.codecId);
 		const operations = opsByCodecId.get(column.codecId) ?? [];
 		const codec = codecRefForStorageColumn(contract.storage, namespaceId, resolvedTable, columnName);
@@ -3278,6 +3454,7 @@ function createRelationFilterAccessor(context, parentNamespaceId, parentModelNam
 		if (typeof prop !== "string") return void 0;
 		if (Object.hasOwn(target, prop)) return Reflect.get(target, prop);
 		if (RELATION_ACCESSOR_METHOD_NAMES.has(prop)) return void 0;
+		if (isProbedByRuntime(prop) && !Object.hasOwn(getModelFieldColumns(context.contract, relation.toNamespace, relation.to), prop)) return probedValue(target, prop);
 		return relatedOrderableField(context, relation, relatedTableName, correlate, prop);
 	} });
 	return {
@@ -3285,6 +3462,15 @@ function createRelationFilterAccessor(context, parentNamespaceId, parentModelNam
 		count: (predicate) => createOrderable(() => buildRelationCountExpr(context, relation, correlate(), predicate))
 	};
 }
+/**
+* Whether the JavaScript runtime or a common library reads `prop` from an object it is handed: `then` when a value is awaited or resolved as a promise, `toJSON` when it is stringified, and the `Object.prototype` members such as `toString`. An accessor answers these like a plain object, so a name that is not a field is refused only when the caller asks for it.
+*/
+function isProbedByRuntime(prop) {
+	return prop === "then" || prop === "toJSON" || prop in Object.prototype;
+}
+function probedValue(target, prop) {
+	return prop === "then" || prop === "toJSON" ? void 0 : Reflect.get(target, prop);
+}
 function createOrderable(buildExpr) {
 	return {
 		asc: (options) => checkedOrderByItem("asc", buildExpr(), options),
@@ -3292,10 +3478,7 @@ function createOrderable(buildExpr) {
 	};
 }
 function relatedOrderableField(context, relation, relatedTableName, correlate, fieldName) {
-	const fieldToColumn = getFieldToColumnMap(context.contract, relation.toNamespace, relation.to);
-	if (!Object.hasOwn(fieldToColumn, fieldName)) return void 0;
-	const columnName = fieldToColumn[fieldName];
-	if (columnName === void 0) return void 0;
+	const columnName = columnOfCallerField(context.contract, relation.toNamespace, getModelFieldColumns(context.contract, relation.toNamespace, relation.to), relation.to, fieldName);
 	const column = resolveColumn(context.contract, relation.toNamespace, relatedTableName, columnName);
 	if (!column || !hasTrait(context, column.codecId, "order")) return void 0;
 	return createOrderable(() => {
@@ -3312,7 +3495,7 @@ function correlateRelatedRows(context, parentNamespaceId, parentModelName, paren
 		const { through } = relation;
 		const { childScope, junctionBinding } = parentScope.forManyToManyRelation(relation.toNamespace, relatedTableName, through.namespaceId, through.table);
 		const junctionJoinOn = buildPairedColumnExprs(junctionBinding, through.childColumns, childScope.current, through.targetColumns);
-		const parentLocalColumns = relation.on.localFields.map((field) => resolveFieldToColumn(context.contract, parentNamespaceId, parentModelName, field));
+		const parentLocalColumns = relation.on.localFields.map((field) => columnOfContractField(context.contract, parentNamespaceId, parentModelName, field));
 		return {
 			childScope,
 			source: SelectAst.from(childScope.current.tableSource(context.contract)).withJoins([JoinAst.inner(junctionBinding.tableSource(context.contract), junctionJoinOn)]),
@@ -3325,7 +3508,7 @@ function correlateRelatedRows(context, parentNamespaceId, parentModelName, paren
 		childScope,
 		source: SelectAst.from(childScope.current.tableSource(context.contract)),
 		correlation: buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentScope.current, childScope.current, relation),
-		keyColumn: firstTargetColumn(context.contract, relation) ?? "id"
+		keyColumn: firstJoinColumn(resolveRelationTargetColumns(context.contract, relation), "targetFields")
 	};
 }
 function buildExistsExpr(context, relation, rows, mode, predicate) {
@@ -3377,14 +3560,12 @@ function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, pred
 	if (!predicate) return;
 	const accessor = createModelAccessorInScope(context, relatedNamespaceId, relatedModelName, void 0, scope);
 	if (typeof predicate === "function") return predicate(accessor);
+	assertModelFieldNames(context.contract, relatedNamespaceId, relatedModelName, predicate);
 	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 (!fieldAccessor) throw new InternalError(`Shorthand filter on "${relatedModelName}.${fieldName}": the field's column is missing from its table`);
 		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());
@@ -3409,8 +3590,8 @@ function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTabl
 		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);
+		const localColumn = columnOfContractField(contract, parentNamespaceId, parentModelName, localField);
+		const targetColumn = columnOfContractField(contract, relation.toNamespace, relation.to, targetField);
 		joinExprs.push(BinaryExpr.eq(relatedTable.column(targetColumn), parentTable.column(localColumn)));
 	}
 	if (joinExprs.length === 0) throw new InternalError("Relation metadata is missing join columns");
@@ -3418,11 +3599,6 @@ function buildJoinWhere(contract, parentNamespaceId, parentModelName, parentTabl
 	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);
-}
 var GroupedCollection = class GroupedCollection {
 	ctx;
 	contract;
@@ -3560,7 +3736,7 @@ var GroupedCollection = class GroupedCollection {
 * dynamic invocation.
 */
 function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
-	const fieldToColumn = getFieldToColumnMap(contract, namespaceId, modelName);
+	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
 	const builder = {};
 	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
 		if (!isAggregateFn(operation)) throw ormError("ORM.AGGREGATE_PROJECTION_ONLY", `Aggregate operation '${operation}' is projection-only: it has no plain SQL form for HAVING, ORDER BY, or comparison positions.`, {
@@ -3568,13 +3744,14 @@ function createHavingBuilder(contract, aggregates, namespaceId, modelName, table
 			fix: `Project '${operation}' in a select and filter or order on the projected value, or use an operation from the SQL aggregate alphabet.`,
 			meta: { operation }
 		});
-		return createHavingComparisonMethods(new AggregateExpr(operation, field === void 0 ? void 0 : ColumnRef.of(tableName, fieldToColumn[field] ?? field)), () => resolveAggregate({
+		const column = field === void 0 ? void 0 : columnOfCallerField(contract, namespaceId, fieldColumns, modelName, field);
+		return createHavingComparisonMethods(new AggregateExpr(operation, column === void 0 ? void 0 : ColumnRef.of(tableName, column)), () => resolveAggregate({
 			aggregates,
 			contract,
 			namespaceId,
 			tableName,
 			fn: operation,
-			column: field === void 0 ? void 0 : fieldToColumn[field] ?? field
+			column
 		}).codec.codecId);
 	};
 	return blindCast(builder);
@@ -3781,7 +3958,7 @@ async function updateFirstGraph(scope, context, namespaceId, modelName, filters,
 		for (const def of appliedUpdateDefaults) mappedUpdateData[def.field] = def.value;
 		const identityWhere = shorthandToWhereExpr(context, namespaceId, modelName, castAs(buildRowIdentityFilterFromRow(contract, namespaceId, modelName, existingRow)));
 		if (!identityWhere) throw new InternalError(`Failed to build row identity filter for model "${modelName}"`);
-		const updatedRaw = (await queryPlanRows(scope, compileUpdateReturning(contract, namespaceId, tableName, mappedUpdateData, [identityWhere], void 0)).toArray())[0];
+		const updatedRaw = (await queryPlanRows(scope, compileUpdateReturning(contract, namespaceId, modelName, tableName, mappedUpdateData, [identityWhere], 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);
@@ -4104,7 +4281,7 @@ async function insertSingleRow(scope, context, namespaceId, modelName, data) {
 		values: mappedData
 	});
 	for (const def of applied) mappedData[def.field] = def.value;
-	const firstRow = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, tableName, [mappedData], void 0)).toArray())[0];
+	const firstRow = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, modelName, 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,
@@ -4120,7 +4297,7 @@ async function findRowByCriterion(scope, context, namespaceId, modelName, criter
 		model: modelName,
 		problem: "empty-criterion"
 	} });
-	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName), {
+	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, modelName, resolveModelTableName(contract, namespaceId, modelName), {
 		...emptyState(),
 		filters: [whereExpr],
 		limit: 1
@@ -4129,7 +4306,7 @@ async function findRowByCriterion(scope, context, namespaceId, modelName, criter
 	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
 }
 async function findFirstByFilters(scope, contract, namespaceId, modelName, filters) {
-	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, resolveModelTableName(contract, namespaceId, modelName), {
+	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, modelName, resolveModelTableName(contract, namespaceId, modelName), {
 		...emptyState(),
 		filters,
 		limit: 1
@@ -4158,8 +4335,8 @@ function getRelationDefinitions(contract, namespaceId, modelName) {
 		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)),
+		localColumns: relation.on.localFields.map((f) => columnOfContractField(contract, namespaceId, modelName, f)),
+		targetColumns: resolveRelationTargetColumns(contract, relation),
 		through: relation.through ? {
 			table: relation.through.table,
 			namespaceId: relation.through.namespaceId,
@@ -4173,7 +4350,7 @@ function getRelationDefinitions(contract, namespaceId, modelName) {
 	return definitions;
 }
 function toFieldName(contract, namespaceId, modelName, columnName) {
-	return getColumnToFieldMap(contract, namespaceId, modelName)[columnName] ?? columnName;
+	return fieldOfColumn(getModelColumnFields(contract, namespaceId, modelName), modelName, columnName);
 }
 function normalizeWhereArg(arg, options) {
 	if (arg === void 0) return;
@@ -4385,7 +4562,7 @@ var CollectionBase = class CollectionBase {
 	*/
 	#includeScalarReducer(operation, field) {
 		this.#assertIncludeRefinementMode(`${operation}()`);
-		const column = field === void 0 ? void 0 : resolveFieldToColumn(this.contract, this.namespaceId, this.modelName, field);
+		const column = field === void 0 ? void 0 : columnOfCallerField(this.contract, this.namespaceId, getModelFieldColumns(this.contract, this.namespaceId, this.modelName), this.modelName, field);
 		return createIncludeScalar(operation, this.state, column);
 	}
 	where(input) {
@@ -4494,7 +4671,7 @@ var CollectionBase = class CollectionBase {
 		return this.#cloneWithRow({ includes: [...this.state.includes, includeExpr] });
 	}
 	select(...fields) {
-		const selectedFields = mapFieldsToColumns(this.contract, this.namespaceId, this.modelName, fields);
+		const selectedFields = mapSelectedFieldsToColumns(this.contract, this.namespaceId, this.modelName, this.state.variantName, fields);
 		return this.#cloneWithRow({ selectedFields });
 	}
 	orderBy(selection) {
@@ -4782,7 +4959,7 @@ var CollectionBase = class CollectionBase {
 		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, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
+			const plans = compileInsertReturningSplit(this.contract, this.namespaceId, this.modelName, this.tableName, mappedRows, selectedForInsert, conflictSkip).map((plan) => mergeAnnotations(plan, annotationsMap));
 			return dispatchSplitMutationRows({
 				context: this.ctx.context,
 				runtime: this.ctx.runtime,
@@ -4797,7 +4974,7 @@ var CollectionBase = class CollectionBase {
 				mapRow: (mapped) => blindCast(mapped)
 			});
 		}
-		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.tableName, mappedRows, selectedForInsert, conflictSkip), annotationsMap);
+		const compiled = mergeAnnotations(compileInsertReturning(this.contract, this.namespaceId, this.modelName, this.tableName, mappedRows, selectedForInsert, conflictSkip), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
@@ -4822,7 +4999,7 @@ var CollectionBase = class CollectionBase {
 		else this.#assertNotMtiVariant(method);
 		const conflictOn = options.conflictOn ?? [];
 		assertInsertConflictSkipCapability(this.contract, method, conflictOn.length > 0);
-		return { columns: resolveInsertConflictColumns(this.contract, this.namespaceId, this.modelName, conflictOn, method) };
+		return { columns: resolveInsertConflictColumns(this.contract, this.namespaceId, this.modelName, conflictOn) };
 	}
 	#assertNotMtiVariant(method) {
 		this.#refuseOnMtiVariant(method, `${method} is not supported for MTI variant "${this.state.variantName}" on model "${this.modelName}". Use createAll() instead.`);
@@ -4846,16 +5023,20 @@ var CollectionBase = class CollectionBase {
 		if (!polyInfo) return null;
 		const variant = polyInfo.variants.get(variantName);
 		if (!isMtiVariantInfo(variant)) return null;
+		const baseFieldToColumn = getModelFieldColumns(this.contract, this.namespaceId, this.modelName);
+		const variantFieldToColumn = getOwnFieldColumns(this.contract, this.namespaceId, variant.modelName);
+		const pkColumns = resolvePrimaryKeyColumns(this.contract, this.namespaceId, this.tableName);
 		return {
 			polyInfo,
 			variant,
-			baseFieldToColumn: getFieldToColumnMap(this.contract, this.namespaceId, this.modelName),
-			variantFieldToColumn: getFieldToColumnMap(this.contract, this.namespaceId, variant.modelName),
-			pkColumns: resolvePrimaryKeyColumns(this.contract, this.namespaceId, this.tableName)
+			baseFieldToColumn,
+			variantFieldToColumn,
+			mergedFieldToColumn: getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.modelName),
+			pkColumns
 		};
 	}
 	#executeMtiCreate(data, mtiCtx) {
-		const { polyInfo, variant, baseFieldToColumn, variantFieldToColumn, pkColumns } = mtiCtx;
+		const { polyInfo, variant, baseFieldToColumn, variantFieldToColumn, mergedFieldToColumn, pkColumns } = mtiCtx;
 		const contract = this.contract;
 		const collectionCtx = this.ctx;
 		const runtime = collectionCtx.runtime;
@@ -4864,18 +5045,13 @@ var CollectionBase = class CollectionBase {
 		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* () {
 			const defaultValueCache = /* @__PURE__ */ new Map();
 			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[columnOfCallerField(contract, namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
 				}
 				allMapped[polyInfo.discriminatorColumn] = variant.value;
 				const baseRow = {};
@@ -4886,7 +5062,7 @@ var CollectionBase = class CollectionBase {
 				}
 				yield blindCast(await withMutationScope(runtime, async (scope) => {
 					applyCreateDefaults(collectionCtx, namespaceId, tableName, [baseRow], defaultValueCache);
-					const baseCreated = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, tableName, [baseRow], void 0)).toArray())[0];
+					const baseCreated = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, modelName, 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,
@@ -4895,7 +5071,7 @@ var CollectionBase = class CollectionBase {
 					} });
 					for (const pkColumn of pkColumns) variantRow[pkColumn] = baseCreated[pkColumn];
 					applyCreateDefaults(collectionCtx, namespaceId, variant.table, [variantRow], defaultValueCache);
-					const variantCreated = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, variant.table, [variantRow], void 0)).toArray())[0];
+					const variantCreated = (await queryPlanRows(scope, compileInsertReturning(contract, namespaceId, variant.modelName, 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,
@@ -4923,18 +5099,12 @@ var CollectionBase = class CollectionBase {
 		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
-		};
+		const mergedFieldToColumn = getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.modelName);
 		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[columnOfCallerField(this.contract, this.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
 			}
 			mapped[polyInfo.discriminatorColumn] = variant.value;
 			return mapped;
@@ -5003,7 +5173,7 @@ var CollectionBase = class CollectionBase {
 			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 compiled = mergeAnnotations(compileUpsertReturning(this.contract, this.namespaceId, this.modelName, this.tableName, createValues, updateValues, conflictColumns, selectedForUpsert), annotationsMap);
 		const row = await executeMutationReturningSingleRow({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
@@ -5048,6 +5218,7 @@ var CollectionBase = class CollectionBase {
 			const identityCriterion = buildRowIdentityFilterFromRow(this.contract, this.namespaceId, this.modelName, updatedRow);
 			return this.#reloadMutationRowByIdentity(identityCriterion);
 		}
+		assertModelFieldNames(this.contract, this.namespaceId, this.modelName, blindCast(data));
 		return withMutationScope(this.ctx.runtime, async (scope) => {
 			const scoped = this.#withRuntime(scope);
 			const identityWhere = await scoped.#findFirstMatchingRowIdentityWhere();
@@ -5069,7 +5240,7 @@ var CollectionBase = class CollectionBase {
 		}
 		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);
+		const compiled = mergeAnnotations(compileUpdateReturning(this.contract, this.namespaceId, this.modelName, this.tableName, mappedData, this.state.filters, selectedForUpdate), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
@@ -5121,7 +5292,7 @@ var CollectionBase = class CollectionBase {
 	#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);
+		const compiled = mergeAnnotations(compileDeleteReturning(this.contract, this.namespaceId, this.modelName, this.tableName, this.state.filters, selectedForDelete), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
@@ -5177,7 +5348,6 @@ var CollectionBase = class CollectionBase {
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	#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: {
@@ -5185,7 +5355,7 @@ var CollectionBase = class CollectionBase {
 				model: this.modelName,
 				column: columnName
 			} });
-			const fieldName = columnToField[columnName] ?? columnName;
+			const fieldName = fieldOfColumn(getModelColumnFields(this.contract, this.namespaceId, this.modelName), this.modelName, columnName);
 			criterion[fieldName] = createValues[columnName];
 		}
 		return criterion;
@@ -5230,10 +5400,9 @@ var CollectionBase = class CollectionBase {
 			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 fieldName = fieldOfColumn(getModelColumnFields(this.contract, this.namespaceId, this.modelName), this.modelName, 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;