@prisma/orm-family-sql 8.0.0-rc.17-dev.30 → 8.0.0-rc.17-dev.32

package/dist/orm-client.mjs

@@ -102,8 +102,7 @@ function resolvePolymorphismInfo(contract, namespaceId, modelName) {
 	}
 	const cacheKey = metadataCacheKey(namespaceId, modelName);
 	if (perContract.has(cacheKey)) return perContract.get(cacheKey);
-	const models = modelsOf(contract, namespaceId);
-	const model = models[modelName];
+	const model = modelsOf(contract, namespaceId)[modelName];
 	if (!model?.discriminator || !model.variants) {
 		perContract.set(cacheKey, void 0);
 		return;
@@ -116,21 +115,21 @@ function resolvePolymorphismInfo(contract, namespaceId, modelName) {
 	const discriminatorField = model.discriminator.field;
 	const discriminatorColumn = columnOfContractField(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];
+	for (const [value, variantRef] of Object.entries(model.variants)) {
+		const variantModelName = variantRef.model;
+		const variantModel = modelOf(contract, variantRef.namespace, 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 strategy = variantRef.namespace === namespaceId && variantTable === baseTable ? "sti" : "mti";
 		const info = {
 			modelName: variantModelName,
-			value: variantEntry.value,
+			namespaceId: variantRef.namespace,
+			value,
 			table: variantTable,
 			strategy
 		};
-		variants.set(variantModelName, info);
-		variantsByValue.set(variantEntry.value, info);
+		variants.set(value, info);
 		if (strategy === "mti") mtiVariants.push(info);
 	}
 	const result = {
@@ -138,7 +137,6 @@ function resolvePolymorphismInfo(contract, namespaceId, modelName) {
 		discriminatorColumn,
 		baseTable,
 		variants,
-		variantsByValue,
 		mtiVariants
 	};
 	perContract.set(cacheKey, result);
@@ -169,6 +167,7 @@ function getModelFields(contract, 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, {
+			namespaceId,
 			table,
 			column
 		}]));
@@ -188,18 +187,18 @@ function getModelFieldColumns(contract, 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.
+* The column each field of the model and of the variant `variantValue` maps, keyed by field name. Without a variant, the model's fields alone.
 *
 * 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) {
+function getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantValue) {
 	return cachedFor(contract, [
 		"modelAndVariantFieldColumns",
 		namespaceId,
 		modelName,
-		variantName ?? null
+		variantValue ?? null
 	], () => ({
-		...variantName === void 0 ? {} : getOwnFieldColumns(contract, namespaceId, variantName),
+		...variantValue === void 0 ? {} : getOwnFieldColumns(contract, ...addressedModel(contract, namespaceId, modelName, variantValue)),
 		...getModelFieldColumns(contract, namespaceId, modelName)
 	}));
 }
@@ -222,7 +221,7 @@ function getModelAndEveryVariantFieldColumns(contract, namespaceId, modelName) {
 		};
 		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))));
+		for (const variant of resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.values() ?? []) add(Object.fromEntries(Object.entries(getOwnFieldColumns(contract, variant.namespaceId, variant.modelName)).filter(([field]) => !modelFields.has(field))));
 		return columns;
 	});
 }
@@ -277,22 +276,28 @@ function getUnmappedColumns(contract, namespaceId, modelName) {
 		namespaceId,
 		modelName
 	], () => {
-		const root = hierarchyRootName(contract, namespaceId, modelName);
-		const rootTable = domainModelTableInNamespace(contract, namespaceId, root);
+		const root = hierarchyRoot(contract, namespaceId, modelName);
+		const rootTable = domainModelTableInNamespace(contract, root.namespaceId, root.modelName);
 		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,
+		const polymorphism = resolvePolymorphismInfo(contract, root.namespaceId, root.modelName);
+		return [{
+			...root,
+			table: rootTable
+		}, ...polymorphism?.mtiVariants ?? []].flatMap((model) => {
+			const read = new Set(getColumnsReadOnTable(contract, model.namespaceId, model.modelName, model.table));
+			return getAllTableColumns(contract, model.namespaceId, model.table).filter((column) => !read.has(column)).map((column) => ({
+				table: model.table,
 				column
 			}));
 		});
 	});
 }
-function hierarchyRootName(contract, namespaceId, modelName) {
+function hierarchyRoot(contract, namespaceId, modelName) {
 	const base = modelOf(contract, namespaceId, modelName)?.base;
-	return base === void 0 || base.namespace !== namespaceId ? modelName : hierarchyRootName(contract, namespaceId, base.model);
+	return base === void 0 ? {
+		namespaceId,
+		modelName
+	} : hierarchyRoot(contract, base.namespace, 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.
@@ -321,10 +326,10 @@ function resolveRelationTargetColumns(contract, relation) {
 /**
 * 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);
+function resolveVariantFieldColumns(contract, namespaceId, baseModelName, variantValue) {
+	const variant = resolvePolymorphismInfo(contract, namespaceId, baseModelName)?.variants.get(variantValue);
 	if (variant?.strategy !== "mti") return {};
-	return Object.fromEntries(Object.entries(getModelFields(contract, namespaceId, variant.modelName)).filter(([, field]) => field.table === variant.table));
+	return Object.fromEntries(Object.entries(getModelFields(contract, variant.namespaceId, variant.modelName)).filter(([, field]) => field.namespaceId === variant.namespaceId && field.table === variant.table));
 }
 /** Every column of a table, in table order. */
 function getAllTableColumns(contract, namespaceId, tableName) {
@@ -338,55 +343,59 @@ function getAllTableColumns(contract, namespaceId, tableName) {
 		} });
 	}
 }
-function isMultiTableVariantTable(contract, namespaceId, modelName, tableName) {
+function isMultiTableVariantTable(contract, namespaceId, modelName, tableNamespaceId, tableName) {
 	const base = modelOf(contract, namespaceId, modelName)?.base;
-	return base !== void 0 && domainModelTableInNamespace(contract, namespaceId, modelName) === tableName && domainModelTableInNamespace(contract, base.namespace, base.model) !== tableName;
+	return base !== void 0 && namespaceId === tableNamespaceId && domainModelTableInNamespace(contract, namespaceId, modelName) === tableName && (base.namespace !== tableNamespaceId || domainModelTableInNamespace(contract, base.namespace, base.model) !== tableName);
 }
 /**
 * 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 getColumnsReadOnTable(contract, namespaceId, modelName, tableName) {
+function getColumnsReadOnTable(contract, namespaceId, modelName, tableName, tableNamespaceId = namespaceId) {
 	return cachedFor(contract, [
 		"columnsReadOnTable",
 		namespaceId,
 		modelName,
+		tableNamespaceId,
 		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 addFieldsOnTable = (modelNamespaceId, name) => {
+			for (const field of Object.values(getModelFields(contract, modelNamespaceId, name))) if (field.namespaceId === tableNamespaceId && field.table === tableName) read.add(field.column);
 		};
 		const addInheritedKey = () => {
-			for (const column of resolvePrimaryKeyColumns(contract, namespaceId, tableName)) read.add(column);
+			for (const column of resolvePrimaryKeyColumns(contract, tableNamespaceId, tableName)) read.add(column);
 		};
-		addFieldsOnTable(modelName);
-		if (isMultiTableVariantTable(contract, namespaceId, modelName, tableName)) addInheritedKey();
+		addFieldsOnTable(namespaceId, modelName);
+		if (isMultiTableVariantTable(contract, namespaceId, modelName, tableNamespaceId, 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.namespaceId !== tableNamespaceId || variant.table !== tableName) continue;
+			addFieldsOnTable(variant.namespaceId, variant.modelName);
 			if (variant.strategy === "mti") addInheritedKey();
 		}
-		return getAllTableColumns(contract, namespaceId, tableName).filter((column) => read.has(column));
+		return getAllTableColumns(contract, tableNamespaceId, 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;
+/** The namespace and name of the model a query or write addresses: the variant it is narrowed to, otherwise the collection's model. */
+function addressedModel(contract, namespaceId, modelName, variantValue) {
+	const variant = variantValue === void 0 ? void 0 : resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.get(variantValue);
+	return variant === void 0 ? [namespaceId, modelName] : [variant.namespaceId, variant.modelName];
 }
-function resolveIncludeRelation(contract, namespaceId, baseModelName, relationName, variantName) {
+function resolveIncludeRelation(contract, namespaceId, baseModelName, relationName, variantValue) {
 	const polymorphism = resolvePolymorphismInfo(contract, namespaceId, baseModelName);
-	const variant = variantName === void 0 ? void 0 : polymorphism?.variants.get(variantName);
+	const variant = variantValue === void 0 ? void 0 : polymorphism?.variants.get(variantValue);
+	let declaringNamespaceId = namespaceId;
 	let declaringModelName = baseModelName;
-	let localVariantName;
+	let localVariantValue;
 	let relation;
 	if (variant !== void 0) {
-		const variantRelations = resolveModelRelations(contract, namespaceId, variant.modelName);
+		const variantRelations = resolveModelRelations(contract, variant.namespaceId, variant.modelName);
 		const candidate = Object.hasOwn(variantRelations, relationName) ? variantRelations[relationName] : void 0;
 		if (candidate !== void 0) {
 			relation = candidate;
+			declaringNamespaceId = variant.namespaceId;
 			declaringModelName = variant.modelName;
-			localVariantName = variant.strategy === "mti" ? variant.modelName : void 0;
+			localVariantValue = variant.strategy === "mti" ? variant.value : void 0;
 		}
 	}
 	const baseRelations = resolveModelRelations(contract, namespaceId, baseModelName);
@@ -397,7 +406,7 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 	} });
 	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) => columnOfContractField(contract, namespaceId, declaringModelName, field));
+	const localColumns = localFields.map((field) => columnOfContractField(contract, declaringNamespaceId, declaringModelName, field));
 	const targetColumns = resolveRelationTargetColumns(contract, relation);
 	const relatedTableName = resolveModelTableName(contract, relation.toNamespace, relation.to);
 	let through;
@@ -413,7 +422,7 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 		relatedModelName: relation.to,
 		relatedNamespaceId: relation.toNamespace,
 		relatedTableName,
-		...ifDefined("localVariantName", localVariantName),
+		...ifDefined("localVariantValue", localVariantValue),
 		targetColumns,
 		localColumns,
 		cardinality: relation.cardinality,
@@ -519,7 +528,8 @@ function hasCompleteUniqueKey(contract, namespaceId, modelName, criterion) {
 	for (const [fieldName, value] of Object.entries(criterion)) {
 		if (value === void 0) continue;
 		const column = columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName);
-		if (value !== null && !isExpression(value) && fields[fieldName]?.table === tableName) columnsWithValue.add(column);
+		const field = fields[fieldName];
+		if (value !== null && !isExpression(value) && field?.namespaceId === namespaceId && field.table === tableName) columnsWithValue.add(column);
 	}
 	return resolveUniqueKeyColumnSets(contract, namespaceId, tableName).some((columns) => columns.every((column) => columnsWithValue.has(column)));
 }
@@ -673,11 +683,11 @@ function mapFieldsToColumns(contract, namespaceId, modelName, fieldNames) {
 	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));
+function mapSelectedFieldsToColumns(contract, namespaceId, modelName, variantValue, fieldNames) {
+	const [addressedNamespaceId, addressed] = addressedModel(contract, namespaceId, modelName, variantValue);
+	if (variantValue !== void 0) {
+		const fieldColumns = getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantValue);
+		return fieldNames.map((fieldName) => columnOfCallerField(contract, addressedNamespaceId, fieldColumns, addressed, fieldName));
 	}
 	const fieldColumns = getModelAndEveryVariantFieldColumns(contract, namespaceId, modelName);
 	return fieldNames.flatMap((fieldName) => {
@@ -746,8 +756,8 @@ function createModelTables(contract, scope, namespaceId, modelName, tableName) {
 	});
 	const variants = /* @__PURE__ */ new Map();
 	const mtiVariants = resolvePolymorphismInfo(contract, namespaceId, modelName)?.mtiVariants ?? [];
-	for (const variant of mtiVariants) variants.set(variant.modelName, scope.aliasTable({
-		namespaceId,
+	for (const variant of mtiVariants) variants.set(variant.value, scope.aliasTable({
+		namespaceId: variant.namespaceId,
 		tableName: variant.table
 	}));
 	return {
@@ -783,9 +793,9 @@ function withScopeCopy(tables) {
 		scope: tables.scope.copy()
 	};
 }
-function requireVariantTable(tables, variantModelName) {
-	const variantTable = tables.variants.get(variantModelName);
-	if (variantTable === void 0) throw new InternalError(`Collection state has no aliased table for variant "${variantModelName}"`);
+function requireVariantTable(tables, variantValue) {
+	const variantTable = tables.variants.get(variantValue);
+	if (variantTable === void 0) throw new InternalError(`Collection state has no aliased table for variant "${variantValue}"`);
 	return variantTable;
 }
 function tableAliases(tables) {
@@ -813,8 +823,8 @@ function createStorageRowMapper(contract, namespaceId, modelName) {
 	return (row) => mapKnownColumnNames(row, columnToField);
 }
 const mergedColumnToFieldCache = /* @__PURE__ */ new WeakMap();
-function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variantModelName, variantTable) {
-	const cacheKey = `${namespaceId}:${baseModelName}:${variantModelName}:${variantTable?.alias ?? ""}`;
+function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant, variantTable) {
+	const cacheKey = `${namespaceId}:${baseModelName}:${variant.value}:${variantTable?.alias ?? ""}`;
 	let perContract = mergedColumnToFieldCache.get(contract);
 	if (!perContract) {
 		perContract = /* @__PURE__ */ new Map();
@@ -823,7 +833,7 @@ function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant
 	const cached = perContract.get(cacheKey);
 	if (cached) return cached;
 	const baseMap = getModelColumnFields(contract, namespaceId, baseModelName);
-	const variantMap = getOwnColumnFields(contract, namespaceId, variantModelName);
+	const variantMap = getOwnColumnFields(contract, variant.namespaceId, variant.modelName);
 	const merged = { ...baseMap };
 	for (const [col, field] of Object.entries(variantMap)) if (variantTable) merged[variantColumnLabel(variantTable, col)] = field;
 	else merged[col] = field;
@@ -831,28 +841,29 @@ function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant
 	return merged;
 }
 function variantTableOf(tables, variant) {
-	return variant.strategy === "mti" ? requireVariantTable(tables, variant.modelName) : void 0;
+	return variant.strategy === "mti" ? requireVariantTable(tables, variant.value) : void 0;
 }
-function mapPolymorphicRow(contract, namespaceId, baseModelName, polyInfo, tables, row, variantName) {
+function mapPolymorphicRow(contract, namespaceId, baseModelName, polyInfo, tables, row, variantValue) {
 	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;
+	const selectedValue = variantValue ?? discriminatorValue;
+	const variant = typeof selectedValue === "string" ? polyInfo.variants.get(selectedValue) : void 0;
 	if (!variant) return mapKnownColumnNames(row, getModelColumnFields(contract, namespaceId, baseModelName));
-	return mapKnownColumnNames(row, getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, variantTableOf(tables, variant)));
+	return mapKnownColumnNames(row, getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant, variantTableOf(tables, variant)));
 }
-function createPolymorphicRowMapper(contract, namespaceId, baseModelName, polyInfo, tables, variantName) {
+function createPolymorphicRowMapper(contract, namespaceId, baseModelName, polyInfo, tables, variantValue) {
 	const baseMapper = captureColumnMapper(() => getModelColumnFields(contract, namespaceId, baseModelName));
 	const mappersByValue = /* @__PURE__ */ new Map();
 	let pinnedMapper = baseMapper;
-	for (const [name, variant] of polyInfo.variants) {
-		if (variantName && name !== variantName) continue;
-		const mapper = captureColumnMapper(() => getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, variantTableOf(tables, variant)));
-		if (variantName) pinnedMapper = mapper;
-		for (const [value, candidate] of polyInfo.variantsByValue) if (candidate === variant) mappersByValue.set(value, mapper);
+	for (const [value, variant] of polyInfo.variants) {
+		if (variantValue && value !== variantValue) continue;
+		const mapper = captureColumnMapper(() => getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant, variantTableOf(tables, variant)));
+		if (variantValue) pinnedMapper = mapper;
+		mappersByValue.set(value, mapper);
 	}
 	const discriminatorColumn = polyInfo.discriminatorColumn;
 	return (row) => {
 		const value = row[discriminatorColumn] ?? row["__prisma_polymorphic_discriminator"];
-		return (variantName ? pinnedMapper : typeof value === "string" ? mappersByValue.get(value) ?? baseMapper : baseMapper)(row);
+		return (variantValue ? pinnedMapper : typeof value === "string" ? mappersByValue.get(value) ?? baseMapper : baseMapper)(row);
 	};
 }
 function captureColumnMapper(resolve) {
@@ -1241,10 +1252,10 @@ function buildPrimaryKeyJoinOn(left, right, primaryKeyColumns) {
 	if (primaryKeyColumns.length === 1 && firstColumn !== void 0) return EqColJoinOn.of(left.column(firstColumn), right.column(firstColumn));
 	return AndExpr.of(primaryKeyColumns.map((column) => BinaryExpr.eq(left.column(column), right.column(column))));
 }
-function buildMtiJoins(contract, tables, polyInfo, variantName, selectedColumnsByVariant) {
+function buildMtiJoins(contract, tables, polyInfo, variantValue, selectedColumnsByVariant) {
 	const joins = [];
 	const projection = [];
-	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
+	const variantsToJoin = variantValue ? polyInfo.mtiVariants.filter((v) => v.value === variantValue) : polyInfo.mtiVariants;
 	if (variantsToJoin.length === 0) return {
 		joins,
 		projection
@@ -1252,12 +1263,12 @@ function buildMtiJoins(contract, tables, polyInfo, variantName, selectedColumnsB
 	const { root } = tables;
 	const pkColumns = resolvePrimaryKeyColumns(contract, root.storage.namespaceId, root.storage.tableName);
 	for (const variant of variantsToJoin) {
-		const variantTable = requireVariantTable(tables, variant.modelName);
+		const variantTable = requireVariantTable(tables, variant.value);
 		const joinOn = buildPrimaryKeyJoinOn(root, variantTable, pkColumns);
-		joins.push(variantName ? JoinAst.inner(variantTable.tableSource(contract), joinOn) : JoinAst.left(variantTable.tableSource(contract), joinOn));
+		joins.push(variantValue ? JoinAst.inner(variantTable.tableSource(contract), joinOn) : JoinAst.left(variantTable.tableSource(contract), joinOn));
 		const { namespaceId, tableName } = variantTable.storage;
 		const variantColumns = getColumnsReadOnTable(contract, namespaceId, variant.modelName, tableName);
-		const selectedVariantColumns = selectedColumnsByVariant?.get(variant.modelName);
+		const selectedVariantColumns = selectedColumnsByVariant?.get(variant.value);
 		for (const col of variantColumns) {
 			if (pkColumns.includes(col)) continue;
 			if (selectedColumnsByVariant !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
@@ -1280,7 +1291,7 @@ function hasEntries(value) {
 function buildAggregateInput(contract, state, modelName, projection) {
 	const { root } = state.tables;
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, root.storage.namespaceId, modelName) : void 0;
-	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantName, void 0).joins : [];
+	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantValue, void 0).joins : [];
 	const where = buildStateWhere(contract, state);
 	const hiddenOrders = hasEntries(state.distinct) ? projectExpressionOrders(root, state.orderBy) : void 0;
 	const { source, where: effectiveWhere } = buildDedupedTableSource(contract, state, where, [...projection, ...hiddenOrders?.projection ?? []], variantJoins);
@@ -1330,7 +1341,7 @@ function emptyState(tables) {
 		selectedFields: void 0,
 		limit: void 0,
 		offset: void 0,
-		variantName: void 0,
+		variantValue: void 0,
 		locking: void 0,
 		annotations: /* @__PURE__ */ new Map()
 	};
@@ -1537,7 +1548,7 @@ function compileAggregate(contract, aggregates, state, aggregateSpec, modelName)
 		return buildOrmQueryPlan(contract, ast, params);
 	}
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantName, void 0).joins : [];
+	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantValue, void 0).joins : [];
 	const where = buildStateWhere(contract, state);
 	const projection = entries.map(([alias, selector]) => {
 		const { expr, codec } = toAggregateProjection(contract, aggregates, root, selector);
@@ -1579,8 +1590,8 @@ function compileGroupedAggregate(contract, aggregates, preGroupState, groupByCol
 		ast = SelectAst.from(source).withProjection(projection).withGroupBy(groupByColumns.map((column) => root.column(column)));
 	} else {
 		const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-		const { tables, variantName } = preGroupState;
-		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, tables, polyInfo, variantName, void 0).joins : [];
+		const { tables, variantValue } = preGroupState;
+		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, tables, polyInfo, variantValue, void 0).joins : [];
 		ast = SelectAst.from(root.tableSource(contract)).withProjection(projection).withGroupBy(groupByColumns.map((column) => root.column(column)));
 		if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
 		const where = buildStateWhere(contract, preGroupState);
@@ -1676,8 +1687,8 @@ function stripUndefinedValues(row) {
 	for (const [key, value] of Object.entries(row)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function buildCountMutationWhere(contract, tables, filters, variantName) {
-	const variantTable = variantName === void 0 ? void 0 : tables.variants.get(variantName);
+function buildCountMutationWhere(contract, tables, filters, variantValue) {
+	const variantTable = variantValue === void 0 ? void 0 : tables.variants.get(variantValue);
 	if (variantTable === void 0) return combineWhereExprs(filters);
 	const { root } = tables;
 	const pkColumns = resolvePrimaryKeyColumns(contract, root.storage.namespaceId, root.storage.tableName);
@@ -1739,10 +1750,10 @@ function compileUpdateReturning(contract, modelName, tables, setValues, filters,
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileUpdateCount(contract, tables, setValues, filters, variantName) {
+function compileUpdateCount(contract, tables, setValues, filters, variantValue) {
 	const { root } = tables;
 	const { namespaceId, tableName } = root.storage;
-	const where = buildCountMutationWhere(contract, tables, filters, variantName);
+	const where = buildCountMutationWhere(contract, tables, filters, variantValue);
 	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
 	let ast = UpdateAst.table(root.tableSource(contract)).withSet(assignments);
 	if (where) ast = ast.withWhere(where);
@@ -1757,8 +1768,8 @@ function compileDeleteReturning(contract, modelName, tables, filters, returningC
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileDeleteCount(contract, tables, filters, variantName) {
-	const where = buildCountMutationWhere(contract, tables, filters, variantName);
+function compileDeleteCount(contract, tables, filters, variantValue) {
+	const where = buildCountMutationWhere(contract, tables, filters, variantValue);
 	let ast = DeleteAst.from(tables.root.tableSource(contract));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
@@ -1833,9 +1844,9 @@ function jsonEntryProjection(value, identity) {
 	if (identity.document === true) return new JsonDocumentProjection(value);
 	return new NativeJsonValueProjection(value);
 }
-function buildProjection(contract, modelName, table, selectedFields, projectedThrough) {
+function buildProjection(contract, model, table, selectedFields, projectedThrough) {
 	const { namespaceId, tableName } = table.storage;
-	return (selectedFields !== void 0 ? [...selectedFields] : getColumnsReadOnTable(contract, namespaceId, modelName, tableName)).map((column) => ProjectionItem.of(column, projectedThrough === void 0 ? table.column(column) : ColumnRef.of(projectedThrough, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
+	return (selectedFields !== void 0 ? [...selectedFields] : getColumnsReadOnTable(contract, ...model, tableName, namespaceId)).map((column) => ProjectionItem.of(column, projectedThrough === void 0 ? table.column(column) : ColumnRef.of(projectedThrough, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
 }
 function appendUnique(values, value) {
 	if (!values.includes(value)) values.push(value);
@@ -1849,7 +1860,7 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 	const baseColumnToField = getModelColumnFields(contract, namespaceId, modelName);
 	const variantColumnMaps = Array.from(polyInfo.variants.values(), (variant) => ({
 		variant,
-		columnToField: getOwnColumnFields(contract, namespaceId, variant.modelName)
+		columnToField: getOwnColumnFields(contract, variant.namespaceId, variant.modelName)
 	}));
 	const baseSelectedFields = [];
 	const selectedMtiColumnsByVariant = /* @__PURE__ */ new Map();
@@ -1866,10 +1877,10 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 				appendUnique(baseSelectedFields, column);
 				continue;
 			}
-			let selectedColumns = selectedMtiColumnsByVariant.get(variant.modelName);
+			let selectedColumns = selectedMtiColumnsByVariant.get(variant.value);
 			if (selectedColumns === void 0) {
 				selectedColumns = /* @__PURE__ */ new Set();
-				selectedMtiColumnsByVariant.set(variant.modelName, selectedColumns);
+				selectedMtiColumnsByVariant.set(variant.value, selectedColumns);
 			}
 			selectedColumns.add(column);
 		}
@@ -1878,7 +1889,7 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 	return {
 		baseSelectedFields,
 		selectedMtiColumnsByVariant,
-		needsHiddenDiscriminator: state.variantName === void 0 && hasVariantOwnedSelection && !baseSelectedFields.includes(polyInfo.discriminatorColumn)
+		needsHiddenDiscriminator: state.variantValue === void 0 && hasVariantOwnedSelection && !baseSelectedFields.includes(polyInfo.discriminatorColumn)
 	};
 }
 function buildHiddenDiscriminatorProjection(contract, table, polyInfo, needed) {
@@ -1917,7 +1928,7 @@ function buildIncludeJoinExpr(include, child, parentLocalRefs) {
 	return joinExprs.length === 1 ? firstExpr : AndExpr.of(joinExprs);
 }
 function localTable(tables, include) {
-	return include.localVariantName === void 0 ? tables.root : requireVariantTable(tables, include.localVariantName);
+	return include.localVariantValue === void 0 ? tables.root : requireVariantTable(tables, include.localVariantValue);
 }
 function resolveParentLocalRefs(parent, include, localColumns) {
 	const local = localTable(parent.tables, include);
@@ -1960,7 +1971,7 @@ function buildChildPolymorphismJoinsAndProjection(contract, include) {
 		baseSelectedFields: include.nested.selectedFields
 	};
 	const selection = resolvePolymorphicProjectionSelection(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, include.nested);
-	const { joins, projection } = buildMtiJoins(contract, include.nested.tables, polyInfo, include.nested.variantName, selection.selectedMtiColumnsByVariant);
+	const { joins, projection } = buildMtiJoins(contract, include.nested.tables, polyInfo, include.nested.variantValue, selection.selectedMtiColumnsByVariant);
 	return {
 		joins,
 		projection,
@@ -1972,8 +1983,8 @@ function buildRequiredMtiJoinKeyProjection(contract, include) {
 	const aliases = /* @__PURE__ */ new Set();
 	const projection = [];
 	for (const nested of include.nested.includes) {
-		if (nested.localVariantName === void 0) continue;
-		const variantTable = requireVariantTable(include.nested.tables, nested.localVariantName);
+		if (nested.localVariantValue === void 0) continue;
+		const variantTable = requireVariantTable(include.nested.tables, nested.localVariantValue);
 		for (const column of localColumnsForRowInclude(nested)) {
 			const alias = variantColumnLabel(variantTable, column);
 			if (aliases.has(alias)) continue;
@@ -2054,7 +2065,7 @@ function buildIncludeChildRowsSelect(contract, aggregates, scope, parent, includ
 		junctionJoins
 	});
 	const polyJoinsAndProjection = buildChildPolymorphismJoinsAndProjection(contract, include);
-	const scalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, polyJoinsAndProjection.baseSelectedFields);
+	const scalarProjection = buildProjection(contract, addressedModel(contract, include.relatedNamespaceId, include.relatedModelName, include.nested.variantValue), child, polyJoinsAndProjection.baseSelectedFields);
 	const nestedProjections = buildNestedIncludeProjections(contract, aggregates, scope, { tables: childState.tables }, childState.includes);
 	const childProjection = [
 		...scalarProjection,
@@ -2092,7 +2103,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 	const { contract, aggregates, scope, include, rowsAlias, childOrderBy, hiddenOrderProjection, aggregateOrderBy, whereExpr, junctionJoins } = options;
 	const childState = include.nested;
 	const child = childState.tables.root;
-	const grandchildJoinColumns = Array.from(new Set(childState.includes.flatMap((nested) => nested.localVariantName === void 0 ? localColumnsForRowInclude(nested) : [])));
+	const grandchildJoinColumns = Array.from(new Set(childState.includes.flatMap((nested) => nested.localVariantValue === void 0 ? localColumnsForRowInclude(nested) : [])));
 	const { selectedForQuery } = augmentSelectionForJoinColumns(childState.selectedFields, grandchildJoinColumns);
 	const visiblePolyProjection = buildChildPolymorphismJoinsAndProjection(contract, include);
 	const queryPolyProjection = buildChildPolymorphismJoinsAndProjection(contract, {
@@ -2102,7 +2113,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 			selectedFields: selectedForQuery
 		}
 	});
-	const innerScalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, queryPolyProjection.baseSelectedFields);
+	const innerScalarProjection = buildProjection(contract, addressedModel(contract, include.relatedNamespaceId, include.relatedModelName, include.nested.variantValue), child, queryPolyProjection.baseSelectedFields);
 	const innerMtiProjection = mergeProjectionByAlias(queryPolyProjection.projection, buildRequiredMtiJoinKeyProjection(contract, include));
 	let baseInner = SelectAst.from(child.tableSource(contract)).withProjection([
 		...innerScalarProjection,
@@ -2125,7 +2136,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 = scope.alias(`${include.relationName}__distinct`);
-	const outerScalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, visiblePolyProjection.baseSelectedFields, distinctAlias);
+	const outerScalarProjection = buildProjection(contract, addressedModel(contract, include.relatedNamespaceId, include.relatedModelName, include.nested.variantValue), child, visiblePolyProjection.baseSelectedFields, distinctAlias);
 	const outerNestedProjections = buildNestedIncludeProjections(contract, aggregates, scope, {
 		tables: childState.tables,
 		projectedThrough: distinctAlias
@@ -2321,9 +2332,9 @@ function buildSelectAst(contract, modelName, state, options) {
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
 	}
-	const addressed = addressedModelName(modelName, state.variantName);
+	const addressed = addressedModel(contract, namespaceId, modelName, state.variantValue);
 	const projection = [...buildProjection(contract, addressed, root, state.selectedFields), ...options.includeProjection ?? []];
-	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, state, options.where ?? buildStateWhere(contract, state), getColumnsReadOnTable(contract, namespaceId, addressed, tableName).map((column) => ProjectionItem.of(column, root.column(column))));
+	const { source: fromSource, where: effectiveWhere } = buildDedupedTableSource(contract, state, options.where ?? buildStateWhere(contract, state), getColumnsReadOnTable(contract, ...addressed, tableName, namespaceId).map((column) => ProjectionItem.of(column, root.column(column))));
 	let ast = SelectAst.from(fromSource).withProjection(projection);
 	if (effectiveWhere) ast = ast.withWhere(effectiveWhere);
 	if (state.orderBy) ast = ast.withOrderBy(state.orderBy);
@@ -2345,7 +2356,7 @@ function buildRootPolymorphism(contract, state, modelName) {
 		projection: []
 	};
 	const selection = resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state);
-	const mtiArtifacts = polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantName, selection.selectedMtiColumnsByVariant) : void 0;
+	const mtiArtifacts = polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantValue, selection.selectedMtiColumnsByVariant) : void 0;
 	return {
 		projectionState: {
 			...state,
@@ -2406,7 +2417,7 @@ function describeExecutionRows(options) {
 	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
 	if (state.includes.length === 0) {
 		const compiled = compileSelect(contract, modelName, state);
-		const mapper = polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, rawRow, state.variantName)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow));
+		const mapper = polyInfo ? (rawRow) => blindCast(mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, rawRow, state.variantValue)) : (rawRow) => blindCast(mapStorageRowToModelFields(contract, namespaceId, modelName, rawRow));
 		return {
 			plan: compiled,
 			consume: (rows) => mapResultRows(rows, mapper)
@@ -2430,7 +2441,7 @@ function deferResolution(resolve) {
 function createPreparedMapper(contract, namespaceId, modelName, state) {
 	const resolved = deferResolution(() => {
 		const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-		return polyInfo ? createPolymorphicRowMapper(contract, namespaceId, modelName, polyInfo, state.tables, state.variantName) : createStorageRowMapper(contract, namespaceId, modelName);
+		return polyInfo ? createPolymorphicRowMapper(contract, namespaceId, modelName, polyInfo, state.tables, state.variantValue) : createStorageRowMapper(contract, namespaceId, modelName);
 	});
 	return (row) => resolved()(row);
 }
@@ -2479,10 +2490,10 @@ function createPreparedIncludeConsumer(context, include) {
 	const mapRow = createPreparedMapper(contract, include.relatedNamespaceId, include.relatedModelName, include.nested);
 	const bindings = deferResolution(() => {
 		const namespace = include.relatedNamespaceId;
-		const keys = new Set(getColumnsReadOnTable(contract, namespace, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName));
+		const keys = new Set(getColumnsReadOnTable(contract, ...addressedModel(contract, namespace, include.relatedModelName, include.nested.variantValue), include.relatedTableName, namespace));
 		const polyInfo = resolvePolymorphismInfo(contract, namespace, include.relatedModelName);
 		for (const variant of polyInfo?.mtiVariants ?? []) {
-			const variantTable = requireVariantTable(include.nested.tables, variant.modelName);
+			const variantTable = requireVariantTable(include.nested.tables, variant.value);
 			for (const column of getColumnsReadOnTable(contract, variantTable.storage.namespaceId, variant.modelName, variantTable.storage.tableName)) keys.add(variantColumnLabel(variantTable, column));
 		}
 		return new Map([...keys].map((key) => [key, deferResolution(() => resolveIncludedColumnBinding(contract, context, include, key))]));
@@ -2595,7 +2606,7 @@ function consumeIncludeRows(context, state, namespaceId, modelName, rows) {
 		const parentRows = parentRowsRaw.map((row) => {
 			return {
 				raw: row,
-				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
+				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, row, state.variantValue) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
 			};
 		});
 		const bindings = /* @__PURE__ */ new WeakMap();
@@ -2688,7 +2699,7 @@ function decodeIncludePayload(contract, context, include, raw, bindings) {
 	if (include.combine) return decodeCombineIncludePayload(contract, context, include, include.combine, raw, bindings);
 	const rawChildren = parseIncludedRows(include, raw);
 	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
-	const mapChildRow = polyInfo ? (childRow) => mapPolymorphicRow(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, include.nested.tables, childRow, include.nested.variantName) : createStorageRowMapper(contract, include.relatedNamespaceId, include.relatedModelName);
+	const mapChildRow = polyInfo ? (childRow) => mapPolymorphicRow(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, include.nested.tables, childRow, include.nested.variantValue) : createStorageRowMapper(contract, include.relatedNamespaceId, include.relatedModelName);
 	let columns = bindings.get(include);
 	if (!columns) {
 		columns = /* @__PURE__ */ new Map();
@@ -2751,7 +2762,7 @@ function resolveIncludedColumnRef(contract, include, key) {
 	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
 	if (!polyInfo) return;
 	for (const variant of polyInfo.mtiVariants) {
-		const variantTable = requireVariantTable(include.nested.tables, variant.modelName);
+		const variantTable = requireVariantTable(include.nested.tables, variant.value);
 		const prefix = variantColumnLabelPrefix(variantTable);
 		if (!key.startsWith(prefix)) continue;
 		const column = key.slice(prefix.length);
@@ -2920,14 +2931,14 @@ function parseIncludePayload(value) {
 		return [];
 	}
 }
-function createMutationRowMapper(contract, namespaceId, modelName, tables, variantName) {
+function createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue) {
 	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, row, variantName) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
+	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, row, variantValue) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
 }
 function dispatchMutationRows(options) {
-	const { context, runtime, compiled, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { context, runtime, compiled, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
 	if (includes.length === 0) return mapResultRows(queryPlanRows(runtime, compiled), (rawRow) => {
 		const mapped = mapStorageRow(rawRow);
 		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
@@ -2949,9 +2960,9 @@ function dispatchMutationRows(options) {
 	return new AsyncIterableResult(generator());
 }
 function dispatchSplitMutationRows(options) {
-	const { context, runtime, plans, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { context, runtime, plans, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
 	const generator = async function* () {
 		if (includes.length > 0) {
 			const identityRows = [];
@@ -2977,9 +2988,9 @@ function dispatchSplitMutationRows(options) {
 	return new AsyncIterableResult(generator());
 }
 async function executeMutationReturningSingleRow(options) {
-	const { context, runtime, compiled, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
+	const { context, runtime, compiled, tables, modelName, namespaceId, variantValue, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantValue);
 	if (includes.length === 0) {
 		const first = (await queryPlanRows(runtime, compiled).toArray())[0];
 		if (!first) return null;
@@ -3157,7 +3168,7 @@ function assertModelFragmentReceiver(source, value) {
 }
 function firstQueryState(state) {
 	return [
-		["a variant", state.variantName !== void 0],
+		["a variant", state.variantValue !== void 0],
 		["a cursor", state.cursor !== void 0],
 		["distinctOn", state.distinctOn !== void 0],
 		["distinct", state.distinct !== void 0],
@@ -3242,7 +3253,7 @@ function assertDeclaredFieldsFragmentFields(collection, fields) {
 			meta
 		});
 		const fieldMany = multiplicity(domainFieldOf(contract, namespaceId, modelName, name)?.many);
-		const column = resolveColumn(contract, namespaceId, fieldColumn.table, fieldColumn.column);
+		const column = resolveColumn(contract, fieldColumn.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,
@@ -3329,7 +3340,7 @@ function fieldCodecId(collection, field) {
 	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;
+	return resolveColumn(contract, fieldColumn.namespaceId, fieldColumn.table, fieldColumn.column)?.codecId;
 }
 /** The domain declaration of a model's own or inherited field. */
 function domainFieldOf(contract, namespaceId, modelName, name) {
@@ -3509,8 +3520,8 @@ function createCallbackTools(context, indexes) {
 function hasThrough$1(relation) {
 	return relation.through !== void 0;
 }
-function createModelAccessor(context, namespaceId, modelName, tables, variantName) {
-	return createModelAccessorInScope(context, namespaceId, modelName, variantName, tables.scope, tables.root, variantName === void 0 ? void 0 : tables.variants.get(variantName));
+function createModelAccessor(context, namespaceId, modelName, tables, variantValue) {
+	return createModelAccessorInScope(context, namespaceId, modelName, variantValue, tables.scope, tables.root, variantValue === void 0 ? void 0 : tables.variants.get(variantValue));
 }
 /**
 * The second argument of a `where` or `orderBy` callback on a collection of the model: the SQL query builder's functions, and the indexes of the model's table.
@@ -3545,14 +3556,16 @@ function indexReferencesOf(context, modelName, aliasedTable) {
 		}
 	});
 }
-function createModelAccessorInScope(context, namespaceId, modelName, variantName, scope, table, variantTable) {
+function createModelAccessorInScope(context, namespaceId, modelName, variantValue, scope, table, variantTable) {
 	const contract = context.contract;
-	const fieldColumns = getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantName);
+	const fieldColumns = getModelAndVariantFieldColumns(contract, namespaceId, modelName, variantValue);
 	const modelRelations = resolveModelRelations(contract, namespaceId, modelName);
-	const variantFieldColumns = variantName ? resolveVariantFieldColumns(contract, namespaceId, modelName, variantName) : {};
-	const variantCoordinates = variantName ? {
-		name: variantName,
-		relations: resolveModelRelations(contract, namespaceId, variantName)
+	const variantFieldColumns = variantValue ? resolveVariantFieldColumns(contract, namespaceId, modelName, variantValue) : {};
+	const [addressedNamespaceId, addressed] = addressedModel(contract, namespaceId, modelName, variantValue);
+	const variantCoordinates = variantValue ? {
+		namespaceId: addressedNamespaceId,
+		name: addressed,
+		relations: resolveModelRelations(contract, addressedNamespaceId, addressed)
 	} : void 0;
 	const variantFieldTable = variantTable ?? table;
 	const opsByCodecId = /* @__PURE__ */ new Map();
@@ -3578,7 +3591,7 @@ function createModelAccessorInScope(context, namespaceId, modelName, variantName
 		if (typeof prop !== "string") return;
 		if (variantCoordinates && Object.hasOwn(variantCoordinates.relations, prop)) {
 			const variantRelation = variantCoordinates.relations[prop];
-			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, scope, variantFieldTable, variantRelation);
+			if (variantRelation) return createRelationFilterAccessor(context, variantCoordinates.namespaceId, variantCoordinates.name, scope, variantFieldTable, variantRelation);
 		}
 		const relation = Object.hasOwn(modelRelations, prop) ? modelRelations[prop] : void 0;
 		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, scope, table, relation);
@@ -3588,7 +3601,7 @@ function createModelAccessorInScope(context, namespaceId, modelName, variantName
 		}
 		const fieldTable = variantField ? variantFieldTable : table;
 		const fieldStorage = fieldTable.storage;
-		const columnName = variantField?.column ?? columnOfCallerField(contract, namespaceId, fieldColumns, addressedModelName(modelName, variantName), prop);
+		const columnName = variantField?.column ?? columnOfCallerField(contract, addressedNamespaceId, fieldColumns, addressed, prop);
 		const column = resolveColumn(contract, fieldStorage.namespaceId, fieldStorage.tableName, columnName);
 		if (!column) throw new InternalError(`Field "${modelName}.${prop}" maps column "${columnName}", which table "${fieldStorage.tableName}" does not have`);
 		const traits = codecTraits(context, column.codecId);
@@ -4798,7 +4811,7 @@ var CollectionBase = class CollectionBase {
 	}
 	where(input) {
 		const tables = withScopeCopy(this.state.tables);
-		const filter = normalizeWhereArg(typeof input === "function" ? whereArgOf(input(createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables, this.state.variantName), this.#callbackTools(tables))) : isWhereDirectInput(input) ? input : shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, input, tables.root), {
+		const filter = normalizeWhereArg(typeof input === "function" ? whereArgOf(input(createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables, this.state.variantValue), this.#callbackTools(tables))) : isWhereDirectInput(input) ? input : shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, input, tables.root), {
 			contract: this.contract,
 			tables: tableAliases(tables)
 		});
@@ -4855,20 +4868,17 @@ var CollectionBase = class CollectionBase {
 	}
 	variant(value) {
 		const polyInfo = resolvePolymorphismInfo(this.contract, this.namespaceId, this.modelName);
-		const selectedVariantName = this.state.variantName;
-		if (selectedVariantName !== void 0) {
-			const selectedValue = polyInfo?.variants.get(selectedVariantName)?.value;
-			throw ormError("ORM.OPERATION_UNSUPPORTED", `variant("${value}") cannot be called on model "${this.modelName}" because variant("${selectedValue}") is already selected; call variant() on the base collection instead`, { meta: {
-				method: "variant",
-				model: this.modelName,
-				variant: selectedVariantName,
-				selectedValue,
-				reason: "variant-already-selected"
-			} });
-		}
-		const variantInfo = polyInfo?.variantsByValue.get(value);
+		const selectedVariantValue = this.state.variantValue;
+		if (selectedVariantValue !== void 0) throw ormError("ORM.OPERATION_UNSUPPORTED", `variant("${value}") cannot be called on model "${this.modelName}" because variant("${selectedVariantValue}") is already selected; call variant() on the base collection instead`, { meta: {
+			method: "variant",
+			model: this.modelName,
+			variant: polyInfo?.variants.get(selectedVariantValue)?.modelName,
+			selectedValue: selectedVariantValue,
+			reason: "variant-already-selected"
+		} });
+		const variantInfo = polyInfo?.variants.get(value);
 		if (!polyInfo || !variantInfo) {
-			const declaredValues = [...polyInfo?.variantsByValue.keys() ?? []];
+			const declaredValues = [...polyInfo?.variants.keys() ?? []];
 			throw ormError("ORM.ARGUMENT_INVALID", declaredValues.length === 0 ? `variant("${value}") cannot narrow model "${this.modelName}": it declares no discriminator values` : `variant("${value}") cannot narrow model "${this.modelName}": the declared discriminator values are ${declaredValues.map((declared) => `"${declared}"`).join(", ")}`, { meta: {
 				method: "variant",
 				argument: "value",
@@ -4881,11 +4891,11 @@ var CollectionBase = class CollectionBase {
 		const filter = BinaryExpr.eq(this.state.tables.root.column(columnName), paramRefForStorageColumn(this.contract, this.state.tables.root.storage, columnName, variantInfo.value));
 		return this.#cloneWithRow({
 			filters: [...this.state.filters, filter],
-			variantName: variantInfo.modelName
+			variantValue: variantInfo.value
 		});
 	}
 	include(relationName, refineFn) {
-		const relation = resolveIncludeRelation(this.contract, this.namespaceId, this.modelName, relationName, this.state.variantName);
+		const relation = resolveIncludeRelation(this.contract, this.namespaceId, this.modelName, relationName, this.state.variantValue);
 		const child = createIncludeTables(this.contract, this.state.tables, relation);
 		let nestedState = emptyState(child.tables);
 		let adoptedScope = child.tables.scope;
@@ -4922,7 +4932,7 @@ var CollectionBase = class CollectionBase {
 			relatedModelName: relation.relatedModelName,
 			relatedNamespaceId: relation.relatedNamespaceId,
 			relatedTableName: relation.relatedTableName,
-			...ifDefined("localVariantName", relation.localVariantName),
+			...ifDefined("localVariantValue", relation.localVariantValue),
 			targetColumns: relation.targetColumns,
 			localColumns: relation.localColumns,
 			cardinality: relation.cardinality,
@@ -4941,12 +4951,12 @@ var CollectionBase = class CollectionBase {
 		});
 	}
 	select(...fields) {
-		const selectedFields = mapSelectedFieldsToColumns(this.contract, this.namespaceId, this.modelName, this.state.variantName, fields);
+		const selectedFields = mapSelectedFieldsToColumns(this.contract, this.namespaceId, this.modelName, this.state.variantValue, fields);
 		return this.#cloneWithRow({ selectedFields });
 	}
 	orderBy(selection) {
 		const tables = withScopeCopy(this.state.tables);
-		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables, this.state.variantName);
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables, this.state.variantValue);
 		const tools = this.#callbackTools(tables);
 		const nextOrders = (Array.isArray(selection) ? selection : [selection]).map((selector) => selector(accessor, tools));
 		const existing = this.state.orderBy ?? [];
@@ -5183,7 +5193,7 @@ var CollectionBase = class CollectionBase {
 				tables: this.state.tables,
 				modelName: this.modelName,
 				namespaceId: this.namespaceId,
-				variantName: this.state.variantName,
+				variantValue: this.state.variantValue,
 				includes: this.state.includes,
 				selectedFields: this.state.selectedFields,
 				hiddenColumns,
@@ -5198,7 +5208,7 @@ var CollectionBase = class CollectionBase {
 			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
-			variantName: this.state.variantName,
+			variantValue: this.state.variantValue,
 			includes: this.state.includes,
 			selectedFields: this.state.selectedFields,
 			hiddenColumns,
@@ -5218,36 +5228,39 @@ var CollectionBase = class CollectionBase {
 		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.`);
+		this.#refuseOnMtiVariant(method, `${method} is not supported for MTI variant "${this.#variantModelName()}" on model "${this.modelName}". Use createAll() instead.`);
 	}
 	#assertConflictSkipNotOnMtiVariant(method) {
-		this.#refuseOnMtiVariant(method, `The onConflict option is not supported on variant "${this.state.variantName}" of model "${this.modelName}" because the variant is stored in its own table. Call createAll(rows) without the option; a duplicate row then makes the call fail.`);
+		this.#refuseOnMtiVariant(method, `The onConflict option is not supported on variant "${this.#variantModelName()}" of model "${this.modelName}" because the variant is stored in its own table. Call createAll(rows) without the option; a duplicate row then makes the call fail.`);
 	}
 	#refuseOnMtiVariant(method, message) {
 		if (!this.#resolveMtiCreateContext()) return;
 		throw ormError("ORM.OPERATION_UNSUPPORTED", message, { meta: {
 			method,
 			model: this.modelName,
-			variant: this.state.variantName,
+			variant: this.#variantModelName(),
 			reason: "mti-variant"
 		} });
 	}
+	#variantModelName() {
+		return addressedModel(this.contract, this.namespaceId, this.modelName, this.state.variantValue)[1];
+	}
 	#resolveMtiCreateContext() {
-		const variantName = this.state.variantName;
-		if (!variantName) return null;
+		const variantValue = this.state.variantValue;
+		if (!variantValue) return null;
 		const polyInfo = resolvePolymorphismInfo(this.contract, this.namespaceId, this.modelName);
 		if (!polyInfo) return null;
-		const variant = polyInfo.variants.get(variantName);
+		const variant = polyInfo.variants.get(variantValue);
 		if (!isMtiVariantInfo(variant)) return null;
 		const baseFieldToColumn = getModelFieldColumns(this.contract, this.namespaceId, this.modelName);
-		const variantFieldToColumn = getOwnFieldColumns(this.contract, this.namespaceId, variant.modelName);
+		const variantFieldToColumn = getOwnFieldColumns(this.contract, variant.namespaceId, variant.modelName);
 		const pkColumns = resolvePrimaryKeyColumns(this.contract, this.namespaceId, this.tableName);
 		return {
 			polyInfo,
 			variant,
 			baseFieldToColumn,
 			variantFieldToColumn,
-			mergedFieldToColumn: getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.modelName),
+			mergedFieldToColumn: getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.value),
 			pkColumns
 		};
 	}
@@ -5260,7 +5273,7 @@ var CollectionBase = class CollectionBase {
 		const modelName = this.modelName;
 		const namespaceId = this.namespaceId;
 		const tables = this.state.tables;
-		const variantTable = requireVariantTable(tables, variant.modelName);
+		const variantTable = requireVariantTable(tables, variant.value);
 		const baseFieldColumns = new Set(Object.values(baseFieldToColumn));
 		const variantFieldColumns = new Set(Object.values(variantFieldToColumn));
 		const generator = async function* () {
@@ -5269,7 +5282,7 @@ var CollectionBase = class CollectionBase {
 				const allMapped = {};
 				for (const [fieldName, value] of Object.entries(row)) {
 					if (value === void 0) continue;
-					allMapped[columnOfCallerField(contract, namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
+					allMapped[columnOfCallerField(contract, variant.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
 				}
 				allMapped[polyInfo.discriminatorColumn] = variant.value;
 				const baseRow = {};
@@ -5304,25 +5317,25 @@ var CollectionBase = class CollectionBase {
 					return mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, {
 						...baseCreated,
 						...prefixedVariant
-					}, variant.modelName);
+					}, variant.value);
 				}));
 			}
 		};
 		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 variantValue = this.state.variantValue;
+		if (!variantValue) 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);
+		const variant = polyInfo.variants.get(variantValue);
 		if (!variant) return data.map((row) => mapModelDataToStorageRow(this.contract, this.namespaceId, this.modelName, row));
-		const mergedFieldToColumn = getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.modelName);
+		const mergedFieldToColumn = getModelAndVariantFieldColumns(this.contract, this.namespaceId, this.modelName, variant.value);
 		return data.map((row) => {
 			const mapped = {};
 			for (const [fieldName, value] of Object.entries(row)) {
 				if (value === void 0) continue;
-				mapped[columnOfCallerField(this.contract, this.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
+				mapped[columnOfCallerField(this.contract, variant.namespaceId, mergedFieldToColumn, variant.modelName, fieldName)] = value;
 			}
 			mapped[polyInfo.discriminatorColumn] = variant.value;
 			return mapped;
@@ -5399,7 +5412,7 @@ var CollectionBase = class CollectionBase {
 			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
-			variantName: this.state.variantName,
+			variantValue: this.state.variantValue,
 			includes: this.state.includes,
 			selectedFields: this.state.selectedFields,
 			hiddenColumns,
@@ -5467,7 +5480,7 @@ var CollectionBase = class CollectionBase {
 			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
-			variantName: this.state.variantName,
+			variantValue: this.state.variantValue,
 			includes: this.state.includes,
 			selectedFields: this.state.selectedFields,
 			hiddenColumns,
@@ -5481,7 +5494,7 @@ var CollectionBase = class CollectionBase {
 		if (Object.keys(mappedData).length === 0) return 0;
 		applyUpdateDefaults(this.ctx, this.namespaceId, this.tableName, mappedData);
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "updateAndCount");
-		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.state.tables, mappedData, this.state.filters, this.state.variantName), annotationsMap);
+		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.state.tables, mappedData, this.state.filters, this.state.variantValue), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	async delete(configure) {
@@ -5519,7 +5532,7 @@ var CollectionBase = class CollectionBase {
 			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
-			variantName: this.state.variantName,
+			variantValue: this.state.variantValue,
 			includes: this.state.includes,
 			selectedFields: this.state.selectedFields,
 			hiddenColumns,
@@ -5550,7 +5563,7 @@ var CollectionBase = class CollectionBase {
 					modelName: collection.modelName,
 					namespaceId: collection.namespaceId
 				}).toArray();
-				const deletePlan = mergeAnnotations(compileDeleteCount(collection.contract, collection.state.tables, collection.state.filters, collection.state.variantName), annotationsMap);
+				const deletePlan = mergeAnnotations(compileDeleteCount(collection.contract, collection.state.tables, collection.state.filters, collection.state.variantValue), annotationsMap);
 				await scope.execute(deletePlan);
 				return rows;
 			});
@@ -5562,7 +5575,7 @@ var CollectionBase = class CollectionBase {
 		assertBulkWriteIgnoresNothing(this.state, this.modelName, "deleteAndCount");
 		assertLockCompatible(this.state, "mutation");
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "write", "deleteAndCount");
-		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.state.tables, this.state.filters, this.state.variantName), annotationsMap);
+		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.state.tables, this.state.filters, this.state.variantValue), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	#buildUpsertConflictCriterion(createValues, conflictColumns) {