@prisma/orm-family-sql 8.0.0-rc.17-dev.23 → 8.0.0-rc.17-dev.24

package/dist/orm-client.mjs

@@ -377,7 +377,7 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 	const polymorphism = resolvePolymorphismInfo(contract, namespaceId, baseModelName);
 	const variant = variantName === void 0 ? void 0 : polymorphism?.variants.get(variantName);
 	let declaringModelName = baseModelName;
-	let localTableName = resolveModelTableName(contract, namespaceId, baseModelName);
+	let localVariantName;
 	let relation;
 	if (variant !== void 0) {
 		const variantRelations = resolveModelRelations(contract, namespaceId, variant.modelName);
@@ -385,7 +385,7 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 		if (candidate !== void 0) {
 			relation = candidate;
 			declaringModelName = variant.modelName;
-			localTableName = variant.table;
+			localVariantName = variant.strategy === "mti" ? variant.modelName : void 0;
 		}
 	}
 	const baseRelations = resolveModelRelations(contract, namespaceId, baseModelName);
@@ -412,7 +412,7 @@ function resolveIncludeRelation(contract, namespaceId, baseModelName, relationNa
 		relatedModelName: relation.to,
 		relatedNamespaceId: relation.toNamespace,
 		relatedTableName,
-		localTableName,
+		...ifDefined("localVariantName", localVariantName),
 		targetColumns,
 		localColumns,
 		cardinality: relation.cardinality,
@@ -677,6 +677,108 @@ function mapCursorValuesToColumns(contract, namespaceId, modelName, cursorValues
 	}
 	return mappedCursor;
 }
+const MAX_ALIAS_BYTES = 63;
+const encoder = new TextEncoder();
+function shortenToBytes(value, maxBytes) {
+	let shortened = "";
+	let bytes = 0;
+	for (const character of value) {
+		bytes += encoder.encode(character).length;
+		if (bytes > maxBytes) break;
+		shortened += character;
+	}
+	return shortened;
+}
+var TableScopeImpl = class TableScopeImpl {
+	#aliases;
+	constructor(aliases = []) {
+		this.#aliases = new Set(aliases);
+	}
+	alias(preferred) {
+		for (let n = 1;; n += 1) {
+			const suffix = n === 1 ? "" : `_${n}`;
+			const candidate = `${shortenToBytes(preferred, MAX_ALIAS_BYTES - suffix.length)}${suffix}`;
+			if (!this.#aliases.has(candidate)) {
+				this.#aliases.add(candidate);
+				return candidate;
+			}
+		}
+	}
+	aliasTable(storage) {
+		const alias = this.alias(storage.tableName);
+		const coordinate = Object.freeze({ ...storage });
+		return Object.freeze({
+			alias,
+			storage: coordinate,
+			column: (name) => ColumnRef.of(alias, name),
+			tableSource: (contract) => tableSourceForContract(contract, coordinate.namespaceId, coordinate.tableName, alias)
+		});
+	}
+	copy() {
+		return new TableScopeImpl(this.#aliases);
+	}
+};
+function createTableScope() {
+	return new TableScopeImpl();
+}
+function createModelTables(contract, scope, namespaceId, modelName, tableName) {
+	const root = scope.aliasTable({
+		namespaceId,
+		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,
+		tableName: variant.table
+	}));
+	return {
+		scope,
+		root,
+		variants
+	};
+}
+function createCollectionTables(contract, namespaceId, modelName, tableName = resolveModelTableName(contract, namespaceId, modelName)) {
+	return createModelTables(contract, createTableScope(), namespaceId, modelName, tableName);
+}
+function createIncludeTables(contract, parent, relation) {
+	const scope = parent.scope.copy();
+	return {
+		tables: createModelTables(contract, scope, relation.relatedNamespaceId, relation.relatedModelName, relation.relatedTableName),
+		junction: relation.through === void 0 ? void 0 : scope.aliasTable({
+			namespaceId: relation.through.namespaceId,
+			tableName: relation.through.table
+		})
+	};
+}
+function createStatementTables(storage) {
+	const scope = createTableScope();
+	return {
+		scope,
+		root: scope.aliasTable(storage),
+		variants: /* @__PURE__ */ new Map()
+	};
+}
+function withScopeCopy(tables) {
+	return {
+		...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}"`);
+	return variantTable;
+}
+function tableAliases(tables) {
+	return new Map([tables.root, ...tables.variants.values()].map((table) => [table.alias, table.storage]));
+}
+function variantColumnLabelPrefix(variantTable) {
+	return `${variantTable.alias}__`;
+}
+function variantColumnLabel(variantTable, column) {
+	return `${variantColumnLabelPrefix(variantTable)}${column}`;
+}
 function stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns) {
 	if (hiddenColumns.length === 0) return;
 	const columnToField = getModelColumnFields(contract, namespaceId, modelName);
@@ -694,7 +796,7 @@ function createStorageRowMapper(contract, namespaceId, modelName) {
 }
 const mergedColumnToFieldCache = /* @__PURE__ */ new WeakMap();
 function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variantModelName, variantTable) {
-	const cacheKey = `${namespaceId}:${baseModelName}:${variantModelName}:${variantTable ?? ""}`;
+	const cacheKey = `${namespaceId}:${baseModelName}:${variantModelName}:${variantTable?.alias ?? ""}`;
 	let perContract = mergedColumnToFieldCache.get(contract);
 	if (!perContract) {
 		perContract = /* @__PURE__ */ new Map();
@@ -705,25 +807,27 @@ function getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant
 	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;
+	for (const [col, field] of Object.entries(variantMap)) if (variantTable) merged[variantColumnLabel(variantTable, col)] = field;
 	else merged[col] = field;
 	perContract.set(cacheKey, merged);
 	return merged;
 }
-function mapPolymorphicRow(contract, namespaceId, baseModelName, polyInfo, row, variantName) {
+function variantTableOf(tables, variant) {
+	return variant.strategy === "mti" ? requireVariantTable(tables, variant.modelName) : void 0;
+}
+function mapPolymorphicRow(contract, namespaceId, baseModelName, polyInfo, tables, 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, getModelColumnFields(contract, namespaceId, baseModelName));
-	const mtiTable = variant.strategy === "mti" ? variant.table : void 0;
-	return mapKnownColumnNames(row, getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, mtiTable));
+	return mapKnownColumnNames(row, getMergedColumnToFieldMap(contract, namespaceId, baseModelName, variant.modelName, variantTableOf(tables, variant)));
 }
-function createPolymorphicRowMapper(contract, namespaceId, baseModelName, polyInfo, variantName) {
+function createPolymorphicRowMapper(contract, namespaceId, baseModelName, polyInfo, tables, variantName) {
 	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, variant.strategy === "mti" ? variant.table : void 0));
+		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);
 	}
@@ -872,43 +976,43 @@ function mergeAnnotations(plan, annotations) {
 		})
 	});
 }
-function namespaceCoordinateForSource(source) {
-	return source.kind === "table-source" ? source.namespaceId : void 0;
+function bindWhereExpr(contract, expr, aliases) {
+	return bindWhereExprInScope(contract, expr, aliases);
 }
-function bindWhereExpr(contract, expr, namespaceId) {
+function bindWhereExprInScope(contract, expr, aliases) {
 	return expr.accept({
 		columnRef(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		identifierRef(expr) {
 			return expr;
 		},
 		subquery(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		operation(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		aggregate(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		windowFunc(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		functionCall(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		cast(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		case(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		jsonObject(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		jsonArrayAgg(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		literal(expr) {
 			return expr;
@@ -920,81 +1024,92 @@ function bindWhereExpr(contract, expr, namespaceId) {
 			return expr;
 		},
 		list(expr) {
-			return bindExpression(contract, expr);
+			return bindExpression(contract, expr, aliases);
 		},
 		binary(expr) {
-			const left = bindExpression(contract, expr.left);
+			const left = bindExpression(contract, expr.left, aliases);
 			const bindingColumn = left.kind === "column-ref" ? left : void 0;
-			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, namespaceId));
+			return new BinaryExpr(expr.op, left, bindComparable(contract, expr.right, bindingColumn, aliases));
 		},
 		and(expr) {
-			return AndExpr.of(expr.exprs.map((part) => bindWhereExpr(contract, part, namespaceId)));
+			return AndExpr.of(expr.exprs.map((part) => bindWhereExprInScope(contract, part, aliases)));
 		},
 		or(expr) {
-			return OrExpr.of(expr.exprs.map((part) => bindWhereExpr(contract, part, namespaceId)));
+			return OrExpr.of(expr.exprs.map((part) => bindWhereExprInScope(contract, part, aliases)));
 		},
 		exists(expr) {
-			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery));
+			return expr.notExists ? ExistsExpr.notExists(bindSelectAst(contract, expr.subquery, aliases)) : ExistsExpr.exists(bindSelectAst(contract, expr.subquery, aliases));
 		},
 		nullCheck(expr) {
-			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr));
+			return expr.isNull ? NullCheckExpr.isNull(bindExpression(contract, expr.expr, aliases)) : NullCheckExpr.isNotNull(bindExpression(contract, expr.expr, aliases));
 		},
 		not(expr) {
-			return new NotExpr(bindWhereExpr(contract, expr.expr, namespaceId));
+			return new NotExpr(bindWhereExprInScope(contract, expr.expr, aliases));
 		},
 		rawExpr(expr) {
 			return expr;
 		}
 	});
 }
-function bindComparable(contract, comparable, bindingColumn, namespaceId) {
-	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable);
-	if (comparable.kind === "literal") return createParamRef(contract, bindingColumn, comparable.value, namespaceId);
-	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? createParamRef(contract, bindingColumn, value.value, namespaceId) : value));
-	return bindExpression(contract, comparable);
-}
-function createParamRef(contract, columnRef, value, namespaceId) {
-	const resolved = resolveStorageTable(contract.storage, columnRef.table, namespaceId);
-	if (resolved === void 0 || !resolved.table.columns[columnRef.column]) throw ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${columnRef.column}" in table "${columnRef.table}"`, { meta: {
-		tableName: columnRef.table,
-		column: columnRef.column
+function bindComparable(contract, comparable, bindingColumn, aliases) {
+	if (comparable.kind === "param-ref" || bindingColumn === void 0) return comparable.kind === "param-ref" ? comparable : comparable.kind === "literal" || comparable.kind === "list" ? comparable : bindExpression(contract, comparable, aliases);
+	if (comparable.kind === "literal") return paramRefForAlias(contract, bindingColumn, comparable.value, aliases);
+	if (comparable.kind === "list") return ListExpression.of(comparable.values.map((value) => value.kind === "literal" ? paramRefForAlias(contract, bindingColumn, value.value, aliases) : value));
+	return bindExpression(contract, comparable, aliases);
+}
+function unknownColumn(alias, column) {
+	return ormError("ORM.COLUMN_UNKNOWN", `Unknown column "${column}" in table "${alias}"`, { meta: {
+		tableName: alias,
+		column
 	} });
-	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, columnRef.table, columnRef.column);
-	return ParamRef.of(value, codec ? { codec } : void 0);
 }
-function createExpressionBinder(contract) {
-	return { select: (ast) => bindSelectAst(contract, ast) };
+function paramRefForAlias(contract, columnRef, value, aliases) {
+	const coordinate = aliases.get(columnRef.table);
+	if (coordinate === void 0) throw unknownColumn(columnRef.table, columnRef.column);
+	return paramRefForTable(contract, coordinate, columnRef.table, columnRef.column, value);
+}
+function paramRefForTable(contract, coordinate, alias, column, value) {
+	const resolved = resolveStorageTable(contract.storage, coordinate.tableName, coordinate.namespaceId);
+	if (resolved === void 0 || !resolved.table.columns[column]) throw unknownColumn(alias, column);
+	const codec = codecRefForStorageColumn(contract.storage, resolved.namespaceId, coordinate.tableName, column);
+	return ParamRef.of(value, codec ? { codec } : void 0);
 }
-function bindExpression(contract, expr) {
-	return expr.rewrite(createExpressionBinder(contract));
+function paramRefForStorageColumn(contract, storage, column, value) {
+	return paramRefForTable(contract, storage, storage.tableName, column, value);
 }
-function bindProjectionExpr(contract, expr) {
-	return expr.kind === "literal" ? expr : bindExpression(contract, expr);
+function bindExpression(contract, expr, aliases) {
+	return expr.rewrite({ select: (ast) => bindSelectAst(contract, ast, aliases) });
 }
-function bindOrderByItem(contract, orderItem) {
-	return orderItem.withExpr(bindExpression(contract, orderItem.expr));
+function bindProjectionExpr(contract, expr, aliases) {
+	return expr.kind === "literal" ? expr : bindExpression(contract, expr, aliases);
 }
-function bindJoin(contract, join) {
-	const namespaceId = namespaceCoordinateForSource(join.source);
-	return new JoinAst(join.joinType, bindFromSource(contract, join.source), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExpr(contract, join.on, namespaceId), join.lateral);
+function bindJoin(contract, join, aliases) {
+	return new JoinAst(join.joinType, bindFromSource(contract, join.source, aliases), join.on.kind === "eq-col-join-on" ? join.on : bindWhereExprInScope(contract, join.on, aliases), join.lateral);
 }
-function bindFromSource(contract, source) {
-	if (source.kind === "table-source") return source;
-	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query));
+function bindFromSource(contract, source, aliases) {
+	if (source.kind === "derived-table-source") return DerivedTableSource.as(source.alias, bindSelectAst(contract, source.query, aliases));
 	return source;
 }
-function bindSelectAst(contract, ast) {
-	const namespaceId = ast.from !== void 0 ? namespaceCoordinateForSource(ast.from) : void 0;
+function aliasesWithSources(outer, sources) {
+	const aliases = new Map(outer);
+	for (const source of sources) if (source.kind === "table-source") aliases.set(source.alias ?? source.name, {
+		namespaceId: source.namespaceId,
+		tableName: source.name
+	});
+	return aliases;
+}
+function bindSelectAst(contract, ast, outer) {
+	const aliases = aliasesWithSources(outer, [...ast.from !== void 0 ? [ast.from] : [], ...(ast.joins ?? []).map((join) => join.source)]);
 	return new SelectAst({
-		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from) } : {},
-		joins: ast.joins?.map((join) => bindJoin(contract, join)),
-		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codec)),
-		where: ast.where ? bindWhereExpr(contract, ast.where, namespaceId) : void 0,
-		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
+		...ast.from !== void 0 ? { from: bindFromSource(contract, ast.from, outer) } : {},
+		joins: ast.joins?.map((join) => bindJoin(contract, join, aliases)),
+		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr, aliases), projection.codec)),
+		where: ast.where ? bindWhereExprInScope(contract, ast.where, aliases) : void 0,
+		orderBy: ast.orderBy?.map((orderItem) => orderItem.withExpr(bindExpression(contract, orderItem.expr, aliases))),
 		distinct: ast.distinct,
-		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr)),
-		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr)),
-		having: ast.having ? bindWhereExpr(contract, ast.having, namespaceId) : void 0,
+		distinctOn: ast.distinctOn?.map((expr) => bindExpression(contract, expr, aliases)),
+		groupBy: ast.groupBy?.map((expr) => bindExpression(contract, expr, aliases)),
+		having: ast.having ? bindWhereExprInScope(contract, ast.having, aliases) : void 0,
 		limit: ast.limit,
 		offset: ast.offset,
 		locking: ast.locking,
@@ -1006,14 +1121,14 @@ function combineWhereExprs(filters) {
 	if (filters.length === 1) return filters[0];
 	return AndExpr.of(filters);
 }
-function createBoundaryExpr(tableName, entry) {
-	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
+function createBoundaryExpr(contract, table, entry) {
+	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", table.column(entry.column), paramRefForStorageColumn(contract, table.storage, entry.column, entry.value));
 }
-function buildLexicographicCursorWhere(tableName, entries) {
+function buildLexicographicCursorWhere(contract, table, entries) {
 	const branches = entries.map((entry, index) => {
 		const branchExprs = [];
-		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(ColumnRef.of(tableName, prefixEntry.column), LiteralExpr.of(prefixEntry.value)));
-		branchExprs.push(createBoundaryExpr(tableName, entry));
+		for (const prefixEntry of entries.slice(0, index)) branchExprs.push(BinaryExpr.eq(table.column(prefixEntry.column), paramRefForStorageColumn(contract, table.storage, prefixEntry.column, prefixEntry.value)));
+		branchExprs.push(createBoundaryExpr(contract, table, entry));
 		if (branchExprs.length === 1) {
 			const branch = branchExprs[0];
 			assertDefined(branch, "cursor branch contains its boundary expression");
@@ -1028,7 +1143,7 @@ function buildLexicographicCursorWhere(tableName, entries) {
 	}
 	return OrExpr.of(branches);
 }
-function buildCursorWhere(tableName, orderBy, cursor) {
+function buildCursorWhere(contract, table, orderBy, cursor) {
 	if (!cursor || !orderBy || orderBy.length === 0) return;
 	assertCursorCompatibleOrder(orderBy);
 	const entries = [];
@@ -1044,28 +1159,12 @@ function buildCursorWhere(tableName, orderBy, cursor) {
 		});
 	}
 	const firstEntry = entries[0];
-	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(tableName, firstEntry);
-	return buildLexicographicCursorWhere(tableName, entries);
-}
-function createTableRefRemapper$1(fromTable, toTable) {
-	return {
-		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
-		tableSource: (source) => {
-			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			return source;
-		},
-		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
-	};
+	if (entries.length === 1 && firstEntry !== void 0) return createBoundaryExpr(contract, table, firstEntry);
+	return buildLexicographicCursorWhere(contract, table, entries);
 }
-function buildStateWhere(contract, tableName, state, options) {
-	const filterTableName = options?.filterTableName;
-	const cursorWhere = buildCursorWhere(filterTableName ?? tableName, state.orderBy, state.cursor);
-	const boundFilters = state.filters.map((filter) => bindWhereExpr(contract, filter, options?.namespaceId));
-	const remappedFilters = filterTableName && filterTableName !== tableName ? boundFilters.map((filter) => filter.rewrite(createTableRefRemapper$1(filterTableName, tableName))) : boundFilters;
-	const boundCursorWhere = cursorWhere ? bindWhereExpr(contract, cursorWhere, options?.namespaceId) : void 0;
-	const remappedCursorWhere = boundCursorWhere && filterTableName && filterTableName !== tableName ? boundCursorWhere.rewrite(createTableRefRemapper$1(filterTableName, tableName)) : boundCursorWhere;
-	return combineWhereExprs(remappedCursorWhere ? [...remappedFilters, remappedCursorWhere] : remappedFilters);
+function buildStateWhere(contract, state) {
+	const cursorWhere = buildCursorWhere(contract, state.tables.root, state.orderBy, state.cursor);
+	return combineWhereExprs(cursorWhere ? [...state.filters, cursorWhere] : state.filters);
 }
 /**
 * Wrap a base SELECT in a `ROW_NUMBER() OVER (PARTITION BY … ORDER BY …) = 1`
@@ -1098,32 +1197,33 @@ function wrapWithRowNumberDedup(options) {
 }
 /**
 * FROM source + WHERE for `state.distinct`: wraps in a `ROW_NUMBER`-ranked
-* derived table aliased back to `tableName`, so callers need no rewriting.
+* derived table aliased back to the root alias, so callers need no rewriting.
 */
-function buildDedupedTableSource(contract, namespaceId, tableName, state, where, wrapProjection, joins) {
+function buildDedupedTableSource(contract, state, where, wrapProjection, joins) {
+	const { root } = state.tables;
 	if (!hasEntries(state.distinct)) return {
-		source: tableSourceForContract(contract, namespaceId, tableName),
+		source: root.tableSource(contract),
 		where
 	};
-	const distinctColumnRefs = state.distinct.map((column) => ColumnRef.of(tableName, column));
+	const distinctColumnRefs = state.distinct.map((column) => root.column(column));
 	const rankingOrderBy = hasEntries(state.orderBy) ? state.orderBy : distinctColumnRefs.map((expr) => OrderByItem.asc(expr));
-	let inner = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection([...wrapProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
+	let inner = SelectAst.from(root.tableSource(contract)).withProjection([...wrapProjection, ProjectionItem.of("__prisma_distinct_rn", WindowFuncExpr.rowNumber({
 		partitionBy: distinctColumnRefs,
 		orderBy: rankingOrderBy
 	}))]);
 	if (joins && joins.length > 0) inner = inner.withJoins(joins);
 	if (where) inner = inner.withWhere(where);
 	return {
-		source: DerivedTableSource.as(tableName, inner),
-		where: BinaryExpr.eq(ColumnRef.of(tableName, "__prisma_distinct_rn"), LiteralExpr.of(1))
+		source: DerivedTableSource.as(root.alias, inner),
+		where: BinaryExpr.eq(root.column("__prisma_distinct_rn"), LiteralExpr.of(1))
 	};
 }
-function buildPrimaryKeyJoinOn(leftTable, rightTable, primaryKeyColumns) {
+function buildPrimaryKeyJoinOn(left, right, primaryKeyColumns) {
 	const [firstColumn] = primaryKeyColumns;
-	if (primaryKeyColumns.length === 1 && firstColumn !== void 0) return EqColJoinOn.of(ColumnRef.of(leftTable, firstColumn), ColumnRef.of(rightTable, firstColumn));
-	return AndExpr.of(primaryKeyColumns.map((column) => BinaryExpr.eq(ColumnRef.of(leftTable, column), ColumnRef.of(rightTable, column))));
+	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, namespaceId, polyInfo, variantName, selectedColumnsByTable) {
+function buildMtiJoins(contract, tables, polyInfo, variantName, selectedColumnsByVariant) {
 	const joins = [];
 	const projection = [];
 	const variantsToJoin = variantName ? polyInfo.mtiVariants.filter((v) => v.modelName === variantName) : polyInfo.mtiVariants;
@@ -1131,19 +1231,19 @@ function buildMtiJoins(contract, namespaceId, polyInfo, variantName, selectedCol
 		joins,
 		projection
 	};
-	const pkColumns = resolvePrimaryKeyColumns(contract, namespaceId, polyInfo.baseTable);
+	const { root } = tables;
+	const pkColumns = resolvePrimaryKeyColumns(contract, root.storage.namespaceId, root.storage.tableName);
 	for (const variant of variantsToJoin) {
-		const joinType = variantName ? "inner" : "left";
-		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 = getColumnsReadOnTable(contract, namespaceId, variant.modelName, variant.table);
-		const selectedVariantColumns = selectedColumnsByTable?.get(variant.table);
+		const variantTable = requireVariantTable(tables, variant.modelName);
+		const joinOn = buildPrimaryKeyJoinOn(root, variantTable, pkColumns);
+		joins.push(variantName ? 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);
 		for (const col of variantColumns) {
 			if (pkColumns.includes(col)) continue;
-			if (selectedColumnsByTable !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
-			const alias = `${variant.table}__${col}`;
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), codecRefForStorageColumn(contract.storage, namespaceId, variant.table, col)));
+			if (selectedColumnsByVariant !== void 0 && selectedVariantColumns?.has(col) !== true) continue;
+			projection.push(ProjectionItem.of(variantColumnLabel(variantTable, col), variantTable.column(col), codecRefForStorageColumn(contract.storage, namespaceId, tableName, col)));
 		}
 	}
 	return {
@@ -1155,30 +1255,31 @@ function hasEntries(value) {
 	return value !== void 0 && value.length > 0;
 }
 /**
-* The rows an aggregate reduces over, one SELECT aliased to `tableName` — an
+* The rows an aggregate reduces over, one SELECT aliased to the root alias — an
 * aggregate has no outer level of its own, so where/joins/distinct/orderBy/
 * limit/offset all have to live in this one wrap.
 */
-function buildAggregateInput(contract, namespaceId, tableName, state, modelName, projection) {
-	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, void 0).joins : [];
-	const where = buildStateWhere(contract, tableName, state, { namespaceId });
-	const hiddenOrders = hasEntries(state.distinct) ? projectExpressionOrders(tableName, state.orderBy) : void 0;
-	const { source, where: effectiveWhere } = buildDedupedTableSource(contract, namespaceId, tableName, state, where, [...projection, ...hiddenOrders?.projection ?? []], variantJoins);
+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 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);
 	let inner = SelectAst.from(source).withProjection(projection);
 	if (!hasEntries(state.distinct) && variantJoins.length > 0) inner = inner.withJoins(variantJoins);
 	if (effectiveWhere) inner = inner.withWhere(effectiveWhere);
-	if (hasEntries(state.distinctOn)) inner = inner.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
+	if (hasEntries(state.distinctOn)) inner = inner.withDistinctOn(state.distinctOn.map((column) => root.column(column)));
 	const orderBy = hiddenOrders?.orderBy ?? state.orderBy;
 	if (hasEntries(orderBy)) inner = inner.withOrderBy(orderBy);
 	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
 	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
-	return { source: DerivedTableSource.as(tableName, inner) };
+	return { source: DerivedTableSource.as(root.alias, inner) };
 }
 /**
 * The dedup wrap exposes only its projection, so an order over an expression (a relation order, a count, an operation result) cannot be evaluated above it. Each such order is projected inside the wrap as a hidden `__order_N` column and the outer order reads that column.
 */
-function projectExpressionOrders(tableName, orderBy) {
+function projectExpressionOrders(root, orderBy) {
 	const projection = [];
 	return {
 		projection,
@@ -1186,7 +1287,7 @@ function projectExpressionOrders(tableName, orderBy) {
 			if (item.expr.kind === "column-ref") return item;
 			const alias = `__order_${index}`;
 			projection.push(ProjectionItem.of(alias, item.expr));
-			return item.withExpr(ColumnRef.of(tableName, alias));
+			return item.withExpr(root.column(alias));
 		})
 	};
 }
@@ -1199,8 +1300,9 @@ function predicateComparison(op, left, right) {
 function predicateExpression(value) {
 	if (isExpression(value)) return value.buildAst();
 }
-function emptyState() {
+function emptyState(tables) {
 	return {
+		tables,
 		filters: [],
 		includes: [],
 		orderBy: void 0,
@@ -1300,7 +1402,8 @@ const COMPARISON_METHODS_META = {
 		create: (left) => () => NullCheckExpr.isNotNull(left)
 	}
 };
-function toAggregateProjection(contract, aggregates, namespaceId, tableName, selector) {
+function toAggregateProjection(contract, aggregates, root, selector) {
+	const { namespaceId, tableName } = root.storage;
 	const { codec, input: inputCodec, lower } = resolveAggregate({
 		aggregates,
 		contract,
@@ -1309,7 +1412,7 @@ function toAggregateProjection(contract, aggregates, namespaceId, tableName, sel
 		fn: selector.fn,
 		column: selector.column
 	});
-	const inputExpr = selector.column === void 0 ? void 0 : ColumnRef.of(tableName, selector.column);
+	const inputExpr = selector.column === void 0 ? void 0 : root.column(selector.column);
 	return {
 		expr: lower !== void 0 ? lower({
 			expr: inputExpr,
@@ -1383,14 +1486,16 @@ function validateGroupedHavingExpr(expr) {
 		rawExpr: rejectHavingExpr
 	});
 }
-function aggregateInputColumns(tableName, entries, orderBy, groupByColumns = []) {
+function aggregateInputColumns(root, entries, orderBy, groupByColumns = []) {
 	const columns = new Set(groupByColumns);
 	for (const [, selector] of entries) if (selector.column !== void 0) columns.add(selector.column);
 	for (const item of orderBy ?? []) if (item.expr.kind === "column-ref") columns.add(item.expr.column);
 	if (columns.size === 0) return [ProjectionItem.of("__row", LiteralExpr.of(1))];
-	return Array.from(columns, (column) => ProjectionItem.of(column, ColumnRef.of(tableName, column)));
+	return Array.from(columns, (column) => ProjectionItem.of(column, root.column(column)));
 }
-function compileAggregate(contract, aggregates, namespaceId, tableName, state, aggregateSpec, modelName) {
+function compileAggregate(contract, aggregates, state, aggregateSpec, modelName) {
+	const { root } = state.tables;
+	const { namespaceId, tableName } = root.storage;
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw ormError("ORM.AGGREGATE_SELECTOR_MISSING", "aggregate() requires at least one aggregation selector", { meta: {
 		method: "aggregate",
@@ -1404,9 +1509,9 @@ function compileAggregate(contract, aggregates, namespaceId, tableName, state, a
 	const hasPagination = state.limit !== void 0 || state.offset !== void 0;
 	const hasDistinct = state.distinct !== void 0 && state.distinct.length > 0 || state.distinctOn !== void 0 && state.distinctOn.length > 0;
 	if (hasPagination || hasDistinct) {
-		const { source } = buildAggregateInput(contract, namespaceId, tableName, state, modelName, aggregateInputColumns(tableName, entries, state.orderBy));
+		const { source } = buildAggregateInput(contract, state, modelName, aggregateInputColumns(root, entries, state.orderBy));
 		const projection = entries.map(([alias, selector]) => {
-			const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+			const { expr, codec } = toAggregateProjection(contract, aggregates, root, selector);
 			return ProjectionItem.of(alias, expr, codec);
 		});
 		const ast = SelectAst.from(source).withProjection(projection);
@@ -1414,19 +1519,21 @@ function compileAggregate(contract, aggregates, namespaceId, tableName, state, a
 		return buildOrmQueryPlan(contract, ast, params);
 	}
 	const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, void 0).joins : [];
-	const where = buildStateWhere(contract, tableName, state, { namespaceId });
+	const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, state.tables, polyInfo, state.variantName, void 0).joins : [];
+	const where = buildStateWhere(contract, state);
 	const projection = entries.map(([alias, selector]) => {
-		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+		const { expr, codec } = toAggregateProjection(contract, aggregates, root, selector);
 		return ProjectionItem.of(alias, expr, codec);
 	});
-	let ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection);
+	let ast = SelectAst.from(root.tableSource(contract)).withProjection(projection);
 	if (variantJoins.length > 0) ast = ast.withJoins(variantJoins);
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, preGroupState, groupByColumns, aggregateSpec, havingExpr, modelName, postGroup = emptyGroupPagingState()) {
+function compileGroupedAggregate(contract, aggregates, preGroupState, groupByColumns, aggregateSpec, havingExpr, modelName, postGroup = emptyGroupPagingState()) {
+	const { root } = preGroupState.tables;
+	const { namespaceId, tableName } = root.storage;
 	if (groupByColumns.length === 0) throw ormError("ORM.GROUP_BY_FIELD_MISSING", "groupBy() requires at least one field", { meta: {
 		namespaceId,
 		tableName
@@ -1441,8 +1548,8 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, p
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(preGroupState.orderBy, preGroupState.distinctOn.length);
 	}
-	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column))), ...entries.map(([alias, selector]) => {
-		const { expr, codec } = toAggregateProjection(contract, aggregates, namespaceId, tableName, selector);
+	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, root.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column))), ...entries.map(([alias, selector]) => {
+		const { expr, codec } = toAggregateProjection(contract, aggregates, root, selector);
 		return ProjectionItem.of(alias, expr, codec);
 	})];
 	const hasPagination = preGroupState.limit !== void 0 || preGroupState.offset !== void 0;
@@ -1450,14 +1557,15 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, p
 	const needsInputSelect = hasPagination || hasDistinct;
 	let ast;
 	if (needsInputSelect) {
-		const { source } = buildAggregateInput(contract, namespaceId, tableName, preGroupState, modelName, aggregateInputColumns(tableName, entries, preGroupState.orderBy, groupByColumns));
-		ast = SelectAst.from(source).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+		const { source } = buildAggregateInput(contract, preGroupState, modelName, aggregateInputColumns(root, entries, preGroupState.orderBy, groupByColumns));
+		ast = SelectAst.from(source).withProjection(projection).withGroupBy(groupByColumns.map((column) => root.column(column)));
 	} else {
 		const polyInfo = modelName ? resolvePolymorphismInfo(contract, namespaceId, modelName) : void 0;
-		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, namespaceId, polyInfo, preGroupState.variantName, void 0).joins : [];
-		ast = SelectAst.from(tableSourceForContract(contract, namespaceId, tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
+		const { tables, variantName } = preGroupState;
+		const variantJoins = polyInfo && polyInfo.mtiVariants.length > 0 ? buildMtiJoins(contract, tables, polyInfo, variantName, 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, tableName, preGroupState, { namespaceId });
+		const where = buildStateWhere(contract, preGroupState);
 		if (where) ast = ast.withWhere(where);
 	}
 	if (havingExpr) ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
@@ -1467,8 +1575,15 @@ function compileGroupedAggregate(contract, aggregates, namespaceId, tableName, p
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-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 aliasTarget(namespaceId, tableName) {
+	return createTableScope().aliasTable({
+		namespaceId,
+		tableName
+	});
+}
+function buildReturningColumns(contract, modelName, target, returningColumns) {
+	const { namespaceId, tableName } = target.storage;
+	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : getColumnsReadOnTable(contract, namespaceId, modelName, tableName)).map((column) => ProjectionItem.of(column, target.column(column), codecRefForStorageColumn(contract.storage, namespaceId, tableName, column)));
 }
 function toParamAssignments(contract, namespaceId, tableName, values) {
 	const assignments = {};
@@ -1519,20 +1634,22 @@ function normalizeInsertRows(contract, namespaceId, tableName, rows) {
 		return normalizedRow;
 	}) };
 }
-function conflictSkipClause(tableName, conflictSkip) {
+function conflictSkipClause(target, conflictSkip) {
 	if (!conflictSkip) return void 0;
 	if (conflictSkip.columns.length === 0) return InsertOnConflict.doNothing();
-	return InsertOnConflict.on(conflictSkip.columns.map((column) => ColumnRef.of(tableName, column))).doNothing();
+	return InsertOnConflict.on(conflictSkip.columns.map((column) => target.column(column))).doNothing();
 }
 function compileInsertReturning(contract, namespaceId, modelName, tableName, rows, returningColumns, conflictSkip) {
+	const target = aliasTarget(namespaceId, tableName);
 	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, modelName, tableName, returningColumns));
+	const ast = InsertAst.into(target.tableSource(contract)).withRows(normalizedRows).withOnConflict(conflictSkipClause(target, conflictSkip)).withReturning(buildReturningColumns(contract, modelName, target, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileInsertCount(contract, namespaceId, tableName, rows, conflictSkip) {
+	const target = aliasTarget(namespaceId, tableName);
 	const { rows: normalizedRows } = normalizeInsertRows(contract, namespaceId, tableName, rows);
-	const ast = InsertAst.into(tableSourceForContract(contract, namespaceId, tableName)).withRows(normalizedRows).withOnConflict(conflictSkipClause(tableName, conflictSkip));
+	const ast = InsertAst.into(target.tableSource(contract)).withRows(normalizedRows).withOnConflict(conflictSkipClause(target, conflictSkip));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
@@ -1541,29 +1658,14 @@ function stripUndefinedValues(row) {
 	for (const [key, value] of Object.entries(row)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function createTableRefRemapper(fromTable, toTable) {
-	return {
-		columnRef: (col) => col.table === fromTable ? ColumnRef.of(toTable, col.column) : col,
-		tableSource: (source) => {
-			if (source.alias === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			if (!source.alias && source.name === fromTable) return TableSource.named(source.name, toTable, source.namespaceId);
-			return source;
-		},
-		eqColJoinOn: (on) => EqColJoinOn.of(on.left.table === fromTable ? ColumnRef.of(toTable, on.left.column) : on.left, on.right.table === fromTable ? ColumnRef.of(toTable, on.right.column) : on.right)
-	};
-}
-function buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName) {
-	if (!variantName || !modelName) return combineWhereExprs(filters);
-	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-	const variant = polyInfo?.variants.get(variantName);
-	if (!polyInfo || !variant || variant.strategy !== "mti") return combineWhereExprs(filters);
-	const pkColumns = resolvePrimaryKeyColumns(contract, namespaceId, tableName);
-	const baseTableRef = `${tableName}__write_filter`;
-	const remapper = createTableRefRemapper(tableName, baseTableRef);
-	const innerFilters = filters.map((filter) => filter.rewrite(remapper));
-	const where = combineWhereExprs([...pkColumns.map((column) => BinaryExpr.eq(ColumnRef.of(baseTableRef, column), ColumnRef.of(tableName, column))), ...innerFilters]);
-	const joinOn = buildPrimaryKeyJoinOn(baseTableRef, variant.table, pkColumns);
-	let subquery = SelectAst.from(TableSource.named(tableName, baseTableRef, namespaceId)).withProjection(pkColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(baseTableRef, column)))).withJoins([JoinAst.inner(tableSourceForContract(contract, namespaceId, variant.table), joinOn)]);
+function buildCountMutationWhere(contract, tables, filters, variantName) {
+	const variantTable = variantName === void 0 ? void 0 : tables.variants.get(variantName);
+	if (variantTable === void 0) return combineWhereExprs(filters);
+	const { root } = tables;
+	const pkColumns = resolvePrimaryKeyColumns(contract, root.storage.namespaceId, root.storage.tableName);
+	const rootCopy = tables.scope.copy().aliasTable(root.storage);
+	const where = combineWhereExprs([...pkColumns.map((column) => BinaryExpr.eq(rootCopy.column(column), root.column(column))), ...filters]);
+	let subquery = SelectAst.from(rootCopy.tableSource(contract)).withProjection(pkColumns.map((column) => ProjectionItem.of(column, rootCopy.column(column)))).withJoins([JoinAst.inner(variantTable.tableSource(contract), buildPrimaryKeyJoinOn(rootCopy, variantTable, pkColumns))]);
 	if (where) subquery = subquery.withWhere(where);
 	return ExistsExpr.exists(subquery);
 }
@@ -1602,37 +1704,44 @@ function compileInsertCountSplit(contract, namespaceId, tableName, rows, conflic
 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, modelName, tableName, returningColumns));
+	const target = aliasTarget(namespaceId, tableName);
+	const conflictTarget = InsertOnConflict.on(conflictColumns.map((column) => target.column(column)));
+	const onConflict = updateAssignments ? conflictTarget.doUpdateSet(updateAssignments.assignments) : conflictTarget.doNothing();
+	const ast = InsertAst.into(target.tableSource(contract)).withRows([createAssignments.assignments]).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, modelName, target, returningColumns));
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileUpdateReturning(contract, namespaceId, modelName, tableName, setValues, filters, returningColumns) {
+function compileUpdateReturning(contract, modelName, tables, setValues, filters, returningColumns) {
+	const { root } = tables;
+	const { namespaceId, tableName } = root.storage;
 	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, modelName, tableName, returningColumns));
+	let ast = UpdateAst.table(root.tableSource(contract)).withSet(assignments).withReturning(buildReturningColumns(contract, modelName, root, returningColumns));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileUpdateCount(contract, namespaceId, tableName, setValues, filters, variantName, modelName) {
-	const where = buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName);
+function compileUpdateCount(contract, tables, setValues, filters, variantName) {
+	const { root } = tables;
+	const { namespaceId, tableName } = root.storage;
+	const where = buildCountMutationWhere(contract, tables, filters, variantName);
 	const { assignments } = toParamAssignments(contract, namespaceId, tableName, setValues);
-	let ast = UpdateAst.table(tableSourceForContract(contract, namespaceId, tableName)).withSet(assignments);
+	let ast = UpdateAst.table(root.tableSource(contract)).withSet(assignments);
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileDeleteReturning(contract, namespaceId, modelName, tableName, filters, returningColumns) {
+function compileDeleteReturning(contract, modelName, tables, filters, returningColumns) {
+	const { root } = tables;
 	const where = combineWhereExprs(filters);
-	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName)).withReturning(buildReturningColumns(contract, namespaceId, modelName, tableName, returningColumns));
+	let ast = DeleteAst.from(root.tableSource(contract)).withReturning(buildReturningColumns(contract, modelName, root, returningColumns));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
 }
-function compileDeleteCount(contract, namespaceId, tableName, filters, variantName, modelName) {
-	const where = buildCountMutationWhere(contract, namespaceId, tableName, filters, variantName, modelName);
-	let ast = DeleteAst.from(tableSourceForContract(contract, namespaceId, tableName));
+function compileDeleteCount(contract, tables, filters, variantName) {
+	const where = buildCountMutationWhere(contract, tables, filters, variantName);
+	let ast = DeleteAst.from(tables.root.tableSource(contract));
 	if (where) ast = ast.withWhere(where);
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params);
@@ -1706,8 +1815,9 @@ function jsonEntryProjection(value, identity) {
 	if (identity.document === true) return new JsonDocumentProjection(value);
 	return new NativeJsonValueProjection(value);
 }
-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 buildProjection(contract, modelName, 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)));
 }
 function appendUnique(values, value) {
 	if (!values.includes(value)) values.push(value);
@@ -1715,7 +1825,7 @@ function appendUnique(values, value) {
 function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName, polyInfo, state) {
 	if (state.selectedFields === void 0) return {
 		baseSelectedFields: void 0,
-		selectedMtiColumnsByTable: void 0,
+		selectedMtiColumnsByVariant: void 0,
 		needsHiddenDiscriminator: false
 	};
 	const baseColumnToField = getModelColumnFields(contract, namespaceId, modelName);
@@ -1724,7 +1834,7 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 		columnToField: getOwnColumnFields(contract, namespaceId, variant.modelName)
 	}));
 	const baseSelectedFields = [];
-	const selectedMtiColumnsByTable = /* @__PURE__ */ new Map();
+	const selectedMtiColumnsByVariant = /* @__PURE__ */ new Map();
 	let hasVariantOwnedSelection = false;
 	for (const column of state.selectedFields) {
 		const isBaseColumn = Object.hasOwn(baseColumnToField, column);
@@ -1738,10 +1848,10 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 				appendUnique(baseSelectedFields, column);
 				continue;
 			}
-			let selectedColumns = selectedMtiColumnsByTable.get(variant.table);
+			let selectedColumns = selectedMtiColumnsByVariant.get(variant.modelName);
 			if (selectedColumns === void 0) {
 				selectedColumns = /* @__PURE__ */ new Set();
-				selectedMtiColumnsByTable.set(variant.table, selectedColumns);
+				selectedMtiColumnsByVariant.set(variant.modelName, selectedColumns);
 			}
 			selectedColumns.add(column);
 		}
@@ -1749,13 +1859,13 @@ function resolvePolymorphicProjectionSelection(contract, namespaceId, modelName,
 	}
 	return {
 		baseSelectedFields,
-		selectedMtiColumnsByTable,
+		selectedMtiColumnsByVariant,
 		needsHiddenDiscriminator: state.variantName === void 0 && hasVariantOwnedSelection && !baseSelectedFields.includes(polyInfo.discriminatorColumn)
 	};
 }
-function buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableRef, needed) {
+function buildHiddenDiscriminatorProjection(contract, table, polyInfo, needed) {
 	if (!needed) return [];
-	return [ProjectionItem.of(POLYMORPHIC_DISCRIMINATOR_ALIAS, ColumnRef.of(tableRef, polyInfo.discriminatorColumn), codecRefForStorageColumn(contract.storage, namespaceId, polyInfo.baseTable, polyInfo.discriminatorColumn))];
+	return [ProjectionItem.of(POLYMORPHIC_DISCRIMINATOR_ALIAS, table.column(polyInfo.discriminatorColumn), codecRefForStorageColumn(contract.storage, table.storage.namespaceId, table.storage.tableName, polyInfo.discriminatorColumn))];
 }
 function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 	if (!childOrderBy || childOrderBy.length === 0) return {
@@ -1777,41 +1887,34 @@ function buildIncludeOrderArtifacts(relationName, rowAlias, childOrderBy) {
 function localColumnsForRowInclude(include) {
 	return include.through?.parentLocalColumns ?? include.localColumns;
 }
-function buildIncludeJoinExpr(include, childTableRef, parentLocalRefs) {
+function buildIncludeJoinExpr(include, child, parentLocalRefs) {
 	invariant(parentLocalRefs.length === include.targetColumns.length, `Include '${include.relationName}' has mismatched join column counts: ${parentLocalRefs.length} local, ${include.targetColumns.length} target`);
 	const joinExprs = include.targetColumns.map((targetColumn, i) => {
 		const parentLocalRef = parentLocalRefs[i];
 		assertDefined(parentLocalRef, `Include '${include.relationName}': no local column at ${i}`);
-		return BinaryExpr.eq(ColumnRef.of(childTableRef, targetColumn), parentLocalRef);
+		return BinaryExpr.eq(child.column(targetColumn), parentLocalRef);
 	});
 	const [firstExpr] = joinExprs;
 	assertDefined(firstExpr, `Include '${include.relationName}' has no join columns`);
 	return joinExprs.length === 1 ? firstExpr : AndExpr.of(joinExprs);
 }
-function resolveParentLocalRefs(parentSource, include, localColumns) {
+function localTable(tables, include) {
+	return include.localVariantName === void 0 ? tables.root : requireVariantTable(tables, include.localVariantName);
+}
+function resolveParentLocalRefs(parent, include, localColumns) {
+	const local = localTable(parent.tables, include);
+	const { projectedThrough } = parent;
 	return localColumns.map((column) => {
-		if (include.localTableName === parentSource.baseTableName) return ColumnRef.of(parentSource.tableRef, column);
-		if (parentSource.variantColumnsProjected) return ColumnRef.of(parentSource.tableRef, `${include.localTableName}__${column}`);
-		return ColumnRef.of(include.localTableName, column);
+		if (projectedThrough === void 0) return local.column(column);
+		return ColumnRef.of(projectedThrough, local === parent.tables.root ? column : variantColumnLabel(local, column));
 	});
 }
-function resolveChildTableSource(include, parentLocalRefs) {
-	const alias = parentLocalRefs.some((ref) => ref.table === include.relatedTableName) ? `${include.relationName}__child` : void 0;
-	return {
-		alias,
-		tableRef: alias ?? include.relatedTableName
-	};
+function requireJunction(include) {
+	if (include.junction === void 0) throw new InternalError(`Include '${include.relationName}' goes through a junction table but carries no aliased table for it`);
+	return include.junction;
 }
-/**
-* Recursively build the correlated-subquery projections for the nested
-* includes attached to a child SELECT. Used by `buildIncludeChildRowsSelect`
-* to wire depth-2+ aggregates into the inner SELECT at each level.
-*
-* Each nested include contributes a single projection item whose
-* expression is a correlated subquery.
-*/
-function buildNestedIncludeProjections(contract, aggregates, parentSource, includes) {
-	return includes.map((nested) => buildCorrelatedIncludeProjection(contract, aggregates, parentSource, nested).projection);
+function buildNestedIncludeProjections(contract, aggregates, scope, parent, includes) {
+	return includes.map((nested) => buildCorrelatedIncludeProjection(contract, aggregates, scope, parent, nested).projection);
 }
 /**
 * The aliases a level's nested includes contribute. Each such subquery
@@ -1829,13 +1932,8 @@ function documentAliasesOf(nestedProjections) {
 * variant-specific columns live on the base table and reach the row through
 * the ordinary base-column projection (`buildProjection`); only the MTI
 * variant tables need a join.
-*
-* When the child base table is aliased (self-relations), `buildMtiJoins`
-* emits a join `ON` against the unaliased base table name, which would fall
-* out of scope. Remap it to the child alias — the same remap the row builder
-* already applies to `orderBy`/`where`.
 */
-function buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef) {
+function buildChildPolymorphismJoinsAndProjection(contract, include) {
 	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
 	if (!polyInfo) return {
 		joins: [],
@@ -1844,35 +1942,25 @@ function buildChildPolymorphismJoinsAndProjection(contract, include, childTableA
 		baseSelectedFields: include.nested.selectedFields
 	};
 	const selection = resolvePolymorphicProjectionSelection(contract, include.relatedNamespaceId, include.relatedModelName, polyInfo, include.nested);
-	const { joins, projection } = buildMtiJoins(contract, include.relatedNamespaceId, polyInfo, include.nested.variantName, selection.selectedMtiColumnsByTable);
-	const hiddenProjection = buildHiddenDiscriminatorProjection(contract, include.relatedNamespaceId, polyInfo, childTableRef, selection.needsHiddenDiscriminator);
-	if (!childTableAlias) return {
-		joins,
-		projection,
-		hiddenProjection,
-		baseSelectedFields: selection.baseSelectedFields
-	};
-	const remapper = createTableRefRemapper$1(polyInfo.baseTable, childTableRef);
+	const { joins, projection } = buildMtiJoins(contract, include.nested.tables, polyInfo, include.nested.variantName, selection.selectedMtiColumnsByVariant);
 	return {
-		joins: joins.map((join) => join.rewrite(remapper)),
+		joins,
 		projection,
-		hiddenProjection,
+		hiddenProjection: buildHiddenDiscriminatorProjection(contract, include.nested.tables.root, polyInfo, selection.needsHiddenDiscriminator),
 		baseSelectedFields: selection.baseSelectedFields
 	};
 }
 function buildRequiredMtiJoinKeyProjection(contract, include) {
-	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
-	if (!polyInfo) return [];
-	const mtiTables = new Set(polyInfo.mtiVariants.map((variant) => variant.table));
 	const aliases = /* @__PURE__ */ new Set();
 	const projection = [];
 	for (const nested of include.nested.includes) {
-		if (!mtiTables.has(nested.localTableName)) continue;
+		if (nested.localVariantName === void 0) continue;
+		const variantTable = requireVariantTable(include.nested.tables, nested.localVariantName);
 		for (const column of localColumnsForRowInclude(nested)) {
-			const alias = `${nested.localTableName}__${column}`;
+			const alias = variantColumnLabel(variantTable, column);
 			if (aliases.has(alias)) continue;
 			aliases.add(alias);
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(nested.localTableName, column), codecRefForStorageColumn(contract.storage, include.relatedNamespaceId, nested.localTableName, column)));
+			projection.push(ProjectionItem.of(alias, variantTable.column(column), codecRefForStorageColumn(contract.storage, variantTable.storage.namespaceId, variantTable.storage.tableName, column)));
 		}
 	}
 	return projection;
@@ -1892,61 +1980,54 @@ function mergeProjectionByAlias(projection, additional) {
 * (AND-ed across all column pairs for composite keys). The junction JOIN
 * connects child rows to the junction via the child columns.
 */
-function buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, through) {
-	const { table: junctionTable, parentColumns, childColumns, targetColumns, namespaceId } = through;
+function buildManyToManyJunctionArtifacts(contract, parentLocalRefs, child, junction, through) {
+	const { table: junctionTable, parentColumns, childColumns, targetColumns } = through;
 	invariant(childColumns.length === targetColumns.length, `M:N junction '${junctionTable}': childColumns (${childColumns.length}) and targetColumns (${targetColumns.length}) must have equal length`);
 	invariant(parentColumns.length === parentLocalRefs.length, `M:N junction '${junctionTable}': parentColumns (${parentColumns.length}) and parentLocalColumns (${parentLocalRefs.length}) must have equal length`);
 	const joinOnPairs = childColumns.map((junctionCol, i) => {
 		const targetCol = targetColumns[i];
 		assertDefined(targetCol, `M:N junction '${junctionTable}': missing target column at index ${i}`);
-		return BinaryExpr.eq(ColumnRef.of(junctionTable, junctionCol), ColumnRef.of(childTableRef, targetCol));
+		return BinaryExpr.eq(junction.column(junctionCol), child.column(targetCol));
 	});
 	const firstJoinPair = joinOnPairs[0];
 	const joinOn = joinOnPairs.length === 1 && firstJoinPair ? firstJoinPair : AndExpr.of(joinOnPairs);
 	const correlationPairs = parentColumns.map((junctionCol, i) => {
 		const parentLocalRef = parentLocalRefs[i];
 		assertDefined(parentLocalRef, `M:N junction '${junctionTable}': missing parent-local column ref at index ${i}`);
-		return BinaryExpr.eq(ColumnRef.of(junctionTable, junctionCol), parentLocalRef);
+		return BinaryExpr.eq(junction.column(junctionCol), parentLocalRef);
 	});
 	const firstCorrelationPair = correlationPairs[0];
 	return {
 		whereExpr: correlationPairs.length === 1 && firstCorrelationPair ? firstCorrelationPair : AndExpr.of(correlationPairs),
-		junctionJoin: JoinAst.inner(TableSource.named(junctionTable, void 0, namespaceId), joinOn, false)
+		junctionJoin: JoinAst.inner(junction.tableSource(contract), joinOn, false)
 	};
 }
-function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include) {
+function buildIncludeChildRowsSelect(contract, aggregates, scope, parent, include) {
 	const childState = include.nested;
 	if (childState.distinctOn !== void 0 && childState.distinctOn.length > 0) {
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(childState.orderBy, childState.distinctOn.length);
 	}
-	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, localColumnsForRowInclude(include));
-	const childSource = resolveChildTableSource(include, parentLocalRefs);
-	const childTableAlias = childSource.alias;
-	const childTableRef = childSource.tableRef;
-	const rowsAlias = `${include.relationName}__rows`;
-	const remappedChildOrderBy = childTableAlias && childState.orderBy ? childState.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : childState.orderBy;
-	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, remappedChildOrderBy);
-	const childWhere = buildStateWhere(contract, childTableRef, childState, {
-		filterTableName: include.relatedTableName,
-		namespaceId: include.relatedNamespaceId
-	});
+	const child = childState.tables.root;
+	const parentLocalRefs = resolveParentLocalRefs(parent, include, localColumnsForRowInclude(include));
+	const rowsAlias = scope.alias(`${include.relationName}__rows`);
+	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include.relationName, rowsAlias, childState.orderBy);
+	const childWhere = buildStateWhere(contract, childState);
 	let whereExpr;
 	let junctionJoins = [];
 	if (include.through !== void 0) {
-		const artifacts = buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, include.through);
+		const artifacts = buildManyToManyJunctionArtifacts(contract, parentLocalRefs, child, requireJunction(include), include.through);
 		whereExpr = childWhere ? AndExpr.of([artifacts.whereExpr, childWhere]) : artifacts.whereExpr;
 		junctionJoins = [artifacts.junctionJoin];
 	} else {
-		const joinExpr = buildIncludeJoinExpr(include, childTableRef, parentLocalRefs);
+		const joinExpr = buildIncludeJoinExpr(include, child, parentLocalRefs);
 		whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
 	}
 	if (childState.distinct !== void 0 && childState.distinct.length > 0 && childState.includes.length > 0) return buildDistinctNonLeafChildRowsSelect({
 		contract,
 		aggregates,
+		scope,
 		include,
-		childTableAlias,
-		childTableRef,
 		rowsAlias,
 		childOrderBy,
 		hiddenOrderProjection,
@@ -1954,30 +2035,26 @@ function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include
 		whereExpr,
 		junctionJoins
 	});
-	const polyJoinsAndProjection = buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, 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,
-		variantColumnsProjected: false
-	}, childState.includes);
+	const polyJoinsAndProjection = buildChildPolymorphismJoinsAndProjection(contract, include);
+	const scalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, polyJoinsAndProjection.baseSelectedFields);
+	const nestedProjections = buildNestedIncludeProjections(contract, aggregates, scope, { tables: childState.tables }, childState.includes);
 	const childProjection = [
 		...scalarProjection,
 		...polyJoinsAndProjection.projection,
 		...polyJoinsAndProjection.hiddenProjection,
 		...nestedProjections
 	];
-	let childRows = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([...childProjection, ...hiddenOrderProjection]).withWhere(whereExpr);
+	let childRows = SelectAst.from(child.tableSource(contract)).withProjection([...childProjection, ...hiddenOrderProjection]).withWhere(whereExpr);
 	if (polyJoinsAndProjection.joins.length > 0) childRows = childRows.withJoins([...polyJoinsAndProjection.joins]);
 	if (junctionJoins.length > 0) childRows = childRows.withJoins(junctionJoins);
 	if (childState.distinctOn && childState.distinctOn.length > 0) {
-		childRows = childRows.withDistinctOn(childState.distinctOn.map((column) => ColumnRef.of(childTableRef, column)));
+		childRows = childRows.withDistinctOn(childState.distinctOn.map((column) => child.column(column)));
 		if (childOrderBy) childRows = childRows.withOrderBy(childOrderBy);
 	} else if (childState.distinct && childState.distinct.length > 0) {
-		const rankedAlias = `${include.relationName}__distinct`;
+		const rankedAlias = scope.alias(`${include.relationName}__distinct`);
 		childRows = wrapWithRowNumberDedup({
 			base: childRows,
-			distinctColumnRefs: childState.distinct.map((column) => ColumnRef.of(childTableRef, column)),
+			distinctColumnRefs: childState.distinct.map((column) => child.column(column)),
 			rankingOrderBy: childOrderBy ?? [],
 			rankedAlias
 		});
@@ -1994,21 +2071,22 @@ function buildIncludeChildRowsSelect(contract, aggregates, parentSource, include
 	};
 }
 function buildDistinctNonLeafChildRowsSelect(options) {
-	const { contract, aggregates, include, childTableAlias, childTableRef, rowsAlias, childOrderBy, hiddenOrderProjection, aggregateOrderBy, whereExpr, junctionJoins } = options;
+	const { contract, aggregates, scope, include, rowsAlias, childOrderBy, hiddenOrderProjection, aggregateOrderBy, whereExpr, junctionJoins } = options;
 	const childState = include.nested;
-	const grandchildJoinColumns = Array.from(new Set(childState.includes.flatMap((nested) => nested.localTableName === include.relatedTableName ? localColumnsForRowInclude(nested) : [])));
+	const child = childState.tables.root;
+	const grandchildJoinColumns = Array.from(new Set(childState.includes.flatMap((nested) => nested.localVariantName === void 0 ? localColumnsForRowInclude(nested) : [])));
 	const { selectedForQuery } = augmentSelectionForJoinColumns(childState.selectedFields, grandchildJoinColumns);
-	const visiblePolyProjection = buildChildPolymorphismJoinsAndProjection(contract, include, childTableAlias, childTableRef);
+	const visiblePolyProjection = buildChildPolymorphismJoinsAndProjection(contract, include);
 	const queryPolyProjection = buildChildPolymorphismJoinsAndProjection(contract, {
 		...include,
 		nested: {
 			...childState,
 			selectedFields: selectedForQuery
 		}
-	}, childTableAlias, childTableRef);
-	const innerScalarProjection = buildProjection(contract, include.relatedNamespaceId, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName, queryPolyProjection.baseSelectedFields, childTableRef);
+	});
+	const innerScalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, queryPolyProjection.baseSelectedFields);
 	const innerMtiProjection = mergeProjectionByAlias(queryPolyProjection.projection, buildRequiredMtiJoinKeyProjection(contract, include));
-	let baseInner = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([
+	let baseInner = SelectAst.from(child.tableSource(contract)).withProjection([
 		...innerScalarProjection,
 		...innerMtiProjection,
 		...queryPolyProjection.hiddenProjection,
@@ -2018,22 +2096,21 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 	if (distinctExtraJoins.length > 0) baseInner = baseInner.withJoins(distinctExtraJoins);
 	const distinctColumns = childState.distinct;
 	if (distinctColumns === void 0 || distinctColumns.length === 0) throw new InternalError("buildDistinctNonLeafChildRowsSelect requires a non-empty `distinct` selection");
-	const rankedAlias = `${include.relationName}__ranked`;
+	const rankedAlias = scope.alias(`${include.relationName}__ranked`);
 	let innerSelect = wrapWithRowNumberDedup({
 		base: baseInner,
-		distinctColumnRefs: distinctColumns.map((column) => ColumnRef.of(childTableRef, column)),
+		distinctColumnRefs: distinctColumns.map((column) => child.column(column)),
 		rankingOrderBy: childOrderBy ?? [],
 		rankedAlias
 	});
 	if (childOrderBy) innerSelect = innerSelect.withOrderBy(childOrderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
 	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, addressedModelName(include.relatedModelName, include.nested.variantName), include.relatedTableName, visiblePolyProjection.baseSelectedFields, distinctAlias);
-	const outerNestedProjections = buildNestedIncludeProjections(contract, aggregates, {
-		baseTableName: include.relatedTableName,
-		tableRef: distinctAlias,
-		variantColumnsProjected: true
+	const distinctAlias = scope.alias(`${include.relationName}__distinct`);
+	const outerScalarProjection = buildProjection(contract, addressedModelName(include.relatedModelName, include.nested.variantName), child, visiblePolyProjection.baseSelectedFields, distinctAlias);
+	const outerNestedProjections = buildNestedIncludeProjections(contract, aggregates, scope, {
+		tables: childState.tables,
+		projectedThrough: distinctAlias
 	}, childState.includes);
 	const outerPolyProjection = visiblePolyProjection.projection.map((proj) => ProjectionItem.of(proj.alias, ColumnRef.of(distinctAlias, proj.alias), proj.codec));
 	const outerHiddenProjection = visiblePolyProjection.hiddenProjection.map((proj) => ProjectionItem.of(proj.alias, ColumnRef.of(distinctAlias, proj.alias), proj.codec));
@@ -2078,7 +2155,7 @@ function buildDistinctNonLeafChildRowsSelect(options) {
 * `distinct`) is dropped at the SQL level since reordering does not
 * change which rows are aggregated.
 */
-function buildIncludeChildScalarSelect(contract, aggregates, parentSource, include, scalar) {
+function buildIncludeChildScalarSelect(contract, aggregates, scope, parent, include, scalar) {
 	const { codec: resultCodec, input: inputCodec, lower: resultLowering } = resolveAggregate({
 		aggregates,
 		contract,
@@ -2087,65 +2164,58 @@ function buildIncludeChildScalarSelect(contract, aggregates, parentSource, inclu
 		fn: scalar.fn,
 		column: scalar.column
 	});
-	const parentLocalRefs = resolveParentLocalRefs(parentSource, include, localColumnsForRowInclude(include));
-	const childSource = resolveChildTableSource(include, parentLocalRefs);
-	const childTableAlias = childSource.alias;
-	const childTableRef = childSource.tableRef;
+	const parentLocalRefs = resolveParentLocalRefs(parent, include, localColumnsForRowInclude(include));
 	const state = scalar.state;
+	const child = state.tables.root;
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
 	}
-	const childWhere = buildStateWhere(contract, childTableRef, state, {
-		filterTableName: include.relatedTableName,
-		namespaceId: include.relatedNamespaceId
-	});
+	const childWhere = buildStateWhere(contract, state);
 	let whereExpr;
 	let junctionJoins = [];
 	if (include.through !== void 0) {
-		const artifacts = buildManyToManyJunctionArtifacts(parentLocalRefs, childTableRef, include.through);
+		const artifacts = buildManyToManyJunctionArtifacts(contract, parentLocalRefs, child, requireJunction(include), include.through);
 		whereExpr = childWhere ? AndExpr.of([artifacts.whereExpr, childWhere]) : artifacts.whereExpr;
 		junctionJoins = [artifacts.junctionJoin];
 	} else {
-		const joinExpr = buildIncludeJoinExpr(include, childTableRef, parentLocalRefs);
+		const joinExpr = buildIncludeJoinExpr(include, child, parentLocalRefs);
 		whereExpr = childWhere ? AndExpr.of([joinExpr, childWhere]) : joinExpr;
 	}
-	const remappedOrderBy = childTableAlias && state.orderBy ? state.orderBy.map((item) => item.rewrite(createTableRefRemapper$1(include.relatedTableName, childTableRef))) : state.orderBy;
 	const hasPagination = state.limit !== void 0 || state.offset !== void 0;
 	const hasDistinct = state.distinct !== void 0 && state.distinct.length > 0 || state.distinctOn !== void 0 && state.distinctOn.length > 0;
 	if (!(hasPagination || hasDistinct)) {
-		const aggregateExpr = buildIncludeAggregateExpr(scalar, childTableRef, resultLowering, inputCodec);
+		const aggregateExpr = buildIncludeAggregateExpr(scalar, scalar.column === void 0 ? void 0 : child.column(scalar.column), resultLowering, inputCodec);
 		const jsonObjectExpr = JsonObjectExpr.fromEntries([JsonObjectExpr.entry("value", jsonEntryProjection(aggregateExpr, { codec: resultCodec }))]);
-		let select = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection([ProjectionItem.of(include.relationName, jsonObjectExpr)]).withWhere(whereExpr);
+		let select = SelectAst.from(child.tableSource(contract)).withProjection([ProjectionItem.of(include.relationName, jsonObjectExpr)]).withWhere(whereExpr);
 		if (junctionJoins.length > 0) select = select.withJoins(junctionJoins);
 		return select;
 	}
-	const innerAlias = `${include.relationName}__scalar`;
-	const hiddenOrderProjection = state.distinct !== void 0 && state.distinct.length > 0 && remappedOrderBy !== void 0 && remappedOrderBy.length > 0 ? remappedOrderBy.map((item, index) => ProjectionItem.of(`${include.relationName}__order_${index}`, item.expr)) : [];
-	const innerProjection = [...scalar.column !== void 0 ? [ProjectionItem.of(scalar.column, ColumnRef.of(childTableRef, scalar.column))] : [ProjectionItem.of("__row", LiteralExpr.of(1))], ...hiddenOrderProjection];
-	let inner = SelectAst.from(tableSourceForContract(contract, include.relatedNamespaceId, include.relatedTableName, childTableAlias)).withProjection(innerProjection).withWhere(whereExpr);
+	const innerAlias = scope.alias(`${include.relationName}__scalar`);
+	const hiddenOrderProjection = state.distinct !== void 0 && state.distinct.length > 0 && state.orderBy !== void 0 && state.orderBy.length > 0 ? state.orderBy.map((item, index) => ProjectionItem.of(`${include.relationName}__order_${index}`, item.expr)) : [];
+	const innerProjection = [...scalar.column !== void 0 ? [ProjectionItem.of(scalar.column, child.column(scalar.column))] : [ProjectionItem.of("__row", LiteralExpr.of(1))], ...hiddenOrderProjection];
+	let inner = SelectAst.from(child.tableSource(contract)).withProjection(innerProjection).withWhere(whereExpr);
 	if (junctionJoins.length > 0) inner = inner.withJoins(junctionJoins);
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
-		inner = inner.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(childTableRef, column)));
-		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy);
+		inner = inner.withDistinctOn(state.distinctOn.map((column) => child.column(column)));
+		if (state.orderBy !== void 0 && state.orderBy.length > 0) inner = inner.withOrderBy(state.orderBy);
 	} else if (state.distinct !== void 0 && state.distinct.length > 0) {
-		const rankedAlias = `${include.relationName}__scalar_distinct`;
+		const rankedAlias = scope.alias(`${include.relationName}__scalar_distinct`);
 		inner = wrapWithRowNumberDedup({
 			base: inner,
-			distinctColumnRefs: state.distinct.map((column) => ColumnRef.of(childTableRef, column)),
-			rankingOrderBy: remappedOrderBy ?? [],
+			distinctColumnRefs: state.distinct.map((column) => child.column(column)),
+			rankingOrderBy: state.orderBy ?? [],
 			rankedAlias
 		});
-		if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
-	} else if (remappedOrderBy !== void 0 && remappedOrderBy.length > 0) inner = inner.withOrderBy(remappedOrderBy);
+		if (state.orderBy !== void 0 && state.orderBy.length > 0) inner = inner.withOrderBy(state.orderBy.map((item, index) => item.withExpr(ColumnRef.of(rankedAlias, `${include.relationName}__order_${index}`))));
+	} else if (state.orderBy !== void 0 && state.orderBy.length > 0) inner = inner.withOrderBy(state.orderBy);
 	if (state.limit !== void 0) inner = inner.withLimit(state.limit);
 	if (state.offset !== void 0) inner = inner.withOffset(state.offset);
-	const outerAggregateExpr = buildIncludeAggregateExpr(scalar, innerAlias, resultLowering, inputCodec);
+	const outerAggregateExpr = buildIncludeAggregateExpr(scalar, scalar.column === void 0 ? void 0 : ColumnRef.of(innerAlias, scalar.column), resultLowering, inputCodec);
 	const outerJsonObjectExpr = JsonObjectExpr.fromEntries([JsonObjectExpr.entry("value", jsonEntryProjection(outerAggregateExpr, { codec: resultCodec }))]);
 	return SelectAst.from(DerivedTableSource.as(innerAlias, inner)).withProjection([ProjectionItem.of(include.relationName, outerJsonObjectExpr)]);
 }
-function buildIncludeAggregateExpr(scalar, childTableRef, lower, inputCodec) {
-	const expr = scalar.column === void 0 ? void 0 : ColumnRef.of(childTableRef, scalar.column);
+function buildIncludeAggregateExpr(scalar, expr, lower, inputCodec) {
 	if (lower !== void 0) return lower({
 		expr,
 		inputCodec
@@ -2171,13 +2241,13 @@ function buildIncludeAggregateExpr(scalar, childTableRef, lower, inputCodec) {
 * branch fan out naturally because the row builder is invoked with
 * a synthetic IncludeExpr whose `nested` is the branch's state.
 */
-function buildIncludeChildCombineSelect(contract, aggregates, parentSource, include, branches) {
+function buildIncludeChildCombineSelect(contract, aggregates, scope, parent, include, branches) {
 	const branchEntries = Object.entries(branches);
 	if (branchEntries.length === 0) throw ormError("ORM.INCLUDE_INVALID", `combine() include "${include.relationName}" has no branches`, { meta: { relation: include.relationName } });
 	const compiledBranches = branchEntries.map(([name, branch]) => ({
 		name,
-		alias: `${include.relationName}__combine__${name}`,
-		select: buildIncludeChildCombineBranchSelect(contract, aggregates, parentSource, include, branch)
+		alias: scope.alias(`${include.relationName}__combine__${name}`),
+		select: buildIncludeChildCombineBranchSelect(contract, aggregates, scope, parent, include, branch)
 	}));
 	const jsonObjectExpr = JsonObjectExpr.fromEntries(compiledBranches.map((branch) => JsonObjectExpr.entry(branch.name, jsonEntryProjection(ColumnRef.of(branch.alias, include.relationName), { document: true }))));
 	const [firstBranch, ...restBranches] = compiledBranches;
@@ -2191,9 +2261,9 @@ function buildIncludeChildCombineSelect(contract, aggregates, parentSource, incl
 * relation name. Dispatches to the standalone scalar / row builders
 * with the branch's state spliced into a synthetic IncludeExpr.
 */
-function buildIncludeChildCombineBranchSelect(contract, aggregates, parentSource, include, branch) {
-	if (branch.kind === "scalar") return buildIncludeChildScalarSelect(contract, aggregates, parentSource, include, branch.selector);
-	return buildIncludeChildRowsAggregateSelect(contract, aggregates, parentSource, {
+function buildIncludeChildCombineBranchSelect(contract, aggregates, scope, parent, include, branch) {
+	if (branch.kind === "scalar") return buildIncludeChildScalarSelect(contract, aggregates, scope, parent, include, branch.selector);
+	return buildIncludeChildRowsAggregateSelect(contract, aggregates, scope, parent, {
 		...include,
 		nested: branch.state,
 		scalar: void 0,
@@ -2206,103 +2276,98 @@ function buildIncludeChildCombineBranchSelect(contract, aggregates, parentSource
 * name. Used by both the standalone row correlated-subquery path and
 * by combine's row branches.
 */
-function buildIncludeChildRowsAggregateSelect(contract, aggregates, parentSource, include) {
-	const { childRows, childProjection, documentAliases, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, aggregates, parentSource, include);
+function buildIncludeChildRowsAggregateSelect(contract, aggregates, scope, parent, include) {
+	const { childRows, childProjection, documentAliases, rowsAlias, aggregateOrderBy } = buildIncludeChildRowsSelect(contract, aggregates, scope, parent, include);
 	const jsonObjectExpr = JsonObjectExpr.fromEntries(childProjection.map((item) => JsonObjectExpr.entry(item.alias, jsonEntryProjection(ColumnRef.of(rowsAlias, item.alias), {
 		codec: item.codec,
 		document: documentAliases.has(item.alias)
 	}))));
 	return SelectAst.from(DerivedTableSource.as(rowsAlias, childRows)).withProjection([ProjectionItem.of(include.relationName, JsonArrayAggExpr.of(jsonEntryProjection(jsonObjectExpr, { document: true }), "emptyArray", aggregateOrderBy))]);
 }
-function buildCorrelatedIncludeProjection(contract, aggregates, parentSource, include) {
+function buildCorrelatedIncludeProjection(contract, aggregates, scope, parent, include) {
 	if (include.scalar) {
-		const scalarSelect = buildIncludeChildScalarSelect(contract, aggregates, parentSource, include, include.scalar);
+		const scalarSelect = buildIncludeChildScalarSelect(contract, aggregates, scope, parent, include, include.scalar);
 		return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(scalarSelect)) };
 	}
 	if (include.combine) {
-		const combineSelect = buildIncludeChildCombineSelect(contract, aggregates, parentSource, include, include.combine);
+		const combineSelect = buildIncludeChildCombineSelect(contract, aggregates, scope, parent, include, include.combine);
 		return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(combineSelect)) };
 	}
-	const aggregateQuery = buildIncludeChildRowsAggregateSelect(contract, aggregates, parentSource, include);
+	const aggregateQuery = buildIncludeChildRowsAggregateSelect(contract, aggregates, scope, parent, include);
 	return { projection: ProjectionItem.of(include.relationName, SubqueryExpr.of(aggregateQuery)) };
 }
-function buildSelectAst(contract, modelName, tableName, state, options) {
-	const namespaceId = options.namespaceId;
+function buildSelectAst(contract, modelName, state, options) {
+	const { root } = state.tables;
+	const { namespaceId, tableName } = root.storage;
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) {
 		assertDistinctOnCapability(contract, "distinctOn");
 		assertDistinctOnCompatibleOrder(state.orderBy, state.distinctOn.length);
 	}
 	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))));
+	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))));
 	let ast = SelectAst.from(fromSource).withProjection(projection);
 	if (effectiveWhere) ast = ast.withWhere(effectiveWhere);
 	if (state.orderBy) ast = ast.withOrderBy(state.orderBy);
 	if (state.selectedFields === void 0) ast = ast.withSelectAllIntent({ table: tableName });
-	if (state.distinctOn && state.distinctOn.length > 0) ast = ast.withDistinctOn(state.distinctOn.map((column) => ColumnRef.of(tableName, column)));
+	if (state.distinctOn && state.distinctOn.length > 0) ast = ast.withDistinctOn(state.distinctOn.map((column) => root.column(column)));
 	if (state.limit !== void 0) ast = ast.withLimit(state.limit);
 	if (state.offset !== void 0) ast = ast.withOffset(state.offset);
 	if (options.joins && options.joins.length > 0) ast = ast.withJoins(options.joins);
 	if (state.locking !== void 0) ast = ast.withLocking(state.locking);
 	return ast;
 }
-function compileSelect(contract, namespaceId, modelName, tableName, state) {
+function buildRootPolymorphism(contract, state, modelName) {
+	const { root } = state.tables;
+	const { namespaceId } = root.storage;
+	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
+	if (!polyInfo) return {
+		projectionState: state,
+		joins: [],
+		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;
+	return {
+		projectionState: {
+			...state,
+			selectedFields: selection.baseSelectedFields
+		},
+		joins: mtiArtifacts?.joins ?? [],
+		projection: [...mtiArtifacts?.projection ?? [], ...buildHiddenDiscriminatorProjection(contract, root, polyInfo, selection.needsHiddenDiscriminator)]
+	};
+}
+function compileSelect(contract, modelName, state) {
 	assertLockCompatible(state);
 	if (state.distinctOn !== void 0 && state.distinctOn.length > 0) assertDistinctOnCapability(contract, "distinctOn");
-	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, modelName, tableName, {
-		...projectionState,
+	const polymorphism = buildRootPolymorphism(contract, state, modelName);
+	const ast = buildSelectAst(contract, modelName, {
+		...polymorphism.projectionState,
 		includes: []
 	}, {
-		joins: mtiArtifacts?.joins ?? [],
-		includeProjection: [...mtiArtifacts?.projection ?? [], ...hiddenProjection],
-		namespaceId
+		joins: polymorphism.joins,
+		includeProjection: polymorphism.projection
 	});
 	const { params } = deriveParamsFromAst(ast);
 	return buildOrmQueryPlan(contract, ast, params, state.annotations);
 }
-function compileSelectWithIncludes(contract, aggregates, namespaceId, modelName, tableName, state) {
+function compileSelectWithIncludes(contract, aggregates, modelName, state) {
 	assertLockCompatible(state);
-	const includeJoins = [];
-	const includeProjection = [];
-	const topLevelWhere = buildStateWhere(contract, tableName, state, { namespaceId });
-	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;
-	if (polyInfo && selection) {
-		if (polyInfo.mtiVariants.length > 0) {
-			const mtiArtifacts = buildMtiJoins(contract, namespaceId, polyInfo, state.variantName, selection.selectedMtiColumnsByTable);
-			includeJoins.push(...mtiArtifacts.joins);
-			includeProjection.push(...mtiArtifacts.projection);
-		}
-		includeProjection.push(...buildHiddenDiscriminatorProjection(contract, namespaceId, polyInfo, tableName, selection.needsHiddenDiscriminator));
-	}
-	const parentSource = {
-		baseTableName: tableName,
-		tableRef: tableName,
-		variantColumnsProjected: false
-	};
+	const topLevelWhere = buildStateWhere(contract, state);
+	const polymorphism = buildRootPolymorphism(contract, state, modelName);
+	const includeProjection = [...polymorphism.projection];
+	const scope = state.tables.scope.copy();
+	const parent = { tables: state.tables };
 	for (const include of state.includes) {
-		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, parentSource, include);
+		const artifact = buildCorrelatedIncludeProjection(contract, aggregates, scope, parent, include);
 		includeProjection.push(artifact.projection);
 	}
-	const ast = buildSelectAst(contract, modelName, tableName, {
-		...projectionState,
+	const ast = buildSelectAst(contract, modelName, {
+		...polymorphism.projectionState,
 		includes: []
 	}, {
-		joins: includeJoins,
+		joins: polymorphism.joins,
 		includeProjection,
-		namespaceId,
 		...ifDefined("where", topLevelWhere)
 	});
 	const { params } = deriveParamsFromAst(ast);
@@ -2318,19 +2383,19 @@ function describeCollectionRows(options) {
 	};
 }
 function describeExecutionRows(options) {
-	const { context, state, tableName, modelName, namespaceId } = options;
+	const { context, state, modelName, namespaceId } = options;
 	const { contract } = context;
 	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
 	if (state.includes.length === 0) {
-		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));
+		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));
 		return {
 			plan: compiled,
 			consume: (rows) => mapResultRows(rows, mapper)
 		};
 	}
 	return {
-		plan: compileSelectWithIncludes(contract, context.aggregateDescriptors, namespaceId, modelName, tableName, state),
+		plan: compileSelectWithIncludes(contract, context.aggregateDescriptors, modelName, state),
 		consume: (rows) => consumeIncludeRows(context, state, namespaceId, modelName, rows)
 	};
 }
@@ -2344,16 +2409,16 @@ function deferResolution(resolve) {
 		};
 	}
 }
-function createPreparedMapper(contract, namespaceId, modelName, variantName) {
+function createPreparedMapper(contract, namespaceId, modelName, state) {
 	const resolved = deferResolution(() => {
 		const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-		return polyInfo ? createPolymorphicRowMapper(contract, namespaceId, modelName, polyInfo, variantName) : createStorageRowMapper(contract, namespaceId, modelName);
+		return polyInfo ? createPolymorphicRowMapper(contract, namespaceId, modelName, polyInfo, state.tables, state.variantName) : createStorageRowMapper(contract, namespaceId, modelName);
 	});
 	return (row) => resolved()(row);
 }
 function createPreparedRowsConsumer(options) {
 	const { context, state, namespaceId, modelName } = options;
-	const mapRow = createPreparedMapper(context.contract, namespaceId, modelName, state.variantName);
+	const mapRow = createPreparedMapper(context.contract, namespaceId, modelName, state);
 	const includes = state.includes.map((include) => createPreparedIncludeConsumer(context, include));
 	const castRow = (row) => blindCast(row);
 	if (includes.length === 0) return (rows) => mapResultRows(rows, (row) => castRow(mapRow(row)));
@@ -2393,12 +2458,15 @@ function createPreparedIncludeConsumer(context, include) {
 			}
 		};
 	}
-	const mapRow = createPreparedMapper(contract, include.relatedNamespaceId, include.relatedModelName, include.nested.variantName);
+	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 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}`);
+		for (const variant of polyInfo?.mtiVariants ?? []) {
+			const variantTable = requireVariantTable(include.nested.tables, variant.modelName);
+			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))]));
 	});
 	const bindingFor = (key) => bindings().get(key)?.() ?? null;
@@ -2482,11 +2550,10 @@ function describeCollectionFirstOrThrow(options) {
 	};
 }
 function dispatchCollectionRows(options) {
-	const { context, runtime, state, tableName, modelName, namespaceId } = options;
+	const { context, runtime, state, modelName, namespaceId } = options;
 	const descriptionOptions = {
 		context,
 		state,
-		tableName,
 		modelName,
 		namespaceId
 	};
@@ -2510,7 +2577,7 @@ function consumeIncludeRows(context, state, namespaceId, modelName, rows) {
 		const parentRows = parentRowsRaw.map((row) => {
 			return {
 				raw: row,
-				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
+				mapped: polyInfo ? mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, state.tables, row, state.variantName) : mapStorageRowToModelFields(contract, namespaceId, modelName, row)
 			};
 		});
 		const bindings = /* @__PURE__ */ new WeakMap();
@@ -2538,26 +2605,26 @@ function consumeIncludeRows(context, state, namespaceId, modelName, rows) {
 * its snapshot before issuing the DELETE (see `collection.ts`).
 */
 function reloadMutationRowsByIdentities(options) {
-	const { context, runtime, tableName, modelName, namespaceId, identityRows, selectedFields, includes } = options;
+	const { context, runtime, tables, modelName, namespaceId, identityRows, selectedFields, includes } = options;
 	const { contract } = context;
+	const { tableName } = tables.root.storage;
 	if (identityRows.length === 0) return emptyResult();
 	const identityColumns = resolveRowIdentityColumns(contract, namespaceId, tableName);
 	if (identityColumns.length === 0) throw ormError("ORM.ROW_IDENTITY_MISSING", `Cannot load includes for the mutation result on model "${modelName}": table "${tableName}" has no primary key or unique constraint to key the include read-back on.`, { meta: {
 		model: modelName,
 		table: tableName
 	} });
-	const identityFilter = buildIdentityInFilter(contract, namespaceId, tableName, identityColumns, identityRows);
+	const identityFilter = buildIdentityInFilter(contract, tables.root, identityColumns, identityRows);
 	if (!identityFilter) return emptyResult();
 	return dispatchCollectionRows({
 		context,
 		runtime,
 		state: {
-			...emptyState(),
+			...emptyState(tables),
 			filters: [identityFilter],
 			selectedFields,
 			includes
 		},
-		tableName,
 		modelName,
 		namespaceId
 	});
@@ -2565,16 +2632,17 @@ function reloadMutationRowsByIdentities(options) {
 function emptyResult() {
 	return new AsyncIterableResult((async function* () {})());
 }
-function buildIdentityInFilter(contract, namespaceId, tableName, identityColumns, identityRows) {
+function buildIdentityInFilter(contract, table, identityColumns, identityRows) {
+	const { storage } = table;
 	const [singleColumn, ...rest] = identityColumns;
 	if (singleColumn !== void 0 && rest.length === 0) {
 		const values = identityRows.map((row) => row[singleColumn]).filter((value) => value !== void 0);
 		if (values.length === 0) return;
-		return bindWhereExpr(contract, BinaryExpr.in(ColumnRef.of(tableName, singleColumn), ListExpression.fromValues(values)), namespaceId);
+		return BinaryExpr.in(table.column(singleColumn), ListExpression.of(values.map((value) => paramRefForStorageColumn(contract, storage, singleColumn, value))));
 	}
 	if (identityRows.length === 0) return;
-	const tuples = identityRows.map((row) => AndExpr.of(identityColumns.map((column) => BinaryExpr.eq(ColumnRef.of(tableName, column), LiteralExpr.of(row[column])))));
-	return bindWhereExpr(contract, OrExpr.of(tuples), namespaceId);
+	const tuples = identityRows.map((row) => AndExpr.of(identityColumns.map((column) => BinaryExpr.eq(table.column(column), paramRefForStorageColumn(contract, storage, column, row[column])))));
+	return OrExpr.of(tuples);
 }
 /**
 * Decode a single-query include payload from a parent row's raw cell
@@ -2602,7 +2670,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, 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.variantName) : createStorageRowMapper(contract, include.relatedNamespaceId, include.relatedModelName);
 	let columns = bindings.get(include);
 	if (!columns) {
 		columns = /* @__PURE__ */ new Map();
@@ -2646,17 +2714,18 @@ function decodeIncludedStorageRow(row, bindingFor) {
 function resolveIncludedColumnBinding(contract, context, include, key) {
 	const ref = resolveIncludedColumnRef(contract, include, key);
 	if (!ref) return null;
-	const codec = context.contractCodecs.forColumn(include.relatedNamespaceId, ref.table, ref.column);
+	const codec = context.contractCodecs.forColumn(ref.namespaceId, ref.table, ref.column);
 	if (!codec) return null;
 	return {
 		ref,
 		codec,
-		codecId: context.codecDescriptors.codecRefForColumn(include.relatedNamespaceId, ref.table, ref.column)?.codecId ?? ref.storageColumn.codecId
+		codecId: context.codecDescriptors.codecRefForColumn(ref.namespaceId, ref.table, ref.column)?.codecId ?? ref.storageColumn.codecId
 	};
 }
 function resolveIncludedColumnRef(contract, include, key) {
 	const baseColumn = resolveColumn(contract, include.relatedNamespaceId, include.relatedTableName, key);
 	if (baseColumn) return {
+		namespaceId: include.relatedNamespaceId,
 		table: include.relatedTableName,
 		column: key,
 		storageColumn: baseColumn
@@ -2664,12 +2733,15 @@ function resolveIncludedColumnRef(contract, include, key) {
 	const polyInfo = resolvePolymorphismInfo(contract, include.relatedNamespaceId, include.relatedModelName);
 	if (!polyInfo) return;
 	for (const variant of polyInfo.mtiVariants) {
-		const prefix = `${variant.table}__`;
+		const variantTable = requireVariantTable(include.nested.tables, variant.modelName);
+		const prefix = variantColumnLabelPrefix(variantTable);
 		if (!key.startsWith(prefix)) continue;
 		const column = key.slice(prefix.length);
-		const variantColumn = resolveColumn(contract, include.relatedNamespaceId, variant.table, column);
+		const { namespaceId, tableName } = variantTable.storage;
+		const variantColumn = resolveColumn(contract, namespaceId, tableName, column);
 		if (variantColumn) return {
-			table: variant.table,
+			namespaceId,
+			table: tableName,
 			column,
 			storageColumn: variantColumn
 		};
@@ -2830,14 +2902,14 @@ function parseIncludePayload(value) {
 		return [];
 	}
 }
-function createMutationRowMapper(contract, namespaceId, modelName, variantName) {
+function createMutationRowMapper(contract, namespaceId, modelName, tables, variantName) {
 	const polyInfo = resolvePolymorphismInfo(contract, namespaceId, modelName);
-	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, row, variantName) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
+	return polyInfo ? (row) => mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, row, variantName) : (row) => mapStorageRowToModelFields(contract, namespaceId, modelName, row);
 }
 function dispatchMutationRows(options) {
-	const { context, runtime, compiled, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { context, runtime, compiled, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
 	if (includes.length === 0) return mapResultRows(queryPlanRows(runtime, compiled), (rawRow) => {
 		const mapped = mapStorageRow(rawRow);
 		if (hiddenColumns.length > 0) stripHiddenMappedFields(contract, namespaceId, modelName, mapped, hiddenColumns);
@@ -2848,7 +2920,7 @@ function dispatchMutationRows(options) {
 		yield* reloadMutationRowsByIdentities({
 			context,
 			runtime,
-			tableName,
+			tables,
 			modelName,
 			namespaceId,
 			identityRows,
@@ -2859,9 +2931,9 @@ function dispatchMutationRows(options) {
 	return new AsyncIterableResult(generator());
 }
 function dispatchSplitMutationRows(options) {
-	const { context, runtime, plans, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
+	const { context, runtime, plans, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
 	const generator = async function* () {
 		if (includes.length > 0) {
 			const identityRows = [];
@@ -2869,7 +2941,7 @@ function dispatchSplitMutationRows(options) {
 			yield* reloadMutationRowsByIdentities({
 				context,
 				runtime,
-				tableName,
+				tables,
 				modelName,
 				namespaceId,
 				identityRows,
@@ -2887,9 +2959,9 @@ function dispatchSplitMutationRows(options) {
 	return new AsyncIterableResult(generator());
 }
 async function executeMutationReturningSingleRow(options) {
-	const { context, runtime, compiled, tableName, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
+	const { context, runtime, compiled, tables, modelName, namespaceId, variantName, includes, selectedFields, hiddenColumns, mapRow, operation, onMissingRowMessage } = options;
 	const { contract } = context;
-	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, variantName);
+	const mapStorageRow = createMutationRowMapper(contract, namespaceId, modelName, tables, variantName);
 	if (includes.length === 0) {
 		const first = (await queryPlanRows(runtime, compiled).toArray())[0];
 		if (!first) return null;
@@ -2902,7 +2974,7 @@ async function executeMutationReturningSingleRow(options) {
 	for await (const row of reloadMutationRowsByIdentities({
 		context,
 		runtime,
-		tableName,
+		tables,
 		modelName,
 		namespaceId,
 		identityRows,
@@ -2912,7 +2984,7 @@ async function executeMutationReturningSingleRow(options) {
 	throw ormError("ORM.MUTATION_ROW_MISSING", onMissingRowMessage, { meta: {
 		operation,
 		model: modelName,
-		tableName
+		tableName: tables.root.storage.tableName
 	} });
 }
 /** The filter expression of a condition: a condition from `fns` becomes its AST. */
@@ -2938,20 +3010,20 @@ function not(expr) {
 function all() {
 	return AndExpr.true();
 }
-function shorthandToWhereExpr(context, namespaceId, modelName, filters) {
+function shorthandToWhereExpr(context, namespaceId, modelName, filters, table) {
 	const contract = context.contract;
-	const tableName = resolveModelTableName(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 left = ColumnRef.of(tableName, columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName));
+		const columnName = columnOfCallerField(contract, namespaceId, fieldColumns, modelName, fieldName);
+		const left = table.column(columnName);
 		if (value === null) {
 			exprs.push(NullCheckExpr.isNull(left));
 			continue;
 		}
 		assertFieldHasEqualityTrait(context, namespaceId, modelName, fieldName);
-		exprs.push(predicateComparison("eq", left, predicateExpression(value) ?? LiteralExpr.of(value)));
+		exprs.push(predicateComparison("eq", left, predicateExpression(value) ?? paramRefForStorageColumn(contract, table.storage, columnName, value)));
 	}
 	if (exprs.length === 0) return;
 	return exprs.length === 1 ? exprs[0] : and(...exprs);
@@ -3419,103 +3491,21 @@ function createCallbackTools(context, indexes) {
 function hasThrough$1(relation) {
 	return relation.through !== void 0;
 }
-var SqlTableBinding = class SqlTableBinding {
-	#storage;
-	#reference;
-	constructor(storage, reference) {
-		this.#storage = Object.freeze({ ...storage });
-		this.#reference = reference;
-		Object.freeze(this);
-	}
-	static unaliased(storage) {
-		return new SqlTableBinding(storage, storage.tableName);
-	}
-	static aliased(storage, alias) {
-		return new SqlTableBinding(storage, alias);
-	}
-	column(columnName) {
-		return ColumnRef.of(this.#reference, columnName);
-	}
-	tableSource(contract) {
-		return tableSourceForContract(contract, this.#storage.namespaceId, this.#storage.tableName, this.#reference);
-	}
-	isReferencedAs(candidate) {
-		return this.#reference === candidate;
-	}
-	isStoredAt(namespaceId, tableName) {
-		return this.#storage.namespaceId === namespaceId && this.#storage.tableName === tableName;
-	}
-};
-var ModelAccessorScope = class ModelAccessorScope {
-	current;
-	#visibleBindings;
-	#aliasCounter;
-	constructor(current, visibleBindings, aliasCounter) {
-		this.current = current;
-		this.#visibleBindings = Object.freeze([...visibleBindings]);
-		this.#aliasCounter = aliasCounter;
-		Object.freeze(this);
-	}
-	static root(namespaceId, tableName) {
-		const binding = SqlTableBinding.unaliased({
-			namespaceId,
-			tableName
-		});
-		return new ModelAccessorScope(binding, [binding], { nextId: 1 });
-	}
-	forRelation(namespaceId, tableName) {
-		const binding = this.#allocateBinding(namespaceId, tableName, "rel");
-		return new ModelAccessorScope(binding, [...this.#visibleBindings, binding], this.#aliasCounter);
-	}
-	forManyToManyRelation(childNamespaceId, childTableName, junctionNamespaceId, junctionTableName) {
-		const initialChildScope = this.forRelation(childNamespaceId, childTableName);
-		const junctionBinding = initialChildScope.#allocateBinding(junctionNamespaceId, junctionTableName, "junction");
-		return {
-			childScope: new ModelAccessorScope(initialChildScope.current, [...initialChildScope.#visibleBindings, junctionBinding], this.#aliasCounter),
-			junctionBinding
-		};
-	}
-	forJoinedSource(namespaceId, tableName) {
-		if (this.current.isStoredAt(namespaceId, tableName)) return this;
-		const binding = SqlTableBinding.unaliased({
-			namespaceId,
-			tableName
-		});
-		return new ModelAccessorScope(binding, [...this.#visibleBindings, binding], this.#aliasCounter);
-	}
-	#allocateBinding(namespaceId, tableName, aliasKind) {
-		const storage = {
-			namespaceId,
-			tableName
-		};
-		if (!this.#visibleBindings.some((binding) => binding.isReferencedAs(tableName))) return SqlTableBinding.unaliased(storage);
-		return SqlTableBinding.aliased(storage, this.#allocateAlias(aliasKind));
-	}
-	#allocateAlias(kind) {
-		while (true) {
-			const alias = `__orm_${kind}_${this.#aliasCounter.nextId}`;
-			this.#aliasCounter.nextId += 1;
-			if (!this.#visibleBindings.some((binding) => binding.isReferencedAs(alias))) return alias;
-		}
-	}
-};
-function createModelAccessor(context, namespaceId, modelName, variantName) {
-	const tableName = resolveModelTableName(context.contract, namespaceId, modelName);
-	return createModelAccessorInScope(context, namespaceId, modelName, variantName, ModelAccessorScope.root(namespaceId, tableName));
+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));
 }
 /**
 * 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.
 */
-function createModelCallbackTools(context, namespaceId, modelName) {
-	const tableName = resolveModelTableName(context.contract, namespaceId, modelName);
-	return callbackToolsFor(context, namespaceId, modelName, ModelAccessorScope.root(namespaceId, tableName));
+function createModelCallbackTools(context, modelName, tables) {
+	return callbackToolsFor(context, modelName, tables.root);
 }
-function callbackToolsFor(context, namespaceId, modelName, scope) {
-	return createCallbackTools(context, () => indexReferencesOf(context, namespaceId, modelName, scope.current));
+function callbackToolsFor(context, modelName, aliasedTable) {
+	return createCallbackTools(context, () => indexReferencesOf(context, modelName, aliasedTable));
 }
-function indexReferencesOf(context, namespaceId, modelName, binding) {
+function indexReferencesOf(context, modelName, aliasedTable) {
 	const { contract } = context;
-	const tableName = resolveModelTableName(contract, namespaceId, modelName);
+	const { namespaceId, tableName } = aliasedTable.storage;
 	const resolved = resolveTableForContract(contract, namespaceId, tableName);
 	if (!resolved) throw new InternalError(`Model "${modelName}" is stored in table "${tableName}", which the contract does not have`);
 	const { table } = resolved;
@@ -3532,22 +3522,21 @@ function indexReferencesOf(context, namespaceId, modelName, binding) {
 					nullable: column.nullable,
 					...ifDefined("codec", codecRefForStorageColumn(contract.storage, namespaceId, tableName, columnName))
 				},
-				buildAst: () => binding.column(columnName)
+				buildAst: () => aliasedTable.column(columnName)
 			};
 		}
 	});
 }
-function createModelAccessorInScope(context, namespaceId, modelName, variantName, scope) {
+function createModelAccessorInScope(context, namespaceId, modelName, variantName, scope, table, variantTable) {
 	const contract = context.contract;
 	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) : {};
 	const variantCoordinates = variantName ? {
 		name: variantName,
-		relations: resolveModelRelations(contract, namespaceId, variantName),
-		tableName: resolvePolymorphismInfo(contract, namespaceId, modelName)?.variants.get(variantName)?.table ?? tableName
+		relations: resolveModelRelations(contract, namespaceId, variantName)
 	} : void 0;
+	const variantFieldTable = variantTable ?? table;
 	const opsByCodecId = /* @__PURE__ */ new Map();
 	function registerOp(codecId, op) {
 		let existing = opsByCodecId.get(codecId);
@@ -3571,27 +3560,27 @@ 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.forJoinedSource(namespaceId, variantCoordinates.tableName), variantRelation);
+			if (variantRelation) return createRelationFilterAccessor(context, namespaceId, variantCoordinates.name, scope, variantFieldTable, variantRelation);
 		}
 		const relation = Object.hasOwn(modelRelations, prop) ? modelRelations[prop] : void 0;
-		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, scope, relation);
+		if (relation) return createRelationFilterAccessor(context, namespaceId, modelName, scope, table, relation);
 		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 fieldTable = variantField ? variantFieldTable : table;
+		const fieldStorage = fieldTable.storage;
 		const columnName = variantField?.column ?? columnOfCallerField(contract, namespaceId, fieldColumns, addressedModelName(modelName, variantName), prop);
-		const column = resolveColumn(contract, namespaceId, resolvedTable, columnName);
-		if (!column) throw new InternalError(`Field "${modelName}.${prop}" maps column "${columnName}", which table "${resolvedTable}" does not have`);
+		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);
 		const operations = opsByCodecId.get(column.codecId) ?? [];
-		const codec = codecRefForStorageColumn(contract.storage, namespaceId, resolvedTable, columnName);
-		return createScalarFieldAccessor(fieldBinding, columnName, column.codecId, column.nullable, codec, traits, operations, context);
+		const codec = codecRefForStorageColumn(contract.storage, fieldStorage.namespaceId, fieldStorage.tableName, columnName);
+		return createScalarFieldAccessor(fieldTable, columnName, column.codecId, column.nullable, codec, traits, operations, context);
 	} }));
 }
-function createScalarFieldAccessor(tableBinding, columnName, codecId, nullable, codec, traits, operations, context) {
-	const column = tableBinding.column(columnName);
+function createScalarFieldAccessor(table, columnName, codecId, nullable, codec, traits, operations, context) {
+	const column = table.column(columnName);
 	const comparisonEntries = [];
 	for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
 		if (meta.traits.some((t) => !traits.includes(t))) continue;
@@ -3631,13 +3620,13 @@ const RELATION_ACCESSOR_METHOD_NAMES = /* @__PURE__ */ new Set([
 	"none",
 	"count"
 ]);
-function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, parentScope, relation) {
+function createRelationFilterAccessor(context, parentNamespaceId, parentModelName, scope, parentTable, relation) {
 	const relatedTableName = resolveModelTableName(context.contract, relation.toNamespace, relation.to);
-	const correlate = () => correlateRelatedRows(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation);
+	const correlate = () => correlateRelatedRows(context, parentNamespaceId, parentModelName, scope, parentTable, relatedTableName, relation);
 	const filters = {
-		some: (predicate) => buildExistsExpr(context, relation, correlate(), "some", predicate),
-		every: (predicate) => buildExistsExpr(context, relation, correlate(), "every", predicate),
-		none: (predicate) => buildExistsExpr(context, relation, correlate(), "none", predicate)
+		some: (predicate) => buildExistsExpr(context, relation, scope, correlate(), "some", predicate),
+		every: (predicate) => buildExistsExpr(context, relation, scope, correlate(), "every", predicate),
+		none: (predicate) => buildExistsExpr(context, relation, scope, correlate(), "none", predicate)
 	};
 	if (isToOneCardinality(relation.cardinality)) return new Proxy(filters, { get(target, prop) {
 		if (typeof prop !== "string") return void 0;
@@ -3648,7 +3637,7 @@ function createRelationFilterAccessor(context, parentNamespaceId, parentModelNam
 	} });
 	return {
 		...filters,
-		count: (predicate) => createOrderable(() => buildRelationCountExpr(context, relation, correlate(), predicate))
+		count: (predicate) => createOrderable(() => buildRelationCountExpr(context, relation, scope, correlate(), predicate))
 	};
 }
 /**
@@ -3672,39 +3661,45 @@ function relatedOrderableField(context, relation, relatedTableName, correlate, f
 	if (!column || !hasTrait(context, column.codecId, "order")) return void 0;
 	return createOrderable(() => {
 		const rows = correlate();
-		return SubqueryExpr.of(rows.source.withProjection([ProjectionItem.of(columnName, rows.childScope.current.column(columnName))]).withWhere(rows.correlation));
+		return SubqueryExpr.of(rows.source.withProjection([ProjectionItem.of(columnName, rows.child.column(columnName))]).withWhere(rows.correlation));
 	});
 }
-function buildRelationCountExpr(context, relation, rows, predicate) {
-	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, rows.childScope);
+function buildRelationCountExpr(context, relation, scope, rows, predicate) {
+	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, scope, rows.child);
 	return SubqueryExpr.of(rows.source.withProjection([ProjectionItem.of("count", plainAggregateExpr("count", void 0))]).withWhere(childWhere ? and(rows.correlation, childWhere) : rows.correlation));
 }
-function correlateRelatedRows(context, parentNamespaceId, parentModelName, parentScope, relatedTableName, relation) {
+function correlateRelatedRows(context, parentNamespaceId, parentModelName, scope, parentTable, relatedTableName, relation) {
+	const child = scope.aliasTable({
+		namespaceId: relation.toNamespace,
+		tableName: relatedTableName
+	});
 	if (hasThrough$1(relation)) {
 		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 junction = scope.aliasTable({
+			namespaceId: through.namespaceId,
+			tableName: through.table
+		});
+		const junctionJoinOn = buildPairedColumnExprs(junction, through.childColumns, child, through.targetColumns);
 		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)]),
-			correlation: buildPairedColumnExprs(junctionBinding, through.parentColumns, parentScope.current, parentLocalColumns),
+			child,
+			source: SelectAst.from(child.tableSource(context.contract)).withJoins([JoinAst.inner(junction.tableSource(context.contract), junctionJoinOn)]),
+			correlation: buildPairedColumnExprs(junction, through.parentColumns, parentTable, parentLocalColumns),
 			keyColumn: firstJoinColumn(through.targetColumns, "targetColumns")
 		};
 	}
-	const childScope = parentScope.forRelation(relation.toNamespace, relatedTableName);
 	return {
-		childScope,
-		source: SelectAst.from(childScope.current.tableSource(context.contract)),
-		correlation: buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentScope.current, childScope.current, relation),
+		child,
+		source: SelectAst.from(child.tableSource(context.contract)),
+		correlation: buildJoinWhere(context.contract, parentNamespaceId, parentModelName, parentTable, child, relation),
 		keyColumn: firstJoinColumn(resolveRelationTargetColumns(context.contract, relation), "targetFields")
 	};
 }
-function buildExistsExpr(context, relation, rows, mode, predicate) {
-	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, rows.childScope);
+function buildExistsExpr(context, relation, scope, rows, mode, predicate) {
+	const childWhere = toRelationWhereExpr(context, relation.toNamespace, relation.to, predicate, scope, rows.child);
 	const filterPlan = planRelationFilterMode(rows.correlation, childWhere, mode);
 	if (filterPlan.kind === "constantTrue") return AndExpr.true();
-	const subquery = rows.source.withProjection([ProjectionItem.of("_exists", rows.childScope.current.column(rows.keyColumn))]).withWhere(filterPlan.where);
+	const subquery = rows.source.withProjection([ProjectionItem.of("_exists", rows.child.column(rows.keyColumn))]).withWhere(filterPlan.where);
 	return filterPlan.notExists ? ExistsExpr.notExists(subquery) : ExistsExpr.exists(subquery);
 }
 function planRelationFilterMode(joinWhere, childWhere, mode) {
@@ -3745,10 +3740,10 @@ function buildPairedColumnExprs(leftTable, leftColumns, rightTable, rightColumns
 	if (exprs.length === 1 && exprs[0]) return exprs[0];
 	return and(...exprs);
 }
-function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, predicate, scope) {
+function toRelationWhereExpr(context, relatedNamespaceId, relatedModelName, predicate, scope, table) {
 	if (!predicate) return;
-	const accessor = createModelAccessorInScope(context, relatedNamespaceId, relatedModelName, void 0, scope);
-	if (typeof predicate === "function") return conditionExpr(predicate(accessor, callbackToolsFor(context, relatedNamespaceId, relatedModelName, scope)));
+	const accessor = createModelAccessorInScope(context, relatedNamespaceId, relatedModelName, void 0, scope, table, void 0);
+	if (typeof predicate === "function") return conditionExpr(predicate(accessor, callbackToolsFor(context, relatedModelName, table)));
 	assertModelFieldNames(context.contract, relatedNamespaceId, relatedModelName, predicate);
 	const exprs = [];
 	for (const [fieldName, value] of Object.entries(predicate)) {
@@ -3824,7 +3819,7 @@ var GroupedCollection = class GroupedCollection {
 		}));
 	}
 	having(predicate) {
-		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.tableName));
+		const havingExpr = predicate(createHavingBuilder(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.modelName, this.preGroupState.tables.root));
 		return this.#clone({ havingFilters: [...this.havingFilters, havingExpr] });
 	}
 	/**
@@ -3839,12 +3834,19 @@ var GroupedCollection = class GroupedCollection {
 			method: "orderBy",
 			model: this.modelName
 		} });
-		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName);
+		const tables = withScopeCopy(this.preGroupState.tables);
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables);
 		const nextOrders = selectors.map((selector) => selector(accessor));
-		return this.#clone({ postGroup: {
-			...this.postGroup,
-			orderBy: [...this.postGroup.orderBy, ...nextOrders]
-		} });
+		return this.#clone({
+			preGroupState: {
+				...this.preGroupState,
+				tables
+			},
+			postGroup: {
+				...this.postGroup,
+				orderBy: [...this.postGroup.orderBy, ...nextOrders]
+			}
+		});
 	}
 	/**
 	* Apply `LIMIT n` to the grouped rows. Replaces any previous post-group
@@ -3900,7 +3902,7 @@ var GroupedCollection = class GroupedCollection {
 			configure(meta);
 			if (meta.annotations.size > 0) annotationsMap = meta.annotations;
 		}
-		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.preGroupState, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters), this.modelName, this.postGroup), annotationsMap);
+		const compiled = mergeAnnotations(compileGroupedAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.preGroupState, this.groupByColumns, aggregateSpec, combineWhereExprs(this.havingFilters), this.modelName, this.postGroup), annotationsMap);
 		const mapRow = createStorageRowMapper(this.contract, this.namespaceId, this.modelName);
 		return {
 			plan: compiled,
@@ -3924,7 +3926,8 @@ var GroupedCollection = class GroupedCollection {
 * refused. The typed surface already excludes it; the runtime refusal covers
 * dynamic invocation.
 */
-function createHavingBuilder(contract, aggregates, namespaceId, modelName, tableName) {
+function createHavingBuilder(contract, aggregates, namespaceId, modelName, root) {
+	const { tableName } = root.storage;
 	const fieldColumns = getModelFieldColumns(contract, namespaceId, modelName);
 	const builder = {};
 	for (const operation of aggregateOperationNames(aggregates)) builder[operation] = (field) => {
@@ -3934,7 +3937,7 @@ function createHavingBuilder(contract, aggregates, namespaceId, modelName, table
 			meta: { operation }
 		});
 		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({
+		return createHavingComparisonMethods(new AggregateExpr(operation, column === void 0 ? void 0 : root.column(column)), () => resolveAggregate({
 			aggregates,
 			contract,
 			namespaceId,
@@ -4054,7 +4057,7 @@ async function executeNestedCreateMutation(options) {
 	return withMutationScope(options.runtime, async (scope) => createGraph(scope, options.context, options.namespaceId, options.modelName, options.data));
 }
 async function executeNestedUpdateMutation(options) {
-	return withMutationScope(options.runtime, async (scope) => updateFirstGraph(scope, options.context, options.namespaceId, options.modelName, options.filters, options.data));
+	return withMutationScope(options.runtime, async (scope) => updateFirstGraph(scope, options.context, options.namespaceId, options.modelName, options.tables, options.filters, options.data));
 }
 function buildRowIdentityFilterFromRow(contract, namespaceId, modelName, row) {
 	const tableName = resolveModelTableName(contract, namespaceId, modelName);
@@ -4125,9 +4128,9 @@ async function createGraph(scope, context, namespaceId, modelName, input) {
 	for (const relationMutation of junctionOwned) await applyJunctionOwnedMutation(scope, context, namespaceId, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
 	return parentRow;
 }
-async function updateFirstGraph(scope, context, namespaceId, modelName, filters, input) {
+async function updateFirstGraph(scope, context, namespaceId, modelName, tables, filters, input) {
 	const contract = context.contract;
-	const existingRow = await findFirstByFilters(scope, contract, namespaceId, modelName, filters);
+	const existingRow = await findFirstByFilters(scope, contract, namespaceId, modelName, tables, filters);
 	if (!existingRow) return null;
 	const parsed = parseMutationInput(contract, namespaceId, modelName, input);
 	const { parentOwned, childOwned, junctionOwned } = partitionByOwnership(parsed.relationMutations);
@@ -4145,9 +4148,9 @@ async function updateFirstGraph(scope, context, namespaceId, modelName, filters,
 			values: mappedUpdateData
 		});
 		for (const def of appliedUpdateDefaults) mappedUpdateData[def.field] = def.value;
-		const identityWhere = shorthandToWhereExpr(context, namespaceId, modelName, castAs(buildRowIdentityFilterFromRow(contract, namespaceId, modelName, existingRow)));
+		const identityWhere = shorthandToWhereExpr(context, namespaceId, modelName, castAs(buildRowIdentityFilterFromRow(contract, namespaceId, modelName, existingRow)), tables.root);
 		if (!identityWhere) throw new InternalError(`Failed to build row identity filter for model "${modelName}"`);
-		const updatedRaw = (await queryPlanRows(scope, compileUpdateReturning(contract, namespaceId, modelName, tableName, mappedUpdateData, [identityWhere], void 0)).toArray())[0];
+		const updatedRaw = (await queryPlanRows(scope, compileUpdateReturning(contract, modelName, tables, 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);
@@ -4266,7 +4269,8 @@ async function applyChildOwnedMutation(scope, context, parentNamespaceId, parent
 	}
 	if (mutation.kind === "connect") {
 		for (const criterion of mutation.criteria) {
-			const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion));
+			const related = createRelatedTables(relation);
+			const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion), related.root);
 			if (!criterionWhere) throw ormError("ORM.RELATION_MUTATION_INVALID", `connect() nested mutation for relation "${relation.relationName}" requires non-empty criterion`, { meta: {
 				kind: "connect",
 				relation: relation.relationName,
@@ -4274,26 +4278,26 @@ async function applyChildOwnedMutation(scope, context, parentNamespaceId, parent
 			} });
 			const setValues = {};
 			for (const [childColumn, parentValue] of parentValues.entries()) setValues[childColumn] = parentValue;
-			await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [criterionWhere]);
+			await executeUpdateCount(scope, contract, related, setValues, [criterionWhere]);
 		}
 		return;
 	}
 	const setValues = {};
 	for (const childColumn of parentValues.keys()) setValues[childColumn] = null;
 	if (!mutation.criteria || mutation.criteria.length === 0) {
-		const parentJoinWhere = buildChildJoinWhere(relation, parentValues);
-		await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [parentJoinWhere]);
+		const related = createRelatedTables(relation);
+		await executeUpdateCount(scope, contract, related, setValues, [buildChildJoinWhere(contract, related.root, parentValues)]);
 		return;
 	}
 	for (const criterion of mutation.criteria) {
-		const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion));
+		const related = createRelatedTables(relation);
+		const criterionWhere = shorthandToWhereExpr(context, relation.relatedNamespaceId, relation.relatedModelName, castAs(criterion), related.root);
 		if (!criterionWhere) throw ormError("ORM.RELATION_MUTATION_INVALID", `disconnect() nested mutation for relation "${relation.relationName}" requires non-empty criterion`, { meta: {
 			kind: "disconnect",
 			relation: relation.relationName,
 			problem: "empty-criterion"
 		} });
-		const parentJoinWhere = buildChildJoinWhere(relation, parentValues);
-		await executeUpdateCount(scope, contract, relation.relatedNamespaceId, relation.relatedTableName, setValues, [and(parentJoinWhere, criterionWhere)]);
+		await executeUpdateCount(scope, contract, related, setValues, [and(buildChildJoinWhere(contract, related.root, parentValues), criterionWhere)]);
 	}
 }
 async function applyJunctionOwnedMutation(scope, context, parentNamespaceId, parentModelName, parentRow, relation, mutation) {
@@ -4432,11 +4436,15 @@ async function deleteJunctionLink(scope, context, relation, parentPkValues, targ
 	const junctionRow = {};
 	for (const [column, value] of parentPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
 	for (const [column, value] of targetPkValues.entries()) writeJunctionColumn(junctionRow, through, column, value, relation.relationName);
+	const junction = createStatementTables({
+		namespaceId: through.namespaceId,
+		tableName: through.table
+	});
 	const exprs = [];
-	for (const [column, value] of Object.entries(junctionRow)) exprs.push(BinaryExpr.eq(ColumnRef.of(through.table, column), LiteralExpr.of(value)));
+	for (const [column, value] of Object.entries(junctionRow)) exprs.push(BinaryExpr.eq(junction.root.column(column), paramRefForStorageColumn(context.contract, junction.root.storage, column, value)));
 	const first = exprs[0];
 	const where = exprs.length === 1 && first !== void 0 ? first : and(...exprs);
-	const compiled = compileDeleteCount(context.contract, through.namespaceId, through.table, [where]);
+	const compiled = compileDeleteCount(context.contract, junction, [where]);
 	await scope.execute(compiled);
 }
 function readParentColumnValues(contract, parentNamespaceId, parentModelName, relation, parentRow) {
@@ -4452,9 +4460,15 @@ function readParentColumnValues(contract, parentNamespaceId, parentModelName, re
 	}
 	return values;
 }
-function buildChildJoinWhere(relation, childValues) {
+function createRelatedTables(relation) {
+	return createStatementTables({
+		namespaceId: relation.relatedNamespaceId,
+		tableName: relation.relatedTableName
+	});
+}
+function buildChildJoinWhere(contract, related, childValues) {
 	const exprs = [];
-	for (const [childColumn, parentValue] of childValues.entries()) exprs.push(BinaryExpr.eq(ColumnRef.of(relation.relatedTableName, childColumn), LiteralExpr.of(parentValue)));
+	for (const [childColumn, parentValue] of childValues.entries()) exprs.push(BinaryExpr.eq(related.column(childColumn), paramRefForStorageColumn(contract, related.storage, childColumn, parentValue)));
 	const first = exprs[0];
 	if (exprs.length === 1 && first !== void 0) return first;
 	return and(...exprs);
@@ -4480,31 +4494,35 @@ async function insertSingleRow(scope, context, namespaceId, modelName, data) {
 }
 async function findRowByCriterion(scope, context, namespaceId, modelName, criterion) {
 	const contract = context.contract;
-	const whereExpr = shorthandToWhereExpr(context, namespaceId, modelName, castAs(criterion));
+	const tables = createStatementTables({
+		namespaceId,
+		tableName: resolveModelTableName(contract, namespaceId, modelName)
+	});
+	const whereExpr = shorthandToWhereExpr(context, namespaceId, modelName, castAs(criterion), tables.root);
 	if (!whereExpr) throw ormError("ORM.RELATION_MUTATION_INVALID", `Nested connect for model "${modelName}" requires non-empty criterion`, { meta: {
 		kind: "connect",
 		model: modelName,
 		problem: "empty-criterion"
 	} });
-	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, modelName, resolveModelTableName(contract, namespaceId, modelName), {
-		...emptyState(),
+	const firstRow = (await queryPlanRows(scope, compileSelect(contract, modelName, {
+		...emptyState(tables),
 		filters: [whereExpr],
 		limit: 1
 	})).toArray())[0];
 	if (!firstRow) return null;
 	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
 }
-async function findFirstByFilters(scope, contract, namespaceId, modelName, filters) {
-	const firstRow = (await queryPlanRows(scope, compileSelect(contract, namespaceId, modelName, resolveModelTableName(contract, namespaceId, modelName), {
-		...emptyState(),
+async function findFirstByFilters(scope, contract, namespaceId, modelName, tables, filters) {
+	const firstRow = (await queryPlanRows(scope, compileSelect(contract, modelName, {
+		...emptyState(tables),
 		filters,
 		limit: 1
 	})).toArray())[0];
 	if (!firstRow) return null;
 	return mapStorageRowToModelFields(contract, namespaceId, modelName, firstRow);
 }
-async function executeUpdateCount(scope, contract, namespaceId, tableName, setValues, filters) {
-	const compiled = compileUpdateCount(contract, namespaceId, tableName, setValues, filters);
+async function executeUpdateCount(scope, contract, tables, setValues, filters) {
+	const compiled = compileUpdateCount(contract, tables, setValues, filters);
 	await scope.execute(compiled);
 }
 const relationDefsCache = /* @__PURE__ */ new WeakMap();
@@ -4544,9 +4562,9 @@ function toFieldName(contract, namespaceId, modelName, columnName) {
 function normalizeWhereArg(arg, options) {
 	if (arg === void 0) return;
 	if (arg === null) throw ormError("ORM.ARGUMENT_INVALID", "WhereArg cannot be null. Pass undefined or a valid WhereExpr/ToWhereExpr payload.", { meta: { argument: "where" } });
-	if (isToWhereExpr(arg)) return arg.toWhereExpr();
-	if (options?.contract) return bindWhereExpr(options.contract, arg, options.namespaceId);
-	return arg;
+	const expr = isToWhereExpr(arg) ? arg.toWhereExpr() : arg;
+	if (!options) return expr;
+	return bindWhereExpr(options.contract, expr, options.tables);
 }
 function isToWhereExpr(arg) {
 	return typeof arg === "object" && arg !== null && "toWhereExpr" in arg && !isWhereExpr(arg);
@@ -4707,7 +4725,7 @@ var CollectionBase = class CollectionBase {
 		this.modelName = modelName;
 		this.namespaceId = options.namespaceId;
 		this.tableName = options.tableName ?? resolveModelTableName(this.contract, options.namespaceId, modelName);
-		this.state = options.state ?? emptyState();
+		this.state = options.state ?? emptyState(createCollectionTables(this.contract, options.namespaceId, modelName, this.tableName));
 		this.registry = options.registry ?? /* @__PURE__ */ new Map();
 		this.includeRefinementMode = options.includeRefinementMode ?? false;
 		this.#installAggregateReducers();
@@ -4755,15 +4773,19 @@ var CollectionBase = class CollectionBase {
 		return createIncludeScalar(operation, this.state, column);
 	}
 	where(input) {
-		const filter = normalizeWhereArg(typeof input === "function" ? whereArgOf(input(createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, this.state.variantName), this.#callbackTools())) : isWhereDirectInput(input) ? input : shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, 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), {
 			contract: this.contract,
-			namespaceId: this.namespaceId
+			tables: tableAliases(tables)
 		});
 		if (!filter) return blindCast(this);
-		return this.#cloneSelf({ filters: [...this.state.filters, filter] });
+		return this.#cloneSelf({
+			tables,
+			filters: [...this.state.filters, filter]
+		});
 	}
-	#callbackTools() {
-		return createModelCallbackTools(this.ctx.context, this.namespaceId, this.modelName);
+	#callbackTools(tables) {
+		return createModelCallbackTools(this.ctx.context, this.modelName, tables);
 	}
 	with(fn) {
 		return fn(this);
@@ -4815,7 +4837,7 @@ var CollectionBase = class CollectionBase {
 			} });
 		}
 		const columnName = polyInfo.discriminatorColumn;
-		const filter = BinaryExpr.eq(ColumnRef.of(this.tableName, columnName), LiteralExpr.of(variantInfo.value));
+		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
@@ -4823,14 +4845,16 @@ var CollectionBase = class CollectionBase {
 	}
 	include(relationName, refineFn) {
 		const relation = resolveIncludeRelation(this.contract, this.namespaceId, this.modelName, relationName, this.state.variantName);
-		let nestedState = emptyState();
+		const child = createIncludeTables(this.contract, this.state.tables, relation);
+		let nestedState = emptyState(child.tables);
+		let adoptedScope = child.tables.scope;
 		let scalarSelector;
 		let combineBranches;
 		if (refineFn) {
 			const refined = refineFn(this.#createCollection(blindCast(relation.relatedModelName), {
 				tableName: relation.relatedTableName,
 				namespaceId: relation.relatedNamespaceId,
-				state: emptyState(),
+				state: nestedState,
 				includeRefinementMode: true
 			}));
 			if (isIncludeScalar(refined)) {
@@ -4838,6 +4862,7 @@ var CollectionBase = class CollectionBase {
 					relation: relationName,
 					kind: "scalar"
 				} });
+				adoptedScope = refined.state.tables.scope;
 				scalarSelector = refined;
 				nestedState = refined.state;
 			} else if (isIncludeCombine(refined)) {
@@ -4846,35 +4871,48 @@ var CollectionBase = class CollectionBase {
 					kind: "combine"
 				} });
 				combineBranches = refined.branches;
-			} else if (isCollectionStateCarrier(refined)) nestedState = refined.state;
-			else throw ormError("ORM.INCLUDE_INVALID", `include('${relationName}') refinement must return a collection, include scalar selector, or combine() descriptor`, { meta: { relation: relationName } });
+			} else if (isCollectionStateCarrier(refined)) {
+				adoptedScope = refined.state.tables.scope;
+				nestedState = refined.state;
+			} else throw ormError("ORM.INCLUDE_INVALID", `include('${relationName}') refinement must return a collection, include scalar selector, or combine() descriptor`, { meta: { relation: relationName } });
 		}
 		const includeExpr = {
 			relationName,
 			relatedModelName: relation.relatedModelName,
 			relatedNamespaceId: relation.relatedNamespaceId,
 			relatedTableName: relation.relatedTableName,
-			localTableName: relation.localTableName,
+			...ifDefined("localVariantName", relation.localVariantName),
 			targetColumns: relation.targetColumns,
 			localColumns: relation.localColumns,
 			cardinality: relation.cardinality,
 			...ifDefined("through", relation.through),
+			...ifDefined("junction", child.junction),
 			nested: nestedState,
 			scalar: scalarSelector,
 			combine: combineBranches
 		};
-		return this.#cloneWithRow({ includes: [...this.state.includes, includeExpr] });
+		return this.#cloneWithRow({
+			tables: {
+				...this.state.tables,
+				scope: adoptedScope
+			},
+			includes: [...this.state.includes, includeExpr]
+		});
 	}
 	select(...fields) {
 		const selectedFields = mapSelectedFieldsToColumns(this.contract, this.namespaceId, this.modelName, this.state.variantName, fields);
 		return this.#cloneWithRow({ selectedFields });
 	}
 	orderBy(selection) {
-		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, this.state.variantName);
-		const tools = this.#callbackTools();
+		const tables = withScopeCopy(this.state.tables);
+		const accessor = createModelAccessor(this.ctx.context, this.namespaceId, this.modelName, tables, this.state.variantName);
+		const tools = this.#callbackTools(tables);
 		const nextOrders = (Array.isArray(selection) ? selection : [selection]).map((selector) => selector(accessor, tools));
 		const existing = this.state.orderBy ?? [];
-		return this.#cloneSelf({ orderBy: [...existing, ...nextOrders] });
+		return this.#cloneSelf({
+			tables,
+			orderBy: [...existing, ...nextOrders]
+		});
 	}
 	/**
 	* Switch to grouped-aggregate mode. Returns a `GroupedCollection`
@@ -5006,7 +5044,6 @@ var CollectionBase = class CollectionBase {
 		return {
 			context: this.ctx.context,
 			state: this.state,
-			tableName: this.tableName,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId
 		};
@@ -5059,7 +5096,7 @@ var CollectionBase = class CollectionBase {
 			alias
 		} });
 		const annotationsMap = this.#collectAnnotationsFromMeta(configure, "read", "aggregate");
-		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.namespaceId, this.tableName, this.state, aggregateSpec, this.modelName), annotationsMap);
+		const compiled = mergeAnnotations(compileAggregate(this.contract, this.ctx.context.aggregateDescriptors, this.state, aggregateSpec, this.modelName), annotationsMap);
 		const results = entries.map(([alias, selector]) => {
 			const resolved = resolveAggregate({
 				aggregates: this.ctx.context.aggregateDescriptors,
@@ -5136,7 +5173,7 @@ var CollectionBase = class CollectionBase {
 				context: this.ctx.context,
 				runtime: this.ctx.runtime,
 				plans,
-				tableName: this.tableName,
+				tables: this.state.tables,
 				modelName: this.modelName,
 				namespaceId: this.namespaceId,
 				variantName: this.state.variantName,
@@ -5151,7 +5188,7 @@ var CollectionBase = class CollectionBase {
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			compiled,
-			tableName: this.tableName,
+			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
 			variantName: this.state.variantName,
@@ -5215,6 +5252,8 @@ var CollectionBase = class CollectionBase {
 		const tableName = this.tableName;
 		const modelName = this.modelName;
 		const namespaceId = this.namespaceId;
+		const tables = this.state.tables;
+		const variantTable = requireVariantTable(tables, variant.modelName);
 		const baseFieldColumns = new Set(Object.values(baseFieldToColumn));
 		const variantFieldColumns = new Set(Object.values(variantFieldToColumn));
 		const generator = async function* () {
@@ -5242,8 +5281,8 @@ var CollectionBase = class CollectionBase {
 						phase: "mti-base"
 					} });
 					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.modelName, variant.table, [variantRow], void 0)).toArray())[0];
+					applyCreateDefaults(collectionCtx, variantTable.storage.namespaceId, variantTable.storage.tableName, [variantRow], defaultValueCache);
+					const variantCreated = (await queryPlanRows(scope, compileInsertReturning(contract, variantTable.storage.namespaceId, variant.modelName, variantTable.storage.tableName, [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,
@@ -5253,9 +5292,9 @@ var CollectionBase = class CollectionBase {
 					const prefixedVariant = {};
 					for (const [col, val] of Object.entries(variantCreated)) {
 						if (pkColumns.includes(col)) continue;
-						prefixedVariant[`${variant.table}__${col}`] = val;
+						prefixedVariant[variantColumnLabel(variantTable, col)] = val;
 					}
-					return mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, {
+					return mapPolymorphicRow(contract, namespaceId, modelName, polyInfo, tables, {
 						...baseCreated,
 						...prefixedVariant
 					}, variant.modelName);
@@ -5350,7 +5389,7 @@ var CollectionBase = class CollectionBase {
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			compiled,
-			tableName: this.tableName,
+			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
 			variantName: this.state.variantName,
@@ -5383,6 +5422,7 @@ var CollectionBase = class CollectionBase {
 				runtime: this.ctx.runtime,
 				namespaceId: this.namespaceId,
 				modelName: this.modelName,
+				tables: this.state.tables,
 				filters: this.state.filters,
 				data: blindCast(data)
 			});
@@ -5412,12 +5452,12 @@ 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.modelName, this.tableName, mappedData, this.state.filters, selectedForUpdate), annotationsMap);
+		const compiled = mergeAnnotations(compileUpdateReturning(this.contract, this.modelName, this.state.tables, mappedData, this.state.filters, selectedForUpdate), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			compiled,
-			tableName: this.tableName,
+			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
 			variantName: this.state.variantName,
@@ -5434,7 +5474,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.namespaceId, this.tableName, mappedData, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
+		const compiled = mergeAnnotations(compileUpdateCount(this.contract, this.state.tables, mappedData, this.state.filters, this.state.variantName), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	async delete(configure) {
@@ -5464,12 +5504,12 @@ 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.modelName, this.tableName, this.state.filters, selectedForDelete), annotationsMap);
+		const compiled = mergeAnnotations(compileDeleteReturning(this.contract, this.modelName, this.state.tables, this.state.filters, selectedForDelete), annotationsMap);
 		return dispatchMutationRows({
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			compiled,
-			tableName: this.tableName,
+			tables: this.state.tables,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId,
 			variantName: this.state.variantName,
@@ -5500,11 +5540,10 @@ var CollectionBase = class CollectionBase {
 					context: collection.ctx.context,
 					runtime: scope,
 					state: collection.state,
-					tableName: collection.tableName,
 					modelName: collection.modelName,
 					namespaceId: collection.namespaceId
 				}).toArray();
-				const deletePlan = mergeAnnotations(compileDeleteCount(collection.contract, collection.namespaceId, collection.tableName, collection.state.filters, collection.state.variantName, collection.modelName), annotationsMap);
+				const deletePlan = mergeAnnotations(compileDeleteCount(collection.contract, collection.state.tables, collection.state.filters, collection.state.variantName), annotationsMap);
 				await scope.execute(deletePlan);
 				return rows;
 			});
@@ -5516,7 +5555,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.namespaceId, this.tableName, this.state.filters, this.state.variantName, this.modelName), annotationsMap);
+		const compiled = mergeAnnotations(compileDeleteCount(this.contract, this.state.tables, this.state.filters, this.state.variantName), annotationsMap);
 		return (await this.ctx.runtime.execute(compiled)).affectedRows;
 	}
 	#buildUpsertConflictCriterion(createValues, conflictColumns) {
@@ -5579,16 +5618,16 @@ var CollectionBase = class CollectionBase {
 			if (value === void 0) throw new InternalError(`Missing identity field "${fieldName}" while resolving single-row scope for model "${this.modelName}"`);
 			criterion[fieldName] = value;
 		}
-		return shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion)) ?? null;
+		return shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion), this.state.tables.root) ?? null;
 	}
 	async #reloadMutationRowByIdentity(criterion) {
 		return this.#reloadMutationRowByCriterion(criterion, "row identity");
 	}
 	async #reloadMutationRowByCriterion(criterion, criterionLabel) {
-		const whereExpr = shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion));
+		const whereExpr = shorthandToWhereExpr(this.ctx.context, this.namespaceId, this.modelName, blindCast(criterion), this.state.tables.root);
 		if (!whereExpr) throw new InternalError(`Failed to build ${criterionLabel} filter for mutation result on model "${this.modelName}"`);
 		const resultState = {
-			...emptyState(),
+			...emptyState(this.state.tables),
 			filters: [whereExpr],
 			includes: this.state.includes,
 			selectedFields: this.state.selectedFields,
@@ -5598,7 +5637,6 @@ var CollectionBase = class CollectionBase {
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			state: resultState,
-			tableName: this.tableName,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId
 		}))[0] ?? null;
@@ -5614,7 +5652,7 @@ var CollectionBase = class CollectionBase {
 		const waitPolicy = lockWaitPolicyOf(strength, options);
 		if (waitPolicy !== void 0) assertLockCapability(this.contract, lockOptionCapabilities[waitPolicy], strength);
 		const clause = LockingClause.of(strength, {
-			of: [this.tableName],
+			of: [this.state.tables.root.alias],
 			...ifDefined("waitPolicy", waitPolicy)
 		});
 		return this.#cloneSelf({ locking: [...this.state.locking ?? [], clause] });
@@ -5672,7 +5710,6 @@ var CollectionBase = class CollectionBase {
 			context: this.ctx.context,
 			runtime: this.ctx.runtime,
 			state: this.state,
-			tableName: this.tableName,
 			modelName: this.modelName,
 			namespaceId: this.namespaceId
 		});
@@ -5839,6 +5876,6 @@ function createPreparedRowQuery(description, statement) {
 	} });
 }
 //#endregion
-export { Collection, GroupedCollection, all, and, createModelAccessor, createPreparedRowQuery, emptyState, not, or, orderByField, orm, prepareQuery };
+export { Collection, GroupedCollection, all, and, createCollectionTables, createModelAccessor, createPreparedRowQuery, emptyState, not, or, orderByField, orm, prepareQuery };
 
 //# sourceMappingURL=orm-client.mjs.map