kern-orm 0.5.0 → 0.7.0

package/dist/{database-BJ0hNYrF.mjs → database-B7Kf5Q9X.mjs}

@@ -1,4 +1,5 @@
-import { B as trueNode, C as toNode, D as isType, E as defineType, F as createNode, I as createSelectNode, L as falseNode, M as valuesQueryNode, O as Column, P as createList, R as noFilters, S as toFunctionOperandNode, T as getBooleanType, _ as isOperandSource, a as stringifyJson, b as toCastValueNode, d as orderingOperators, g as isExpression, h as getType, j as isEqualityCompatible, m as createIsNullNode, n as text, p as compareNodes, s as encodeBytea, v as operandNode, w as toValueNode, x as toExpression, y as toBooleanExpression, z as oneNode } from "./text-BTFErHIi.mjs";
+import { B as noOrder, C as toNode, D as isType, E as defineType, F as createNode, H as oneNode, I as createSelectNode, L as falseNode, M as valuesQueryNode, O as Column, P as createList, R as noFilters, S as toFunctionOperandNode, T as getBooleanType, U as trueNode, V as noProjections, _ as isOperandSource, a as stringifyJson, b as toCastValueNode, d as orderingOperators, g as isExpression, h as getType, j as isEqualityCompatible, m as createIsNullNode, n as text, p as compareNodes, s as encodeBytea, v as operandNode, w as toValueNode, x as toExpression, y as toBooleanExpression, z as noJoins } from "./text-CIUxPWPl.mjs";
+import { types } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 // src/ast/boolean.ts
 /** Combines predicate nodes with `AND` or `OR`, flattening nested groups of the same kind. */
@@ -173,6 +174,12 @@ const aggregateDefinitions = /* @__PURE__ */ Object.freeze({
 		type: toArgumentType
 	}
 });
+/** Argument `*` of `count(*)`. */
+const allRowsNode = /* @__PURE__ */ createNode({
+	kind: "raw",
+	fragments: ["*"],
+	values: []
+});
 /** Projection of `count(*)`, which `count` without an argument selects; its value does not depend on the values or the order of the rows. */
 const countProjection = /* @__PURE__ */ Object.freeze({
 	key: "count",
@@ -180,12 +187,9 @@ const countProjection = /* @__PURE__ */ Object.freeze({
 		kind: "aggregate",
 		name: "count",
 		distinct: false,
-		arguments: [/* @__PURE__ */ createNode({
-			kind: "raw",
-			fragments: ["*"],
-			values: []
-		})],
-		orderBy: []
+		arguments: [allRowsNode],
+		orderBy: noOrder,
+		filter: void 0
 	}),
 	type: countType,
 	ordered: false,
@@ -197,27 +201,51 @@ const countProjection = /* @__PURE__ */ Object.freeze({
 * `delimiter` is the delimiter of `stringAgg`, sent as a parameter.
 */
 function projectAggregate(method, argument, delimiter) {
+	return Object.freeze({
+		key: method,
+		expression: createAggregateCall(method, argument.expression, delimiter),
+		type: toAggregateType(method, argument.type),
+		ordered: aggregateDefinitions[method].ordered,
+		fallbacks: noFallbacks
+	});
+}
+/**
+* Creates the call of the aggregate function of `method` over the values of `argument`.
+*
+* `delimiter` is the delimiter of `stringAgg`, sent as a parameter, `orderBy` the order of the rows that the function takes, and `filter` their condition.
+*/
+function createAggregateCall(method, argument, delimiter, orderBy = noOrder, filter) {
 	const definition = aggregateDefinitions[method];
-	const args = [argument.expression];
+	const args = [argument];
 	if (delimiter !== void 0) args.push(createNode({
 		kind: "param",
 		value: delimiter,
 		type: void 0
 	}));
-	return Object.freeze({
-		key: method,
-		expression: createNode({
-			kind: "aggregate",
-			name: definition.name,
-			distinct: definition.distinct,
-			arguments: args,
-			orderBy: []
-		}),
-		type: definition.type(argument.type),
-		ordered: definition.ordered,
-		fallbacks: noFallbacks
+	return createNode({
+		kind: "aggregate",
+		name: definition.name,
+		distinct: definition.distinct,
+		arguments: args,
+		orderBy,
+		filter
+	});
+}
+/** Creates the call of `count(*)` over the rows that `filter` takes. */
+function createCountCall(filter) {
+	return createNode({
+		kind: "aggregate",
+		name: "count",
+		distinct: false,
+		arguments: [allRowsNode],
+		orderBy: noOrder,
+		filter
 	});
 }
+/** Returns the type that decodes the value of the aggregate of `method` over the values of type `argument`, rejecting what `method` cannot decode, such as `avg` of a type of the SQL type `bigint`. */
+function toAggregateType(method, argument) {
+	return aggregateDefinitions[method].type(argument);
+}
 /** Creates the projection of the aggregate of `field` whose `NULL` `fallback` replaces after its earlier fallbacks. */
 function addFallback(field, fallback) {
 	const fallbacks = field.fallbacks.slice();
@@ -234,9 +262,9 @@ function addFallback(field, fallback) {
 function isAggregateQuery(node) {
 	return node.value && isAggregateProjection(node.projections[0]);
 }
-/** Tells whether `node`, a nested query, is selected as its value rather than as packed rows: an aggregate query as a scalar subquery of its statement, and a query of `exists` as `EXISTS` of its rows. */
+/** Tells whether `node`, a nested query, is selected as its value rather than as packed rows: an aggregate query as a scalar subquery of its statement, and a query of `exists` as `EXISTS` of its rows, unless `map` or `transform` converts its value. */
 function isSelectedAsValue(node) {
-	return isAggregateQuery(node) || isExistsQuery(node);
+	return node.conversion === void 0 && (isAggregateQuery(node) || isExistsQuery(node));
 }
 /** Tells whether a selected field is the projection of an aggregate, which only the aggregate methods select. */
 function isAggregateProjection(field) {
@@ -289,6 +317,21 @@ function createSelectionRefs(source, context) {
 	}), columns[key].type);
 	return Object.defineProperties(refs, context.relations);
 }
+// src/ast/projections.ts
+/**
+* Returns the position of the projection that has the value of `expression`, such as a sort expression or a key of a group: a projection of the same value, as `isSameValue` tells, or `-1`.
+*/
+function findValueProjection(projections, expression) {
+	return projections.findIndex((projection) => isSameValue(projection.expression, expression));
+}
+/**
+* Tells whether `left` and `right` are sure to have the same value: they are the same column of the same source or the same expression node.
+*
+* Only the same node or column guarantees one value: PostgreSQL may or may not evaluate equal expressions built apart once, and gives each its own parameters.
+*/
+function isSameValue(left, right) {
+	return left.kind === "column" && right.kind === "column" ? left.source === right.source && left.key === right.key : left === right;
+}
 // src/result/result.ts
 /** Error thrown when a query of one row finds no row, executed or nested, unless a required relation guarantees the row. */
 var NotFoundError = class extends Error {
@@ -315,7 +358,7 @@ var RequiredRelationError = class extends Error {
 		this.path = path;
 	}
 };
-/** Error thrown when a row does not match the result fields or a value fails to decode; the failure of the value is its cause. */
+/** Error thrown when a row does not match the result fields, a value fails to decode, or a callback of `transform` or `map` fails; the failure is its cause. */
 var ResultDecodeError = class extends Error {
 	path;
 	name = "ResultDecodeError";
@@ -334,9 +377,13 @@ function isRecordKey(key) {
 * A statement of one row that returns its number or a record without fields rejects as a query of one row does: with `NotFoundError` without a row, unless it is optional or nullable, and with several rows.
 */
 function decodeStatement(plan, result) {
-	const { counted } = plan;
+	const { counted, conversion } = plan;
 	if (counted === void 0) return decodeResult(plan, plan.named ? selectColumns(plan, result) : result.rows);
-	const { count } = result;
+	const decoded = decodeCount(plan, counted, result.count);
+	return conversion === void 0 ? decoded : convertTopResult(plan, conversion, decoded, counted === "records" && plan.rows !== "many" && result.count === 0);
+}
+/** Returns what a statement resolves to by `count`, the number of the rows of its command tag, as `counted` tells: the number, or as many records without fields. */
+function decodeCount(plan, counted, count) {
 	if (plan.rows !== "many") {
 		if (count > 1) throw new Error(plan.named ? `Query of one row reported ${count} rows` : `Query of one row changed ${count} rows`);
 		if (count === 0) {
@@ -382,11 +429,47 @@ function selectColumns(plan, result) {
 	return selected;
 }
 /**
-* Decodes driver rows into the result of a query by its result plan.
+* Decodes driver rows into the result of a query by its result plan, and converts the result as its conversion tells.
 *
 * It rejects a row whose values do not match the result fields, and names the path of the value that fails to decode from its result field, such as `fields[2].label`, after the index of the row of rows `many`, such as `[2].fields[2].label`.
 */
 function decodeResult(plan, rows) {
+	const result = decodeRows(plan, rows);
+	const { conversion } = plan;
+	return conversion === void 0 ? result : convertTopResult(plan, conversion, result, rows.length === 0);
+}
+/** Converts `result`, which `plan` decoded for a statement rather than for nested rows, as `convertResult` does, rejecting with the error of the statement. */
+function convertTopResult(plan, conversion, result, missing) {
+	try {
+		return convertResult(plan, conversion, result, missing);
+	} catch (error) {
+		throw error instanceof NestedFailure ? createRowError("", error) : new ResultDecodeError(`Cannot convert the result${describeCause(error)}`, void 0, { cause: error });
+	}
+}
+/**
+* Converts `result`, which `plan` decoded, by `conversion`.
+*
+* It tells a missing row by `missing` rather than by the value, since a row may decode to `null` or `undefined`.
+* A failure of `map` of rows `many` is a `NestedFailure` of the index of its row; any other failure is the error of the callback, which the enclosing field adds its path to.
+*/
+function convertResult(plan, conversion, result, missing) {
+	const { map, transform } = conversion;
+	let converted = result;
+	if (map !== void 0) {
+		if (plan.rows === "many") {
+			const rows = result;
+			let index = 0;
+			try {
+				for (; index < rows.length; index++) rows[index] = map(rows[index]);
+			} catch (error) {
+				throw new NestedFailure(`[${index}]`, error);
+			}
+		} else if (!missing) converted = map(result);
+	}
+	return transform === void 0 ? converted : transform(converted);
+}
+/** Decodes driver rows into the result of a query before its conversion: an array of rows `many`, one row, or the result of a missing row. */
+function decodeRows(plan, rows) {
 	if (plan.rows === "many") {
 		const results = [];
 		let index = 0;
@@ -450,7 +533,11 @@ function createRowError(prefix, error) {
 	const path = prefix + error.path;
 	const { cause } = error;
 	if (cause instanceof MissingRow) return cause.guaranteedBy === void 0 ? new NotFoundError(`Nested query of result field "${path}" returned no rows`, path) : new RequiredRelationError(cause.guaranteedBy, path);
-	return new ResultDecodeError(`Cannot decode result field "${path}"${cause instanceof Error ? `: ${cause.message}` : ""}`, path, { cause });
+	return new ResultDecodeError(`Cannot decode result field "${path}"${describeCause(cause)}`, path, { cause });
+}
+/** Describes the failure `cause` at the end of the message of an error. */
+function describeCause(cause) {
+	return cause instanceof Error ? `: ${cause.message}` : "";
 }
 /**
 * Decodes a row into a record keyed by the result fields, or into the value of its only field.
@@ -500,8 +587,14 @@ function decodePackedValue(field, value) {
 	if (typeof value !== "string") throw new TypeError(`Nested value must be text, not ${describeJson(value)}`);
 	return field.type.decode(value);
 }
-/** Decodes the rows of a nested query from JSON: an array of packed rows for rows `many`, and a packed row or `null` otherwise. */
+/** Decodes the rows of a nested query from JSON, as `decodeNestedRows` does, and converts them as the conversion of `plan` tells. */
 function decodeNested(plan, json) {
+	const result = decodeNestedRows(plan, json);
+	const { conversion } = plan;
+	return conversion === void 0 ? result : convertResult(plan, conversion, result, json === null);
+}
+/** Decodes the rows of a nested query from JSON: an array of packed rows for rows `many`, and a packed row or `null` otherwise. */
+function decodeNestedRows(plan, json) {
 	if (plan.rows === "many") {
 		if (!Array.isArray(json)) throw new TypeError(`Nested rows must be an array, not ${describeJson(json)}`);
 		const results = [];
@@ -532,6 +625,20 @@ function describeJson(value) {
 }
 // src/table/table.ts
 function defineTable(name, definitions, options) {
+	return createTable(name, definitions, options, void 0);
+}
+/**
+* Creates a table-definition function with the given naming convention, for an application to define its tables with.
+*
+* Its tables have the same types as those of `defineTable`.
+*/
+function createTableFactory(factoryOptions) {
+	const deriveColumnName = factoryOptions.columnName;
+	if (typeof deriveColumnName !== "function") throw new TypeError("The columnName option of createTableFactory must be a function");
+	return ((name, definitions, options) => createTable(name, definitions, options, deriveColumnName));
+}
+/** Creates the table that `defineTable` defines, naming its columns by `deriveColumnName` if given. */
+function createTable(name, definitions, options, deriveColumnName) {
 	const columns = {};
 	for (const [key, definition] of Object.entries(definitions)) {
 		if (key.startsWith("$")) throw new Error(`Column key "${key}" of table "${name}" must not start with "$"`);
@@ -540,14 +647,42 @@ function defineTable(name, definitions, options) {
 		if (!column) throw new TypeError(`Column "${key}" of table "${name}" must be a type or a column`);
 		columns[key] = column;
 	}
+	if (deriveColumnName) nameColumns(name, columns, deriveColumnName);
+	const singleton = options?.singleton;
+	if (singleton !== void 0 && typeof singleton !== "boolean") throw new TypeError(`The singleton option of table "${name}" must be a boolean`);
 	return Object.freeze({
 		kind: "table",
 		name,
 		columns: Object.freeze(columns),
-		keys: defineKeys(name, columns, options)
+		keys: defineKeys(name, columns, options),
+		singleton: singleton === true
 	});
 }
 /**
+* Replaces unnamed columns of table `name` with copies whose physical names are derived from their keys, so that a column shared with other tables stays as it is.
+*
+* It calls `deriveColumnName`, which an application gives, once for each such column.
+* It rejects a derived name that is not a non-empty string, which PostgreSQL rejects only when a query runs, and a derived name that another column has, since two keys would silently read one column.
+* Duplicate names set with `columnName` are allowed, as in `defineTable`.
+*/
+function nameColumns(name, columns, deriveColumnName) {
+	const keys = Object.keys(columns);
+	const derivedKeys = [];
+	for (const key of keys) {
+		const column = columns[key];
+		if (column.attributes.name === void 0) {
+			const columnName = deriveColumnName(key);
+			if (typeof columnName !== "string" || columnName === "") throw new TypeError(`The name derived for column "${key}" of table "${name}" must be a non-empty string`);
+			columns[key] = column.columnName(columnName);
+			derivedKeys.push(key);
+		}
+	}
+	for (const key of derivedKeys) {
+		const columnName = columns[key].attributes.name;
+		for (const other of keys) if (other !== key && columns[other].attributes.name === columnName) throw new Error(`Columns "${key}" and "${other}" of table "${name}" have one physical name "${columnName}"; set another name with columnName()`);
+	}
+}
+/**
 * Defines the keys of table `name` of `columns` from the keys marked on the columns and those of `options`.
 *
 * The unique keys are those of the columns in their order, followed by those of the options.
@@ -599,8 +734,14 @@ function findColumn(table, key) {
 }
 /** Tells whether the columns of `table` under `columns` are exactly a key of it, primary or unique, in any order, as `IsKey` does in types. */
 function isKey(table, columns) {
+	return findKey(table, columns) !== void 0;
+}
+/** Returns the key of `table`, primary or unique, whose columns are exactly those under `columns` in any order, as `isKey` tells, or `undefined`. */
+function findKey(table, columns) {
 	const listed = new Set(columns);
-	return someKey(table, (key) => key.length === listed.size && isKeyAmong(key, listed));
+	const isListed = (key) => key.length === listed.size && isKeyAmong(key, listed);
+	const { primaryKey, unique } = table.keys;
+	return primaryKey !== void 0 && isListed(primaryKey) ? primaryKey : unique.find(isListed);
 }
 /** Tells whether the columns of `table` under `columns` include a key of it, primary or unique, as `ContainsKey` does in types. */
 function containsKey(table, columns) {
@@ -631,108 +772,6 @@ function toColumn(definition) {
 		hasDefault: false
 	}) : void 0;
 }
-// src/query/resolve-values.ts
-/**
-* Replaces objects of column values in a predicate with conditions on the columns of `source`.
-*
-* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
-*/
-function resolveValues(node, source) {
-	switch (node.kind) {
-		case "values": {
-			const conditions = [];
-			for (const key of Object.keys(node.values)) conditions.push(matchColumn(source, key, node.values[key]));
-			return combineNodes("and", conditions);
-		}
-		case "and":
-		case "or": {
-			const operands = [];
-			for (const operand of node.operands) operands.push(resolveValues(operand, source));
-			return combineNodes(node.kind, operands);
-		}
-		case "not": return negateNode(resolveValues(node.operand, source));
-		case "raw": return createNode({
-			...node,
-			values: node.values.map((value) => resolveValues(value, source))
-		});
-		default: return node;
-	}
-}
-/** Creates the condition of column `key` of `source` in an object of column values: `IS NULL` of `null`, or the `eq` operator of its type for another value. */
-function matchColumn(source, key, value) {
-	const type = findColumn(source.table, key)?.type;
-	const column = createNode({
-		kind: "column",
-		source,
-		key
-	});
-	if (value === null) return createIsNullNode(column);
-	if (type) return matchValue(source, column, type, value);
-	return compareNodes("=", column, value, void 0);
-}
-/** Matches a column with a value of an object condition by calling the `eq` operator of its type, whichever operator it is. */
-function matchValue(source, column, type, value) {
-	const expression = toExpression(column, type);
-	if (typeof expression.eq !== "function") throw new TypeError(`Column "${column.key}" of table "${source.table.name}" has no eq operator; an object condition can only match it with null`);
-	const predicate = expression.eq(value);
-	if (!isExpression(predicate)) throw new TypeError(`The eq operator of column "${column.key}" of table "${source.table.name}" must return an expression`);
-	return toNode(predicate);
-}
-// src/query/filters.ts
-/** Creates query filters with the filter of `where` over `source` with the relations of `context` combined with `AND` with the user filters of `filters`. */
-function addUserFilter(filters, filter, source, context) {
-	const predicate = resolveValues(toConditionNode(typeof filter === "function" ? filter(createSelectionRefs(source, context)) : filter), source);
-	const { user } = filters;
-	return Object.freeze({
-		...filters,
-		user: user ? combineNodes("and", [user, predicate]) : predicate
-	});
-}
-// src/query/find.ts
-/**
-* Returns the object of column values that `find` filters a query of `table` by: `values` of the columns of its primary key, in their order.
-*
-* It rejects a table without a primary key, a number of values other than the number of its columns, and `null` and `undefined`.
-*/
-function toPrimaryKeyValues(table, values) {
-	const { primaryKey } = table.keys;
-	if (primaryKey === void 0) throw new Error(`find takes the values of a primary key, which table "${table.name}" does not have; use findBy with a unique key`);
-	if (values.length !== primaryKey.length) throw new Error(`find takes one value for each column of the primary key of table "${table.name}", ${quoteColumns(primaryKey)}, not ${values.length}`);
-	const filter = {};
-	for (let index = 0; index < primaryKey.length; index++) {
-		const column = primaryKey[index];
-		filter[column] = requireKeyValue(table, column, values[index], "find");
-	}
-	return filter;
-}
-/**
-* Returns the object of column values that `findBy` filters a query of `table` by: a copy of `values`, read once.
-*
-* It rejects columns that are not exactly a key of `table`, primary or unique, as `isKey` tells, and `null` and `undefined`.
-*/
-function toKeyValues(table, values) {
-	if (typeof values !== "object" || values === null) throw new TypeError(`findBy takes an object of the columns of a key of table "${table.name}"`);
-	const columns = Object.keys(values);
-	if (!isKey(table, columns)) {
-		const listed = columns.length === 0 ? "an object without columns" : `columns ${quoteColumns(columns)}`;
-		throw new Error(`findBy takes the columns of one key of table "${table.name}", primary or unique, not ${listed}`);
-	}
-	const filter = {};
-	for (const column of columns) {
-		const value = values[column];
-		filter[column] = requireKeyValue(table, column, value, "findBy");
-	}
-	return filter;
-}
-/** Returns `value` of column `column` of a key of `table` that `method` takes, rejecting `null` and `undefined`. */
-function requireKeyValue(table, column, value, method) {
-	if (value === null || value === void 0) throw new TypeError(`${method} got ${value} for column "${column}" of table "${table.name}"; a value of a key is never null or undefined`);
-	return value;
-}
-/** Lists `columns` in quotes, separated by commas. */
-function quoteColumns(columns) {
-	return columns.map((column) => `"${column}"`).join(", ");
-}
 // src/type/untyped.ts
 /** Encodes a parameter without a type, such as a value interpolated into `sql`, by its JavaScript type. */
 function encodeUntyped(value) {
@@ -785,7 +824,12 @@ var CompileContext = class {
 	tables;
 	db;
 	parameters = [];
+	/** Whether a select statement of the compilation locks rows. */
+	locksRows = false;
+	/** Whether the clauses being compiled belong to a query of groups, which binds the parameter of a cast once by `bindOnce`. */
+	grouped = false;
 	#aliases = /* @__PURE__ */ new Set();
+	#placeholders;
 	constructor(schemaName, tables = void 0, db = void 0) {
 		this.schemaName = schemaName;
 		this.tables = tables;
@@ -809,6 +853,16 @@ var CompileContext = class {
 		this.parameters.push(value);
 		return `$${this.parameters.length}`;
 	}
+	/** Binds `value` as the parameter of `cast` unless `bindOnce` has bound the cast before, and returns its placeholder. */
+	bindOnce(cast, value) {
+		this.#placeholders ??= /* @__PURE__ */ new Map();
+		let placeholder = this.#placeholders.get(cast);
+		if (placeholder === void 0) {
+			placeholder = this.bind(value);
+			this.#placeholders.set(cast, placeholder);
+		}
+		return placeholder;
+	}
 };
 // src/compiler/postgres/parentheses.ts
 /** Tells whether an operand of `kind` needs parentheses at `position`, so that the SQL keeps the structure of the tree. */
@@ -885,10 +939,12 @@ function compileStatement(node, options = {}, tables, db) {
 			parameters: context.parameters,
 			fields: node.projections,
 			recordTemplate: node.recordTemplate,
+			conversion: node.conversion,
 			rows: node.rows,
 			value: node.value,
 			counted: void 0,
-			named: false
+			named: false,
+			locksRows: context.locksRows
 		};
 		case "text": {
 			const { fields } = node;
@@ -899,7 +955,8 @@ function compileStatement(node, options = {}, tables, db) {
 				rows: node.rows,
 				value: node.value,
 				counted: fields === void 0 ? "number" : void 0,
-				named: true
+				named: true,
+				locksRows: false
 			};
 		}
 		default: {
@@ -909,33 +966,30 @@ function compileStatement(node, options = {}, tables, db) {
 				parameters: context.parameters,
 				fields: returning ?? noFields,
 				recordTemplate: node.recordTemplate,
+				conversion: node.conversion,
 				rows: node.rows,
 				value: node.value,
 				counted: returning === void 0 ? "number" : returning.length === 0 ? "records" : void 0,
-				named: false
+				named: false,
+				locksRows: false
 			};
 		}
 	}
 }
-/** Compiles a mutation, whose expressions see only the occurrence of its table, apart from the values of an insert, which see no source. */
+/** Compiles a mutation, whose expressions see the occurrence of its table, apart from the values of an insert, which see no source, and the values of `DO UPDATE SET`, which also see the row proposed for insertion as `excluded`. */
 function compileMutation(context, node) {
+	if (node.kind === "insert" && node.conflict?.update !== void 0) context.createAlias(excludedAlias);
 	const scope = declareSource(context, void 0, node.target);
 	const target = compileSource(context, void 0, scope);
 	let text;
 	switch (node.kind) {
 		case "insert":
-			text = `INSERT INTO ${target}${compileValues(context, node)}`;
+			text = `INSERT INTO ${target}${compileValues(context, node)}${compileConflict(context, scope, node)}`;
 			break;
-		case "update": {
-			text = `UPDATE ${target} SET`;
-			const { set } = node;
-			for (let index = 0; index < set.length; index++) {
-				const { key, value } = set[index];
-				text += `${index === 0 ? " " : ", "}${compileColumnName(node.target, key)} = ${compileExpression(context, scope, value)}`;
-			}
+		case "update":
+			text = `UPDATE ${target} SET${compileAssignments(context, scope, node.target, node.set)}`;
 			text += compileWhere(context, scope, node.filters);
 			break;
-		}
 		case "delete":
 			text = `DELETE FROM ${target}${compileWhere(context, scope, node.filters)}`;
 			break;
@@ -966,7 +1020,41 @@ function compileValues(context, node) {
 	}
 	return text;
 }
-/** Compiles the physical name of the column of the table of `target` under `key`, as `SET` and the column list of an insert name it, without an alias. */
+/** Alias of the row proposed for insertion in `DO UPDATE` of `ON CONFLICT`, which PostgreSQL names `EXCLUDED`. */
+const excludedAlias = "excluded";
+/**
+* Compiles `ON CONFLICT` of an insert, which names the physical columns of its key, or the expression `(true)` of the unique index of a singleton table, or nothing for an insert without it.
+*
+* The values of `DO UPDATE SET` see the existing row in `scope`, the occurrence of the table of the insert, and the row proposed for insertion as `excluded`.
+*/
+function compileConflict(context, scope, node) {
+	const { conflict } = node;
+	if (conflict === void 0) return "";
+	const { target, update } = conflict;
+	let text = " ON CONFLICT";
+	if (target === "singleton") text += " ((true))";
+	else {
+		for (let index = 0; index < target.length; index++) text += `${index === 0 ? " (" : ", "}${compileColumnName(node.target, target[index])}`;
+		if (target.length > 0) text += ")";
+	}
+	if (update === void 0) return `${text} DO NOTHING`;
+	const excluded = {
+		source: update.excluded,
+		alias: excludedAlias,
+		outer: scope
+	};
+	return `${text} DO UPDATE SET${compileAssignments(context, excluded, node.target, update.set)}`;
+}
+/** Compiles the assignments of `SET` of an update or of `DO UPDATE` to the columns of the table of `target`, whose values see the sources of `scope`. */
+function compileAssignments(context, scope, target, set) {
+	let text = "";
+	for (let index = 0; index < set.length; index++) {
+		const { key, value } = set[index];
+		text += `${index === 0 ? " " : ", "}${compileColumnName(target, key)} = ${compileExpression(context, scope, value)}`;
+	}
+	return text;
+}
+/** Compiles the physical name of the column of the table of `target` under `key`, as `SET`, the column list of an insert, and the target of `ON CONFLICT` name it, without an alias. */
 function compileColumnName(target, key) {
 	return quoteIdentifier(requireColumn(target.table, key).attributes.name ?? key);
 }
@@ -981,7 +1069,14 @@ function compileQuery(context, outer, node) {
 		scope = declareSource(context, scope, join.source);
 		joinScopes.push(scope);
 	}
-	let text = `SELECT${compileProjections(context, scope, node.projections)}`;
+	const { groupBy, having } = node;
+	const { grouped } = context;
+	context.grouped = groupBy !== void 0;
+	let text = "SELECT";
+	if (node.distinct) text += " DISTINCT";
+	const { distinctOn } = node;
+	if (distinctOn !== void 0) text += ` DISTINCT ON (${compileKeys(context, scope, distinctOn, node.projections)})`;
+	text += compileProjections(context, scope, node.projections);
 	if (fromScope !== void 0) {
 		text += ` FROM ${compileSource(context, outer, fromScope)}`;
 		for (let index = 0; index < node.joins.length; index++) {
@@ -990,9 +1085,18 @@ function compileQuery(context, outer, node) {
 		}
 	}
 	text += compileWhere(context, scope, node.filters);
+	if (groupBy !== void 0) text += ` GROUP BY ${compileKeys(context, scope, groupBy, node.projections)}`;
+	if (having !== void 0) text += ` HAVING ${compileExpression(context, scope, having)}`;
 	if (node.orderBy.length > 0) text += ` ${compileOrderBy(context, scope, node.orderBy)}`;
 	if (node.limit) text += ` LIMIT ${compileExpression(context, outer, node.limit)}`;
 	if (node.offset) text += ` OFFSET ${compileExpression(context, outer, node.offset)}`;
+	const { lock } = node;
+	if (lock !== void 0) {
+		context.locksRows = true;
+		text += ` FOR ${lock.strength}`;
+		if (lock.onLocked !== void 0) text += ` ${lock.onLocked}`;
+	}
+	context.grouped = grouped;
 	return text;
 }
 /** Compiles the projections of a select list or of `RETURNING`, each after a space or a comma. */
@@ -1009,6 +1113,16 @@ function compileWhere(context, scope, filters) {
 	const where = combineFilters(filters);
 	return where.kind === "boolean" && where.value ? "" : ` WHERE ${compileExpression(context, scope, where)}`;
 }
+/** Compiles the keys of `GROUP BY` or `DISTINCT ON` of a query of `projections`, its final select list, also with those that lowering adds, such as of a sort key of packed rows: each key is the position of the projection that has its value, or its expression without one. */
+function compileKeys(context, scope, keys, projections) {
+	let text = "";
+	for (let index = 0; index < keys.length; index++) {
+		const key = keys[index];
+		const position = findValueProjection(projections, key);
+		text += `${index === 0 ? "" : ", "}${position === -1 ? compileExpression(context, scope, key) : String(position + 1)}`;
+	}
+	return text;
+}
 /** Compiles the `ORDER BY` clause of a query or an aggregate, which has at least one sort key. */
 function compileOrderBy(context, scope, orderBy) {
 	let text = "ORDER BY";
@@ -1055,7 +1169,10 @@ function compileExpression(context, scope, node) {
 	switch (node.kind) {
 		case "column": return compileColumn(scope, node);
 		case "param": return context.bind(encodeParameter(node));
-		case "cast": return `${compileOperand(context, scope, node.operand, "value")}::${node.type.castType}`;
+		case "cast": {
+			const { operand } = node;
+			return `${context.grouped && operand.kind === "param" ? context.bindOnce(node, encodeParameter(operand)) : compileOperand(context, scope, operand, "value")}::${node.type.castType}`;
+		}
 		case "boolean": return node.value ? "TRUE" : "FALSE";
 		case "and":
 		case "or": return node.operands.map((operand) => compileOperand(context, scope, operand, "condition")).join(node.kind === "and" ? " AND " : " OR ");
@@ -1087,7 +1204,9 @@ function compileExpression(context, scope, node) {
 			let text = `${node.name}(${node.distinct ? "DISTINCT " : ""}`;
 			for (let index = 0; index < node.arguments.length; index++) text += `${index === 0 ? "" : ", "}${compileExpression(context, scope, node.arguments[index])}`;
 			if (node.orderBy.length > 0) text += ` ${compileOrderBy(context, scope, node.orderBy)}`;
-			return `${text})`;
+			text += ")";
+			if (node.filter !== void 0) text += ` FILTER (WHERE ${compileExpression(context, scope, node.filter)})`;
+			return text;
 		}
 		default: return node;
 	}
@@ -1117,173 +1236,40 @@ function createStatement(text, parameters = []) {
 		parameters
 	};
 }
-// src/ast/references.ts
-/** Adds to `keys` the key of each column reference to `source` in `node` at any depth, including the queries nested in it. */
-function collectColumnKeys(node, source, keys) {
-	visitNodes(node, true, (child) => {
-		if (child.kind === "column" && child.source === source) keys.add(child.key);
-	});
+// src/schema/relation.ts
+/** Runtime mark of the declarations of `many` and `one`. */
+const declarationBrand = Symbol("kern-orm.relation");
+/** Returns the name of relation `name` of the table under key `key` in messages and errors, such as `field.form`. */
+function formatRelationName(key, name) {
+	return `${key}.${name}`;
 }
 /**
-* Tells whether `node` holds, at any depth, a SQL fragment that refers to a column of `source` outside the queries nested in the fragment.
+* Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
 *
-* PostgreSQL assigns an aggregate whose arguments refer only to the sources of an enclosing query to that query ([PostgreSQL](https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-AGGREGATES)).
-* Lowering does not parse SQL fragments to identify their aggregates, so such a fragment in a nested query, such as `sum` of a column of the parent row, may aggregate the rows of the query of `source`.
+* A composite key lists its columns in arrays of the same length.
 */
-function holdsFragmentOfSource(node, source) {
-	let found = false;
-	visitNodes(node, true, (child) => {
-		if (found || child.kind !== "raw") return;
-		visitNodes(child, false, (value) => {
-			if (value.kind === "column" && value.source === source) found = true;
-		});
-	});
-	return found;
-}
-/** Calls `visit` for `node` and each expression node in it, also in the queries nested in it when `deep` is set. */
-function visitNodes(node, deep, visit) {
-	visit(node);
-	switch (node.kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "tableName":
-		case "values":
-		case "nestedQuery": return;
-		case "cast":
-		case "not":
-		case "isNull":
-			visitNodes(node.operand, deep, visit);
-			return;
-		case "and":
-		case "or":
-			for (const operand of node.operands) visitNodes(operand, deep, visit);
-			return;
-		case "comparison":
-			visitNodes(node.left, deep, visit);
-			visitNodes(node.right, deep, visit);
-			return;
-		case "in":
-			visitNodes(node.operand, deep, visit);
-			for (const item of node.list) visitNodes(item, deep, visit);
-			return;
-		case "inQuery":
-			visitNodes(node.operand, deep, visit);
-			if (deep && node.query.kind === "select") visitQuery(node.query, visit);
-			return;
-		case "raw":
-			for (const value of node.values) visitNodes(value, deep, visit);
-			return;
-		case "subquery":
-		case "exists":
-		case "textSubquery":
-			if (deep) visitQuery(node.query, visit);
-			return;
-		case "aggregate":
-			for (const argument of node.arguments) visitNodes(argument, deep, visit);
-			for (const order of node.orderBy) visitNodes(order.expression, deep, visit);
-			return;
-	}
-}
-/** Calls `visit` for each expression node in the clauses and the derived sources of `query` at any depth. */
-function visitQuery(query, visit) {
-	const { from, filters } = query;
-	if (from?.kind === "derived") visitQuery(from.query, visit);
-	for (const join of query.joins) {
-		if (join.source.kind === "derived") visitQuery(join.source.query, visit);
-		visitNodes(join.on, true, visit);
-	}
-	for (const projection of query.projections) visitNodes(projection.expression, true, visit);
-	if (filters.relation !== void 0) visitNodes(filters.relation, true, visit);
-	if (filters.scope !== void 0) visitNodes(filters.scope, true, visit);
-	if (filters.user !== void 0) visitNodes(filters.user, true, visit);
-	for (const order of query.orderBy) visitNodes(order.expression, true, visit);
-	if (query.limit !== void 0) visitNodes(query.limit, true, visit);
-	if (query.offset !== void 0) visitNodes(query.offset, true, visit);
-}
-// src/query/rows.ts
-/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
-function getRelationRows(relation) {
-	if (relation.kind === "many") return "many";
-	return relation.required ? "one" : "nullable";
-}
-/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
-function toFilteredRows(rows, value, guaranteed) {
-	if (!guaranteed || rows !== "one") return rows;
-	return value ? "optional" : "nullable";
-}
-/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
-function limitToOne(limit) {
-	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
-}
-/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
-function toValueRows(rows) {
-	return rows === "nullable" ? "optional" : rows;
-}
-// src/query/node.ts
-/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
-function createQueryNode(from, relation, filters = noFilters) {
-	return Object.freeze({
-		kind: "query",
-		from,
-		relation,
-		projections: [],
-		filters,
-		orderBy: [],
-		limit: void 0,
-		offset: void 0,
-		rows: relation === void 0 ? "many" : getRelationRows(relation),
-		value: false,
-		guaranteed: relation?.required ?? false,
-		all: false
-	});
-}
-/** Tells whether `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, order, limit, offset, rows other than `many`, or `all`. */
-function isTableQuery(node) {
-	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && node.rows === "many" && !node.all;
-}
-/** Tells whether a selected field is the rows of a nested query. */
-function isNestedSelection(node) {
-	return "query" in node;
-}
-/** Tells whether a selected field is a literal. */
-function isLiteralSelection(node) {
-	return "literal" in node;
-}
-// src/schema/relation.ts
-/** Runtime mark of the declarations of `many` and `one`. */
-const declarationBrand = Symbol("kern-orm.relation");
-/** Returns the name of relation `name` of the table under key `key` in messages and errors, such as `field.form`. */
-function formatRelationName(key, name) {
-	return `${key}.${name}`;
-}
-/**
-* Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
-*
-* A composite key lists its columns in arrays of the same length.
-*/
-function many(target, keys) {
-	return declareRelation("many", target, keys, false);
-}
-/**
-* Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
-*
-* A composite key lists its columns in arrays of the same length.
-* The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
-* Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
-* Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
-*/
-function one(target, keys) {
-	return declareRelation("one", target, keys, keys.required === true);
-}
-function declareRelation(kind, target, keys, required) {
-	return Object.freeze({
-		[declarationBrand]: true,
-		kind,
-		target,
-		from: toKeyList(keys.from),
-		to: toKeyList(keys.to),
-		required
+function many(target, keys) {
+	return declareRelation("many", target, keys, false);
+}
+/**
+* Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+*
+* A composite key lists its columns in arrays of the same length.
+* The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
+* Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
+* Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
+*/
+function one(target, keys) {
+	return declareRelation("one", target, keys, keys.required === true);
+}
+function declareRelation(kind, target, keys, required) {
+	return Object.freeze({
+		[declarationBrand]: true,
+		kind,
+		target,
+		from: toKeyList(keys.from),
+		to: toKeyList(keys.to),
+		required
 	});
 }
 function toKeyList(key) {
@@ -1365,260 +1351,976 @@ function freezeRelations(relations) {
 function isRelationDeclaration(value) {
 	return typeof value === "object" && value !== null && declarationBrand in value;
 }
-// src/lowering/order.ts
-/**
-* Returns the position of the projection that has the value of the sort expression `expression`: a projection of the same column or of the same expression node, or `-1`.
-*
-* Only the same node or column guarantees one value: PostgreSQL may or may not evaluate equal expressions built apart once, and gives each its own parameters.
-*/
-function findSortProjection(projections, expression) {
-	return projections.findIndex((projection) => {
-		const selected = projection.expression;
-		return expression.kind === "column" && selected.kind === "column" ? selected.source === expression.source && selected.key === expression.key : selected === expression;
-	});
+// src/query/rows.ts
+/** Returns the rows mode of a query that starts from `table`, as `TableQueryState` gives it in types: `optional` of the one row of a singleton table, and `many` of the rows of another table. */
+function getTableRows(table) {
+	return table.singleton ? "optional" : "many";
 }
-/** Creates the number of the projection at `position`, by which `ORDER BY` sorts by its value instead of evaluating an expression again. */
-function createPositionNode(position) {
-	return createNode({
-		kind: "raw",
-		fragments: [String(position + 1)],
-		values: []
-	});
+/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
+function getRelationRows(relation) {
+	if (relation.kind === "many") return "many";
+	return relation.required ? "one" : "nullable";
 }
-/** Creates the order of a statement that sorts by the positions of the projections among `projections` that have the values of its sort expressions, and by the other expressions as they are. */
-function sortByPositions(orderBy, projections) {
-	const result = [];
-	for (const order of orderBy) {
-		const position = findSortProjection(projections, order.expression);
-		result.push(position === -1 ? order : Object.freeze({
-			expression: createPositionNode(position),
-			direction: order.direction,
-			nulls: order.nulls
-		}));
-	}
-	return result;
+/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
+function toFilteredRows(rows, value, guaranteed) {
+	if (!guaranteed || rows !== "one") return rows;
+	return value ? "optional" : "nullable";
 }
+/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
+function limitToOne(limit) {
+	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
+}
+/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
+function toValueRows(rows) {
+	return rows === "nullable" ? "optional" : rows;
+}
+// src/query/node.ts
+/** Empty values of the key without columns of a query that starts from a singleton table. */
+const singletonKey = /* @__PURE__ */ Object.freeze({});
 /**
-* Creates the derived source of the rows of `query`, and, when `ordered`, the order of the query over the projections of the source, in which its reader takes the rows, such as an aggregate.
+* Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation.
 *
-* The order of a derived source does not carry into the query that reads it, so the reader sorts by sort keys: the projections that have the values of the sort expressions, as for an executed query, or projections of the sort expressions added to the source.
-* With a limit or an offset, the source sorts by the positions of the sort keys, so that the rows it chooses, their values, and their order in the reader come from one evaluation; without them, it has no order.
-* `offset` replaces the offset of `query` in the source, such as `OFFSET 0` that keeps PostgreSQL from merging it, and the source replaces the occurrence of a table `replaces` for its reader.
+* A query of a singleton table without `relation` is a query of its one row, as of `find` of a key without columns, which `upsert` applies to.
 */
-function deriveOrderedSource(query, ordered, offset = query.offset, replaces) {
-	const { orderBy } = query;
-	const projections = query.projections.slice();
-	const paginated = query.limit !== void 0 || query.offset !== void 0;
-	const sortKeys = [];
-	const positions = [];
-	if (orderBy.length > 0 && (ordered || paginated)) for (let index = 0; index < orderBy.length; index++) {
-		const { expression, direction, nulls } = orderBy[index];
-		const position = projectSortKey(projections, expression, index);
-		if (ordered) sortKeys.push({
-			key: projections[position].key,
-			direction,
-			nulls
-		});
-		if (paginated) positions.push(Object.freeze({
-			expression: createPositionNode(position),
-			direction,
-			nulls
-		}));
-	}
-	const derivedQuery = Object.freeze({
-		...query,
-		projections,
-		orderBy: positions,
-		offset
-	});
-	const source = Object.freeze(replaces === void 0 ? {
-		kind: "derived",
-		query: derivedQuery,
-		lateral: false
-	} : {
-		kind: "derived",
-		query: derivedQuery,
-		lateral: false,
-		replaces
+function createQueryNode(from, relation, filters = noFilters) {
+	const singleton = relation === void 0 && from.table.singleton;
+	return Object.freeze({
+		kind: "query",
+		from,
+		relation,
+		projections: [],
+		filters,
+		groupBy: [],
+		having: void 0,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		distinct: false,
+		distinctOn: [],
+		distinctFields: void 0,
+		lock: void 0,
+		rows: relation === void 0 ? getTableRows(from.table) : getRelationRows(relation),
+		value: false,
+		guaranteed: relation?.required ?? false,
+		all: false,
+		conversion: void 0,
+		foundKey: singleton ? singletonKey : void 0
 	});
-	const order = [];
-	for (const { key, direction, nulls } of sortKeys) order.push(Object.freeze({
-		expression: createNode({
-			kind: "column",
-			source,
-			key
-		}),
-		direction,
-		nulls
-	}));
-	return {
-		source,
-		order
-	};
 }
-/**
-* Returns the position of the projection that sorts by `expression`: the projection of `findSortProjection`, or one added to `projections`.
-*
-* `index` is the position of the expression in the order.
-*/
-function projectSortKey(projections, expression, index) {
-	const position = findSortProjection(projections, expression);
-	if (position !== -1) return position;
-	projections.push(Object.freeze({
-		key: createSortProjectionKey(projections, index),
-		expression,
-		type: text
-	}));
-	return projections.length - 1;
+/** Tells whether `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, keys of groups, order, limit, offset, `distinct`, keys of `distinctOn`, row lock, rows other than those that the table starts with, `many` or `optional` of a singleton table, `all`, or conversion. */
+function isTableQuery(node) {
+	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.groupBy.length === 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && !node.distinct && node.distinctOn.length === 0 && node.lock === void 0 && node.rows === getTableRows(node.from.table) && !node.all && node.conversion === void 0;
 }
-/** Creates the key of the sort key projection at `index` of the sort keys, which no other projection has. */
-function createSortProjectionKey(projections, index) {
-	const base = `$order${index + 1}`;
-	let key = base;
-	for (let number = 2; projections.some((projection) => projection.key === key); number++) key = `${base}_${number}`;
-	return key;
+/** Tells whether a selected field is the rows of a nested query. */
+function isNestedSelection(node) {
+	return "query" in node;
 }
-// src/lowering/nested.ts
-/** Maximum number of arguments of a PostgreSQL function, `FUNC_MAX_ARGS` of its default build. */
-const maxFunctionArguments = 100;
-/** Number `0`, the offset that keeps PostgreSQL from merging a derived source into its query. */
-const zeroNode = /* @__PURE__ */ createNode({
-	kind: "raw",
-	fragments: ["0"],
-	values: []
-});
+/** Tells whether a selected field is a literal. */
+function isLiteralSelection(node) {
+	return "literal" in node;
+}
+// src/lowering/context.ts
+/** Rejects a query of a relation outside the definitions of `context`. */
+function checkRelation(node, context) {
+	const { relation } = node;
+	const { definitions } = context;
+	if (relation !== void 0 && definitions !== void 0 && !definitions.has(relation)) throw new Error(`Relation "${formatRelationName(relation.key, relation.name)}" is not part of the schema`);
+}
+/** Rejects a nested query bound to `db`, which the error names as `subject`, unless `db` is the `Db` of `context` or `undefined`. */
+function checkDb(db, context, subject) {
+	if (db !== void 0 && db !== context.db) throw new Error(context.db === void 0 ? `${subject} is bound to a Db, so only that Db can compile the query` : `${subject} is bound to another Db`);
+}
+// src/lowering/expression.ts
 /**
-* Creates the projection of the rows of `query` packed as JSON under `key`, selected as a scalar subquery and decoded by the result plan of `query`.
+* Lowers an expression, replacing each query in it and checking the query as a nested query.
+* A query of `exists`, such as in a condition, becomes `EXISTS` of its rows, another query of one value a scalar subquery of its value, the query of the values of `IN` its statement, and another query in SQL text its statement in parentheses.
 *
-* Rows `many` are one array, and the other rows modes are one packed row or `NULL` without a row; a scalar subquery fails with several rows.
+* It returns `node` itself when it holds no query, and creates only the nodes that hold one.
 */
-function projectRows(key, query) {
-	const packed = packRows(query);
-	const { nested } = packed.projections[0];
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "subquery",
+function lowerExpression(node, context) {
+	switch (node.kind) {
+		case "column":
+		case "param":
+		case "boolean":
+		case "values":
+		case "tableName":
+		case "subquery":
+		case "exists":
+		case "textSubquery": return node;
+		case "nestedQuery": return lowerNestedQuery(node, context);
+		case "cast": {
+			const operand = lowerExpression(node.operand, context);
+			return operand === node.operand ? node : createNode({
+				kind: "cast",
+				operand,
+				type: node.type
+			});
+		}
+		case "not": {
+			const operand = lowerExpression(node.operand, context);
+			return operand === node.operand ? node : createNode({
+				kind: "not",
+				operand
+			});
+		}
+		case "isNull": {
+			const operand = lowerExpression(node.operand, context);
+			return operand === node.operand ? node : createNode({
+				kind: "isNull",
+				operand
+			});
+		}
+		case "and":
+		case "or": {
+			const operands = lowerEach(node.operands, context, lowerExpression);
+			return operands === node.operands ? node : createNode({
+				kind: node.kind,
+				operands
+			});
+		}
+		case "comparison": {
+			const left = lowerExpression(node.left, context);
+			const right = lowerExpression(node.right, context);
+			return left === node.left && right === node.right ? node : createNode({
+				kind: "comparison",
+				operator: node.operator,
+				left,
+				right
+			});
+		}
+		case "in": {
+			const operand = lowerExpression(node.operand, context);
+			const list = lowerEach(node.list, context, lowerExpression);
+			return operand === node.operand && list === node.list ? node : createNode({
+				kind: "in",
+				operand,
+				list
+			});
+		}
+		case "inQuery": {
+			const operand = lowerExpression(node.operand, context);
+			const query = node.query.kind === "nestedQuery" ? lowerQueryOfValues(node.query, context) : node.query;
+			return operand === node.operand && query === node.query ? node : createNode({
+				kind: "inQuery",
+				operand,
+				query
+			});
+		}
+		case "raw": {
+			const values = lowerEach(node.values, context, lowerExpression);
+			return values === node.values ? node : createNode({
+				kind: "raw",
+				fragments: node.fragments,
+				values
+			});
+		}
+		case "aggregate": {
+			const args = lowerEach(node.arguments, context, lowerExpression);
+			const orderBy = lowerOrder(node.orderBy, context);
+			const filter = lowerValue(node.filter, context);
+			return args === node.arguments && orderBy === node.orderBy && filter === node.filter ? node : createNode({
+				kind: "aggregate",
+				name: node.name,
+				distinct: node.distinct,
+				arguments: args,
+				orderBy,
+				filter
+			});
+		}
+		default: return node;
+	}
+}
+/** Lowers an optional expression, such as `having` of a query or a value of a row of an insert, as `lowerExpression` does. */
+function lowerValue(node, context) {
+	return node === void 0 ? void 0 : lowerExpression(node, context);
+}
+/**
+* Lowers a query in an expression to `EXISTS` of the rows of a query of `exists`, to a scalar subquery of the value of another query of one value, or to its statement in parentheses for a query of records or of rows `many`, which only SQL text holds.
+*
+* In SQL text, a query of `exists` stays `EXISTS` rather than a subquery of its value, so that PostgreSQL can join its rows in a condition, as a semi-join.
+*/
+function lowerNestedQuery(node, context) {
+	checkDb(node.db, context, "A query in an expression");
+	const { query } = node;
+	if (isExistsQuery(query)) return context.lowerExists(query);
+	return createNode({
+		kind: query.value && query.rows !== "many" ? "subquery" : "textSubquery",
+		query: context.lowerSelect(query, sortsByPositions(query))
+	});
+}
+/** Lowers the query of the values of `IN` to its statement, whatever its rows; it tells positions as `sortsByPositions` does. */
+function lowerQueryOfValues(node, context) {
+	checkDb(node.db, context, "A query in an expression");
+	return context.lowerSelect(node.query, sortsByPositions(node.query));
+}
+/** Tells whether the statement of `node` in a subquery sorts by the positions of its projections: PostgreSQL finds a sort expression of `SELECT DISTINCT` or `GROUP BY` only when it is equal to a selected one or a key, and the keys of `DISTINCT ON` with the order only when they are equal, while a repeated expression has aliases of its own and, apart from the parameters of casts in a query of groups, parameters of its own. */
+function sortsByPositions(node) {
+	return node.distinct || node.distinctOn.length > 0 || node.groupBy.length > 0;
+}
+/** Lowers the filters of a query, replacing the queries in their expressions; without queries, it returns `filters` itself. */
+function lowerFilters(filters, context) {
+	const { relation, scope, user } = filters;
+	const loweredRelation = relation === void 0 ? void 0 : lowerExpression(relation, context);
+	const loweredScope = scope === void 0 ? void 0 : lowerExpression(scope, context);
+	const loweredUser = user === void 0 ? void 0 : lowerExpression(user, context);
+	if (loweredRelation === relation && loweredScope === scope && loweredUser === user) return filters;
+	const lowered = {};
+	if (loweredRelation !== void 0) lowered.relation = loweredRelation;
+	if (loweredScope !== void 0) lowered.scope = loweredScope;
+	if (loweredUser !== void 0) lowered.user = loweredUser;
+	return Object.freeze(lowered);
+}
+/**
+* Lowers the sort keys of a query, replacing the queries in their expressions; without queries, it returns `orderBy` itself.
+*
+* Each sort key is lowered by `lowerSelectedValue` over `selected`, the fields of the query, and `projections`, their lowered projections.
+*/
+function lowerOrder(orderBy, context, selected, projections) {
+	let lowered;
+	for (let index = 0; index < orderBy.length; index++) {
+		const order = orderBy[index];
+		const { expression } = order;
+		const sorted = lowerSelectedValue(expression, context, selected, projections);
+		if (lowered === void 0 && sorted === expression) continue;
+		lowered ??= orderBy.slice(0, index);
+		lowered.push(sorted === expression ? order : Object.freeze({
+			expression: sorted,
+			direction: order.direction,
+			nulls: order.nulls
+		}));
+	}
+	return lowered ?? orderBy;
+}
+/**
+* Lowers the keys of `groupBy` or `distinctOn` of a query, or `undefined` for a query without them.
+*
+* Each key is lowered by `lowerSelectedValue` over `selected`, the fields of the query, and `projections`, their lowered projections.
+*/
+function lowerKeys(keys, context, selected, projections) {
+	return keys.length === 0 ? void 0 : lowerEach(keys, context, (key, keyContext) => lowerSelectedValue(key, keyContext, selected, projections));
+}
+/**
+* Lowers `expression`, a sort key, a key of a group, or the argument of an aggregate: the value of a field of `selected` gets the expression of its lowered projection among `projections`, and another expression is lowered as it is.
+*
+* Lowering a field that holds a query gives its projection a new node, so reusing that node keeps the projection identifiable by its position.
+* A field of an aggregate or of `exists` is identified by the node of its reference, which holds the field.
+*/
+function lowerSelectedValue(expression, context, selected, projections) {
+	const position = selected === void 0 || projections === void 0 || projections === selected ? -1 : selected.findIndex((field) => isFieldValue(field, expression));
+	return position === -1 ? lowerExpression(expression, context) : projections[position].expression;
+}
+/** Tells whether `expression`, a sort key, a key of a group, or the argument of an aggregate, is the value of `field`: its expression, or for a field of an aggregate or of `exists`, the node of its reference in the callback of `orderBy` or `groupBy`. */
+function isFieldValue(field, expression) {
+	return isNestedSelection(field) ? expression.kind === "nestedQuery" && expression.field === field : field.expression === expression;
+}
+/** Lowers each of `items` with `lower`; when none changes, it returns `items` itself. */
+function lowerEach(items, context, lower) {
+	let lowered;
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		const result = lower(item, context);
+		if (lowered !== void 0) lowered.push(result);
+		else if (result !== item) {
+			lowered = items.slice(0, index);
+			lowered.push(result);
+		}
+	}
+	return lowered ?? items;
+}
+// src/lowering/order.ts
+/** Creates the number of the projection at `position`, by which `ORDER BY` sorts by its value instead of evaluating an expression again. */
+function createPositionNode(position) {
+	return createNode({
+		kind: "raw",
+		fragments: [String(position + 1)],
+		values: []
+	});
+}
+/** Creates the order of a statement that sorts by the positions of the projections among `projections` that have the values of its sort expressions, and by the other expressions as they are. */
+function sortByPositions(orderBy, projections) {
+	const result = [];
+	for (const order of orderBy) {
+		const position = findValueProjection(projections, order.expression);
+		result.push(position === -1 ? order : Object.freeze({
+			expression: createPositionNode(position),
+			direction: order.direction,
+			nulls: order.nulls
+		}));
+	}
+	return result;
+}
+/**
+* Creates the derived source of the rows of `query`, and, when `ordered`, the order of the query over the projections of the source, in which its reader takes the rows, such as an aggregate.
+*
+* The order of a derived source does not carry into the query that reads it, so the reader sorts by sort keys: the projections that have the values of the sort expressions, as for an executed query, or projections of the sort expressions added to the source.
+* With a limit or an offset, the source sorts by the positions of the sort keys, so that the rows it chooses, their values, and their order in the reader come from one evaluation; so it does with `DISTINCT ON`, whose order chooses the first row of each group, and with a row lock, which takes the rows in the order of its query.
+* Without them, it has no order.
+* `offset` replaces the offset of `query` in the source, such as `OFFSET 0` that keeps PostgreSQL from merging it, and the source replaces the occurrence of a table `replaces` for its reader.
+*/
+function deriveOrderedSource(query, ordered, offset = query.offset, replaces) {
+	const { orderBy } = query;
+	const projections = query.projections.slice();
+	const sorted = query.limit !== void 0 || query.offset !== void 0 || query.distinctOn !== void 0 || query.lock !== void 0;
+	const sortKeys = [];
+	const positions = [];
+	if (orderBy.length > 0 && (ordered || sorted)) for (let index = 0; index < orderBy.length; index++) {
+		const { expression, direction, nulls } = orderBy[index];
+		const position = projectSortKey(projections, expression, index);
+		if (ordered) sortKeys.push({
+			key: projections[position].key,
+			direction,
+			nulls
+		});
+		if (sorted) positions.push(Object.freeze({
+			expression: createPositionNode(position),
+			direction,
+			nulls
+		}));
+	}
+	const derivedQuery = Object.freeze({
+		...query,
+		projections,
+		orderBy: positions,
+		offset
+	});
+	const source = Object.freeze(replaces === void 0 ? {
+		kind: "derived",
+		query: derivedQuery,
+		lateral: false
+	} : {
+		kind: "derived",
+		query: derivedQuery,
+		lateral: false,
+		replaces
+	});
+	const order = [];
+	for (const { key, direction, nulls } of sortKeys) order.push(Object.freeze({
+		expression: createNode({
+			kind: "column",
+			source,
+			key
+		}),
+		direction,
+		nulls
+	}));
+	return {
+		source,
+		order
+	};
+}
+/**
+* Returns the position of the projection that sorts by `expression`: the projection of `findValueProjection`, or one added to `projections`.
+*
+* `index` is the position of the expression in the order.
+*/
+function projectSortKey(projections, expression, index) {
+	const position = findValueProjection(projections, expression);
+	if (position !== -1) return position;
+	projections.push(Object.freeze({
+		key: createSortProjectionKey(projections, index),
+		expression,
+		type: text
+	}));
+	return projections.length - 1;
+}
+/** Creates the key of the sort key projection at `index` of the sort keys, which no other projection has. */
+function createSortProjectionKey(projections, index) {
+	const base = `$order${index + 1}`;
+	let key = base;
+	for (let number = 2; projections.some((projection) => projection.key === key); number++) key = `${base}_${number}`;
+	return key;
+}
+// src/lowering/nested.ts
+/** Maximum number of arguments of a PostgreSQL function, `FUNC_MAX_ARGS` of its default build. */
+const maxFunctionArguments = 100;
+/** Number `0`, the offset that keeps PostgreSQL from merging a derived source into its query. */
+const zeroNode = /* @__PURE__ */ createNode({
+	kind: "raw",
+	fragments: ["0"],
+	values: []
+});
+/**
+* Creates the projection of the rows of `query` packed as JSON under `key`, selected as a scalar subquery and decoded by the result plan of `query`.
+*
+* Rows `many` are one array, and the other rows modes are one packed row or `NULL` without a row; a scalar subquery fails with several rows.
+*/
+function projectRows(key, query) {
+	const packed = packRows(query);
+	const { nested } = packed.projections[0];
+	return Object.freeze({
+		key,
+		expression: createNode({
+			kind: "subquery",
 			query: packed
 		}),
-		nested
+		nested
+	});
+}
+/**
+* Creates a query whose only projection is the rows of `query` packed as JSON, a field decoded by the result plan of `query`.
+*
+* Rows `many` are packed as an array in the order of `query`, and the created query returns one row.
+* Otherwise the created query returns a packed row for each row of `query`, so a scalar subquery of it gives the packed row, `NULL` without a row, and fails with several rows.
+*/
+function packRows(query) {
+	const { projections } = query;
+	const many = query.rows === "many";
+	const { source, order } = deriveOrderedSource(query, many, !query.distinct && query.distinctOn === void 0 && query.groupBy === void 0 && query.lock === void 0 && query.limit === void 0 && query.offset === void 0 && projections.some((projection) => projection.nested === void 0 && !isTableColumn(projection.expression)) ? zeroNode : query.offset);
+	const wide = projections.length > maxFunctionArguments;
+	const values = [];
+	for (const projection of projections) {
+		const value = createRef(source, projection.key);
+		if (projection.nested !== void 0) values.push(value);
+		else values.push(wide ? createList("to_json(", [packScalar(value)], ")") : packScalar(value));
+	}
+	const row = wide ? createList("array_to_json(ARRAY[", values, "])") : createList("json_build_array(", values, ")");
+	let packed = row;
+	if (many) packed = createNode({
+		kind: "raw",
+		fragments: ["coalesce(", ", '[]'::json)"],
+		values: [createNode({
+			kind: "aggregate",
+			name: "json_agg",
+			distinct: false,
+			arguments: [row],
+			orderBy: order,
+			filter: void 0
+		})]
+	});
+	const plan = Object.freeze({
+		fields: projections,
+		rows: query.rows,
+		value: query.value,
+		guaranteedBy: query.guaranteedBy,
+		recordTemplate: query.recordTemplate,
+		conversion: query.conversion
+	});
+	const projection = Object.freeze({
+		key: "rows",
+		expression: packed,
+		nested: plan
+	});
+	return createSelectNode(source, [projection]);
+}
+/** Tells whether `node` is a column of a table, which PostgreSQL reads rather than evaluates, so it can be repeated. */
+function isTableColumn(node) {
+	return node.kind === "column" && node.source.kind === "table";
+}
+/**
+* Packs a scalar as its PostgreSQL text representation, or `NULL`.
+*
+* `format` uses the output function of the type, as the driver receives the values of a row; a cast to `text` differs from it for types such as `boolean`, `inet`, and `char`.
+*/
+function packScalar(value) {
+	return createNode({
+		kind: "raw",
+		fragments: [
+			"CASE WHEN ",
+			" IS NOT DISTINCT FROM NULL THEN NULL ELSE format('%s', ",
+			") END"
+		],
+		values: [value, value]
+	});
+}
+function createRef(source, key) {
+	return createNode({
+		kind: "column",
+		source,
+		key
+	});
+}
+// src/lowering/projection.ts
+/**
+* Lowers the fields of a query to projections, packing the rows of each nested query into the value of its field, or selecting the value of an aggregate query or `EXISTS` of a query of `exists`, and replacing the queries in the expressions of the other fields; checks them as `lowerQuery` does.
+*
+* Without queries, it returns `selected` itself.
+*/
+function lowerProjections(selected, context) {
+	let lowered;
+	for (let index = 0; index < selected.length; index++) {
+		const field = selected[index];
+		let projection;
+		if (isNestedSelection(field)) {
+			checkDb(field.db, context, `Selected field "${field.key}"`);
+			projection = projectQuery(field.key, field.query, context);
+		} else {
+			const expression = lowerExpression(field.expression, context);
+			projection = expression === field.expression ? field : Object.freeze({
+				key: field.key,
+				expression,
+				type: field.type
+			});
+		}
+		if (lowered !== void 0) lowered.push(projection);
+		else if (projection !== field) {
+			lowered = selected.slice(0, index);
+			lowered.push(projection);
+		}
+	}
+	return lowered ?? selected;
+}
+/** Creates the projection of the value of `node`, a nested query, under `key`: `EXISTS` of a query of `exists`, the value of an aggregate query, or the packed rows of another query or of one whose result code converts. */
+function projectQuery(key, node, context) {
+	if (!isSelectedAsValue(node)) return projectRows(key, context.lowerSelect(node, false));
+	return isExistsQuery(node) ? projectExists(key, node, context) : projectAggregateValue(key, context.lowerSelect(node, false));
+}
+/** Creates the projection of `EXISTS` of the rows of `node`, a query of `exists`, under `key`, decoded by the type of the projection of `exists`. */
+function projectExists(key, node, context) {
+	return Object.freeze({
+		key,
+		expression: context.lowerExists(node),
+		type: node.projections[0].type
+	});
+}
+/** Creates the projection of the value of `query`, the statement of an aggregate query, under `key`, selected as a scalar subquery and decoded by the type of the aggregate. */
+function projectAggregateValue(key, query) {
+	return Object.freeze({
+		key,
+		expression: createNode({
+			kind: "subquery",
+			query
+		}),
+		type: query.projections[0].type
+	});
+}
+/** Returns the fields of `selected` that a statement selects, or `selected` itself without literals. */
+function dropLiterals(selected) {
+	if (!selected.some(isLiteralSelection)) return selected;
+	const fields = [];
+	for (const field of selected) if (!isLiteralSelection(field)) fields.push(field);
+	return fields;
+}
+/** Creates the template of the records of `selected`: every field in its order with the value of a literal, or `undefined` without literals. */
+function createRecordTemplate(selected) {
+	if (!selected.some(isLiteralSelection)) return;
+	const template = [];
+	for (const field of selected) template.push(Object.freeze({
+		key: field.key,
+		value: isLiteralSelection(field) ? field.literal : void 0
+	}));
+	return template;
+}
+// src/lowering/distinct.ts
+/**
+* Rejects a query of `distinct` of the lowered `projections` and `orderBy` that `SELECT DISTINCT` cannot give the rows of, with an error that does not depend on where the query is:
+*
+* - A query without projections, such as of only literals, has nothing to compare, and PostgreSQL has no syntax for it.
+* - Nested rows are JSON, which PostgreSQL cannot compare.
+* - PostgreSQL rejects a sort key that is not a projection, since duplicates can differ in its value, whereas a packed query would add it to the projections of its derived source and compare it too.
+*   Only a projection of the same column or of the same expression node is sure to have its value, as in `findValueProjection`.
+*/
+function checkDistinct(projections, orderBy) {
+	if (projections.length === 0) throw new Error("distinct requires at least one selected column or SQL expression; literal fields are not compared");
+	for (const { key, nested } of projections) if (nested !== void 0) throw new Error(`distinct cannot compare the nested rows of the selected field "${key}"`);
+	for (const { expression } of orderBy) if (findValueProjection(projections, expression) === -1) throw new Error("A query of distinct sorts only by its selected fields, since duplicates can differ in any other value; select the value to sort by it");
+}
+/**
+* Rejects a query of `distinctOn` of the lowered `projections`, `keys`, and `orderBy` that `SELECT DISTINCT ON` cannot give the rows of, with an error that does not depend on where the query is: a query without projections, such as of only literals, since PostgreSQL requires a select list with `DISTINCT ON`, and an order that `checkDistinctOnOrder` rejects.
+*/
+function checkDistinctOn(projections, keys, orderBy) {
+	if (projections.length === 0) throw new Error("distinctOn requires at least one selected column or SQL expression; literal fields are not selected");
+	checkDistinctOnOrder(projections, keys, orderBy);
+}
+/**
+* Rejects an order of a query of `distinctOn` of the lowered `projections`, `keys`, and `orderBy` that sorts by a value other than the keys before it sorts by all of them, in any order and direction, which PostgreSQL rejects, since the order sorts the groups apart and then chooses the first row of each; an order of only keys may omit some, which PostgreSQL adds.
+*
+* A sort key is a key when it is the same column, or the same expression node that a projection of the query has, as `findValueProjection` tells, so that both compile to the same column or position.
+* Another expression may compile at each place with parameters and aliases of its own, so PostgreSQL may find the two unequal; the check runs before packing, which would add the expression to the projections of its derived source and make both positions, so that it counts as another value wherever the query is.
+*/
+function checkDistinctOnOrder(projections, keys, orderBy) {
+	const isKey = (key, expression) => isSameValue(key, expression) && (key.kind === "column" || findValueProjection(projections, key) !== -1);
+	let leading = 0;
+	while (leading < orderBy.length && keys.some((key) => isKey(key, orderBy[leading].expression))) leading++;
+	if (leading === orderBy.length) return;
+	for (const key of keys) {
+		let sorted = false;
+		for (let index = 0; index < leading && !sorted; index++) sorted = isKey(key, orderBy[index].expression);
+		if (!sorted) throw new Error("A query of distinctOn must sort by all its keys before any other value; sort by a key of an expression through its selected field");
+	}
+}
+/**
+* Lowers the rows of `node`, a query of `distinct` or `distinctOn` made by an aggregate method or `exists`, to the statement that gives them, which an aggregate reads from a derived source and `EXISTS` reads as it is.
+*
+* It lowers the fields that the query kept, its keys, its order, and `argument`, the first argument of the aggregate, through those fields, as `lowerSelectedValue` does, so that each value of a selected field is its projection, and checks the query as the statement of the query of those fields is checked, except that a query of `distinctOn` needs no selected field, since the statement selects its keys.
+*
+* - The statement of `distinct` selects the fields, which `DISTINCT` compares, and `argument` must be one of them, as a sort key must be, since duplicates can differ in any other value.
+* - The statement of `distinctOn` selects `argument` and each key that it does not select otherwise, so that it has a select list, which PostgreSQL requires with `DISTINCT ON`.
+*   It selects no other field, since an aggregate reads the rows of the source rather than of the select list, as for a query without `distinctOn`, so it does not lower the fields of nested rows, which neither a key nor a sort key reads.
+*
+* The statement has the order of the query when `sorted` is set; the number of the rows, which `count(*)` and `EXISTS` read, does not depend on it.
+*/
+function lowerDistinctRows(node, context, argument, sorted) {
+	const fields = dropLiterals(node.distinctFields);
+	let selected = fields;
+	if (!node.distinct) {
+		const scalars = [];
+		for (const field of fields) if (!isNestedSelection(field) || isSelectedAsValue(field.query)) scalars.push(field);
+		selected = scalars;
+	}
+	const projections = lowerProjections(selected, context);
+	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
+	const groupBy = lowerKeys(node.groupBy, context, selected, projections);
+	const keys = lowerKeys(node.distinctOn, context, selected, projections);
+	const value = argument === void 0 ? void 0 : lowerSelectedValue(argument, context, selected, projections);
+	let sourced;
+	let valueKey;
+	if (keys === void 0) {
+		checkDistinct(projections, orderBy);
+		sourced = projections;
+		if (value !== void 0) {
+			const position = findValueProjection(projections, value);
+			if (position === -1) throw new Error("An aggregate of a query of distinct reads only its selected fields, since duplicates can differ in any other value; select the value to aggregate it");
+			valueKey = projections[position].key;
+		}
+	} else {
+		checkDistinctOnOrder(projections, keys, orderBy);
+		const keyed = [];
+		if (value !== void 0) {
+			valueKey = "value";
+			keyed.push(Object.freeze({
+				key: valueKey,
+				expression: value,
+				type: text
+			}));
+		}
+		for (let index = 0; index < keys.length; index++) {
+			const key = keys[index];
+			if (findValueProjection(keyed, key) === -1) keyed.push(Object.freeze({
+				key: `$key${index + 1}`,
+				expression: key,
+				type: text
+			}));
+		}
+		sourced = keyed;
+	}
+	return {
+		query: Object.freeze({
+			kind: "select",
+			from: node.from,
+			joins: noJoins,
+			projections: sourced,
+			filters: lowerFilters(node.filters, context),
+			groupBy,
+			having: lowerValue(node.having, context),
+			orderBy: sorted ? orderBy : noOrder,
+			limit: node.limit,
+			offset: node.offset,
+			distinct: node.distinct,
+			distinctOn: keys,
+			rows: "many",
+			value: false,
+			guaranteedBy: void 0
+		}),
+		valueKey
+	};
+}
+// src/lowering/aggregate.ts
+/** Lowers an aggregate query to a statement of the value of its aggregate over the rows that its filters, limit, and offset choose, also the distinct rows of `distinct` and the first rows of `distinctOn`. */
+function lowerAggregate(node, context) {
+	const field = node.projections[0];
+	const aggregate = field.expression;
+	const counted = aggregate === countProjection.expression;
+	let from = node.from;
+	let filters = noFilters;
+	let args = aggregate.arguments;
+	let order = noOrder;
+	let rows;
+	let valueKey;
+	if (node.distinctFields !== void 0) {
+		const distinctRows = lowerDistinctRows(node, context, counted ? void 0 : aggregate.arguments[0], !counted);
+		rows = distinctRows.query;
+		valueKey = distinctRows.valueKey;
+	} else {
+		const orderBy = lowerOrder(node.orderBy, context);
+		const groupBy = lowerKeys(node.groupBy, context);
+		filters = lowerFilters(node.filters, context);
+		args = lowerEach(aggregate.arguments, context, lowerExpression);
+		order = field.ordered ? orderBy : noOrder;
+		if (groupBy !== void 0 || node.limit !== void 0 || node.offset !== void 0 || !counted && !refersToSource(args[0], node.from)) {
+			const projections = [];
+			if (!counted) {
+				valueKey = "value";
+				projections.push(Object.freeze({
+					key: valueKey,
+					expression: args[0],
+					type: field.type
+				}));
+			}
+			rows = {
+				kind: "select",
+				from: node.from,
+				joins: noJoins,
+				projections,
+				filters,
+				groupBy,
+				having: lowerValue(node.having, context),
+				orderBy: counted ? noOrder : orderBy,
+				limit: node.limit,
+				offset: node.offset,
+				rows: "many",
+				value: false,
+				guaranteedBy: void 0
+			};
+		}
+	}
+	if (rows !== void 0) {
+		const derived = deriveOrderedSource(rows, field.ordered);
+		from = derived.source;
+		filters = noFilters;
+		if (valueKey !== void 0) {
+			const sourceArgs = [createNode({
+				kind: "column",
+				source: from,
+				key: valueKey
+			})];
+			for (let index = 1; index < args.length; index++) sourceArgs.push(args[index]);
+			args = sourceArgs;
+		}
+		order = derived.order;
+	}
+	const call = args === aggregate.arguments && order.length === 0 ? aggregate : createNode({
+		kind: "aggregate",
+		name: aggregate.name,
+		distinct: aggregate.distinct,
+		arguments: args,
+		orderBy: order,
+		filter: aggregate.filter
+	});
+	const fallbacks = lowerEach(field.fallbacks, context, lowerExpression);
+	let value = call;
+	if (fallbacks.length > 0) {
+		const values = [call];
+		for (const fallback of fallbacks) values.push(fallback);
+		value = createList("coalesce(", values, ")");
+	}
+	return Object.freeze({
+		kind: "select",
+		from,
+		joins: noJoins,
+		projections: [value === aggregate ? field : Object.freeze({
+			key: field.key,
+			expression: value,
+			type: field.type
+		})],
+		filters,
+		orderBy: noOrder,
+		limit: void 0,
+		offset: void 0,
+		rows: node.rows,
+		value: true,
+		guaranteedBy: void 0
+	});
+}
+/**
+* Tells whether `node` refers to `source` outside the queries nested in it.
+*
+* A reference inside a nested query is not counted, so an argument that refers to the source only there is read from a derived source, which is correct either way.
+*/
+function refersToSource(node, source) {
+	switch (node.kind) {
+		case "column": return node.source === source;
+		case "param":
+		case "boolean":
+		case "values":
+		case "nestedQuery":
+		case "tableName":
+		case "subquery":
+		case "exists":
+		case "textSubquery": return false;
+		case "cast":
+		case "not":
+		case "isNull":
+		case "inQuery": return refersToSource(node.operand, source);
+		case "and":
+		case "or": return node.operands.some((operand) => refersToSource(operand, source));
+		case "comparison": return refersToSource(node.left, source) || refersToSource(node.right, source);
+		case "in": return refersToSource(node.operand, source) || node.list.some((item) => refersToSource(item, source));
+		case "raw": return node.values.some((value) => refersToSource(value, source));
+		case "aggregate": return node.arguments.some((argument) => refersToSource(argument, source)) || node.filter !== void 0 && refersToSource(node.filter, source);
+		default: return node;
+	}
+}
+// src/lowering/exists.ts
+/** Lowers a query of `exists` to `EXISTS` of the rows that its filters, limit, and offset choose, also the distinct rows of `distinct` and the first rows of `distinctOn`. */
+function lowerExists(node, context) {
+	checkRelation(node, context);
+	return createNode({
+		kind: "exists",
+		query: node.distinctFields === void 0 ? Object.freeze({
+			kind: "select",
+			from: node.from,
+			joins: noJoins,
+			projections: noProjections,
+			filters: lowerFilters(node.filters, context),
+			groupBy: lowerKeys(node.groupBy, context),
+			having: lowerValue(node.having, context),
+			orderBy: noOrder,
+			limit: node.limit,
+			offset: node.offset,
+			rows: "many",
+			value: false,
+			guaranteedBy: void 0
+		}) : lowerDistinctRows(node, context, void 0, false).query
+	});
+}
+// src/ast/references.ts
+/** Adds to `keys` the key of each column reference to `source` in `node` at any depth, including the queries nested in it. */
+function collectColumnKeys(node, source, keys) {
+	visitNodes(node, (child) => {
+		if (child.kind === "column" && child.source === source) keys.add(child.key);
 	});
 }
 /**
-* Creates a query whose only projection is the rows of `query` packed as JSON, a field decoded by the result plan of `query`.
+* Tells whether `node` holds, at any depth, what may aggregate the rows of the query of `source`: an `aggregate` node or a SQL fragment that refers to a column of `source` at any depth, also in the queries nested in it.
 *
-* Rows `many` are packed as an array in the order of `query`, and the created query returns one row.
-* Otherwise the created query returns a packed row for each row of `query`, so a scalar subquery of it gives the packed row, `NULL` without a row, and fails with several rows.
+* PostgreSQL assigns an aggregate whose arguments and filter refer only to the sources of an enclosing query to that query, also through a query nested in them ([PostgreSQL](https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-AGGREGATES)), so such a call in a nested query, such as `sum` of a column of the parent row, aggregates the rows of the query of `source`.
+* Lowering does not parse SQL fragments to identify their aggregates, so a fragment counts as such a call.
+*
+* It is conservative: an aggregate whose arguments read both `source` and its own query belongs to its own query, yet it counts, since this walk cannot tell a source of the query that holds the aggregate from one of an enclosing query.
+* So does a scalar fragment, also one that reads `source` only through a query correlated with it, such as of a relation.
 */
-function packRows(query) {
-	const { projections } = query;
-	const many = query.rows === "many";
-	const { source, order } = deriveOrderedSource(query, many, query.limit === void 0 && query.offset === void 0 && projections.some((projection) => projection.nested === void 0 && !isTableColumn(projection.expression)) ? zeroNode : query.offset);
-	const wide = projections.length > maxFunctionArguments;
-	const values = [];
-	for (const projection of projections) {
-		const value = createRef(source, projection.key);
-		if (projection.nested !== void 0) values.push(value);
-		else values.push(wide ? createList("to_json(", [packScalar(value)], ")") : packScalar(value));
-	}
-	const row = wide ? createList("array_to_json(ARRAY[", values, "])") : createList("json_build_array(", values, ")");
-	let packed = row;
-	if (many) packed = createNode({
-		kind: "raw",
-		fragments: ["coalesce(", ", '[]'::json)"],
-		values: [createNode({
-			kind: "aggregate",
-			name: "json_agg",
-			distinct: false,
-			arguments: [row],
-			orderBy: order
-		})]
-	});
-	const plan = Object.freeze({
-		fields: projections,
-		rows: query.rows,
-		value: query.value,
-		guaranteedBy: query.guaranteedBy,
-		recordTemplate: query.recordTemplate
-	});
-	const projection = Object.freeze({
-		key: "rows",
-		expression: packed,
-		nested: plan
+function mayAggregateSource(node, source) {
+	let found = false;
+	const check = (value) => {
+		if (value.kind === "column" && value.source === source) found = true;
+	};
+	visitNodes(node, (child) => {
+		if (!found && (child.kind === "aggregate" || child.kind === "raw")) visitNodes(child, check);
 	});
-	return createSelectNode(source, [projection]);
-}
-/** Tells whether `node` is a column of a table, which PostgreSQL reads rather than evaluates, so it can be repeated. */
-function isTableColumn(node) {
-	return node.kind === "column" && node.source.kind === "table";
+	return found;
 }
 /**
-* Packs a scalar as its PostgreSQL text representation, or `NULL`.
+* Tells whether an aggregate belongs to an enclosing query rather than the query of `source`.
 *
-* `format` uses the output function of the type, as the driver receives the values of a row; a cast to `text` differs from it for types such as `boolean`, `inet`, and `char`.
+* Only references free in its arguments, order, and filter decide its owner: columns bound by a subquery do not count, but references through that subquery to its enclosing queries do.
+* Without such references, an aggregate of constants belongs to the query that contains it.
+* The node must have been lowered, so that subqueries expose their sources.
 */
-function packScalar(value) {
-	return createNode({
-		kind: "raw",
-		fragments: [
-			"CASE WHEN ",
-			" IS NOT DISTINCT FROM NULL THEN NULL ELSE format('%s', ",
-			") END"
-		],
-		values: [value, value]
-	});
+function aggregatesOuterSource(node, source) {
+	let local = false;
+	let outer = false;
+	const queries = [];
+	visitNodes(node, (child) => {
+		if (child.kind !== "column" || local) return;
+		for (const query of queries) {
+			if (bindsSource(query.from, child.source)) return;
+			for (const join of query.joins) if (bindsSource(join.source, child.source)) return;
+		}
+		if (child.source === source) local = true;
+		else outer = true;
+	}, queries);
+	return outer && !local;
 }
-function createRef(source, key) {
-	return createNode({
-		kind: "column",
-		source,
-		key
-	});
+/** Tells whether a declared source binds a reference, including the table occurrence a derived source replaces. */
+function bindsSource(declared, source) {
+	return declared === source || declared?.kind === "derived" && declared.replaces === source;
 }
-// src/lowering/lower.ts
-const noJoins = /* @__PURE__ */ Object.freeze([]);
-const noOrder = /* @__PURE__ */ Object.freeze([]);
-const noProjections = /* @__PURE__ */ Object.freeze([]);
-function lowerStatement(node, definitions, db) {
-	const context = {
-		definitions,
-		db
-	};
+/**
+* Calls `visit` for `node` and each expression node in it at any depth, including the queries nested in it.
+* When supplied, `queries` holds the nested queries enclosing each node passed to `visit`.
+*/
+function visitNodes(node, visit, queries) {
+	visit(node);
 	switch (node.kind) {
-		case "query": return lowerSelect(node, context, true);
-		case "record": return lowerRecord(node, context);
-		case "text": return lowerText(node, context);
-		default: return lowerMutation(node, context);
+		case "column":
+		case "param":
+		case "boolean":
+		case "tableName":
+		case "values":
+		case "nestedQuery": return;
+		case "cast":
+		case "not":
+		case "isNull":
+			visitNodes(node.operand, visit, queries);
+			return;
+		case "and":
+		case "or":
+			for (const operand of node.operands) visitNodes(operand, visit, queries);
+			return;
+		case "comparison":
+			visitNodes(node.left, visit, queries);
+			visitNodes(node.right, visit, queries);
+			return;
+		case "in":
+			visitNodes(node.operand, visit, queries);
+			for (const item of node.list) visitNodes(item, visit, queries);
+			return;
+		case "inQuery":
+			visitNodes(node.operand, visit, queries);
+			if (node.query.kind === "select") visitQuery(node.query, visit, queries);
+			return;
+		case "raw":
+			for (const value of node.values) visitNodes(value, visit, queries);
+			return;
+		case "subquery":
+		case "exists":
+		case "textSubquery":
+			visitQuery(node.query, visit, queries);
+			return;
+		case "aggregate":
+			for (const argument of node.arguments) visitNodes(argument, visit, queries);
+			for (const order of node.orderBy) visitNodes(order.expression, visit, queries);
+			if (node.filter !== void 0) visitNodes(node.filter, visit, queries);
+			return;
 	}
 }
-/** Lowers a statement of SQL text, replacing the queries in the expressions interpolated into it. */
-function lowerText(node, context) {
-	const sql = lowerExpression(node.sql, context);
-	if (sql === node.sql) return node;
-	return Object.freeze({
-		kind: "text",
-		sql,
-		fields: node.fields,
-		rows: node.rows,
-		value: node.value
-	});
+/**
+* Calls `visit` for each expression node in the clauses and the derived sources of `query` at any depth.
+* When supplied, `queries` holds the nested queries enclosing each node passed to `visit`; this call adds `query` for its duration.
+*/
+function visitQuery(query, visit, queries) {
+	queries?.push(query);
+	const { from, filters } = query;
+	if (from?.kind === "derived") visitQuery(from.query, visit, queries);
+	for (const join of query.joins) {
+		if (join.source.kind === "derived") visitQuery(join.source.query, visit, queries);
+		visitNodes(join.on, visit, queries);
+	}
+	if (query.distinctOn !== void 0) for (const key of query.distinctOn) visitNodes(key, visit, queries);
+	for (const projection of query.projections) visitNodes(projection.expression, visit, queries);
+	if (filters.relation !== void 0) visitNodes(filters.relation, visit, queries);
+	if (filters.scope !== void 0) visitNodes(filters.scope, visit, queries);
+	if (filters.user !== void 0) visitNodes(filters.user, visit, queries);
+	if (query.groupBy !== void 0) for (const key of query.groupBy) visitNodes(key, visit, queries);
+	if (query.having !== void 0) visitNodes(query.having, visit, queries);
+	for (const order of query.orderBy) visitNodes(order.expression, visit, queries);
+	if (query.limit !== void 0) visitNodes(query.limit, visit, queries);
+	if (query.offset !== void 0) visitNodes(query.offset, visit, queries);
+	queries?.pop();
+}
+// src/lowering/group.ts
+/**
+* Rejects directly selected, unfiltered aggregates of an enclosing query in a query of groups.
+*
+* Types give these aggregates the nullability of their arguments in a nonempty group, but an enclosing query can have no rows.
+* A typed SQL fragment keeps its declared nullability and is the explicit escape hatch for an outer aggregate.
+*/
+function checkGroupAggregates(projections, query) {
+	for (const field of projections) {
+		const expression = field.expression;
+		if (expression.kind === "aggregate" && expression.name !== "count" && expression.filter === void 0 && aggregatesOuterSource(expression, query.from)) throw new Error(`An aggregate function of ${query.value ? "the grouped value" : `grouped field ${JSON.stringify(field.key)}`} refers only to enclosing queries; use an explicitly nullable sql expression for an outer aggregate`);
+	}
 }
+// src/lowering/mutation.ts
 /** Lowers a mutation to its statement, replacing the queries in its expressions, and packing the rows of each nested query of `RETURNING` into the value of its field, or selecting the value of a nested aggregate query, as a select list does. */
 function lowerMutation(node, context) {
-	const { target, returning, rows, value } = node;
+	const { target, returning, rows, value, conversion } = node;
 	const recordTemplate = returning === void 0 ? void 0 : createRecordTemplate(returning);
 	const lowered = returning === void 0 ? void 0 : lowerProjections(dropLiterals(returning), context);
 	switch (node.kind) {
 		case "insert": {
 			const values = lowerEach(node.values, context, lowerRow);
-			if (lowered === returning && values === node.values) return node;
+			const conflict = lowerConflict(node.conflict, context);
+			if (lowered === returning && values === node.values && conflict === node.conflict) return node;
 			return Object.freeze({
 				kind: "insert",
 				target,
 				columns: node.columns,
 				values,
+				conflict,
 				returning: lowered,
 				recordTemplate,
+				conversion,
 				rows,
 				value
 			});
@@ -1634,6 +2336,7 @@ function lowerMutation(node, context) {
 				filters,
 				returning: lowered,
 				recordTemplate,
+				conversion,
 				rows,
 				value
 			});
@@ -1647,6 +2350,7 @@ function lowerMutation(node, context) {
 				filters,
 				returning: lowered,
 				recordTemplate,
+				conversion,
 				rows,
 				value
 			});
@@ -1658,8 +2362,18 @@ function lowerMutation(node, context) {
 function lowerRow(row, context) {
 	return lowerEach(row, context, lowerValue);
 }
-function lowerValue(node, context) {
-	return node === void 0 ? void 0 : lowerExpression(node, context);
+/** Lowers the values of `DO UPDATE` of `ON CONFLICT` of an insert, keeping a conflict without queries in them as it is. */
+function lowerConflict(conflict, context) {
+	if (conflict?.update === void 0) return conflict;
+	const { target, update } = conflict;
+	const set = lowerEach(update.set, context, lowerAssignment);
+	return set === update.set ? conflict : Object.freeze({
+		target,
+		update: Object.freeze({
+			set,
+			excluded: update.excluded
+		})
+	});
 }
 function lowerAssignment(assignment, context) {
 	const value = lowerExpression(assignment.value, context);
@@ -1668,95 +2382,31 @@ function lowerAssignment(assignment, context) {
 		value
 	});
 }
-/** Lowers a query as `lowerQuery` does, or as `lowerStatement` does when `positions` is set. */
-function lowerSelect(node, context, positions) {
-	if (isExistsQuery(node)) return selectExists(node, context);
-	checkRelation(node, context);
-	if (isAggregateQuery(node)) return lowerAggregate(node, context);
-	const recordTemplate = createRecordTemplate(node.projections);
-	const selected = dropLiterals(node.projections);
-	const projections = lowerProjections(selected, context);
-	const filters = lowerFilters(node.filters, context);
-	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
-	const { relation } = node;
-	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
-	const page = node.offset !== void 0 && selected.some((field, index) => isPagedField(field, projections[index], orderBy)) ? lowerPage(node, selected, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) : void 0;
-	if (page !== void 0) return page;
-	return Object.freeze({
-		kind: "select",
-		from: node.from,
-		joins: noJoins,
-		projections,
-		filters,
-		orderBy: positions && orderBy.length > 0 ? sortByPositions(orderBy, projections) : orderBy,
-		limit: node.limit,
-		offset: node.offset,
-		rows: node.rows,
-		value: node.value,
-		guaranteedBy,
-		recordTemplate
-	});
-}
-/** Returns the fields of `selected` that a statement selects, or `selected` itself without literals. */
-function dropLiterals(selected) {
-	if (!selected.some(isLiteralSelection)) return selected;
-	const fields = [];
-	for (const field of selected) if (!isLiteralSelection(field)) fields.push(field);
-	return fields;
-}
-/** Creates the template of the records of `selected`: every field in its order with the value of a literal, or `undefined` without literals. */
-function createRecordTemplate(selected) {
-	if (!selected.some(isLiteralSelection)) return;
-	const template = [];
-	for (const field of selected) template.push(Object.freeze({
-		key: field.key,
-		value: isLiteralSelection(field) ? field.literal : void 0
-	}));
-	return template;
-}
-/**
-* Tells whether `field`, a field of a query lowered to `projection`, is a nested query that a page after an offset evaluates only over its rows: one that no sort key of `orderBy`, the lowered order, sorts by.
-*
-* The query evaluates a field that it sorts by, of an aggregate or of `exists`, for every row anyway.
-*/
-function isPagedField(field, projection, orderBy) {
-	if (!isNestedSelection(field)) return false;
-	const { expression } = projection;
-	return !orderBy.some((order) => order.expression === expression);
-}
-/** Rejects a query of a relation outside the definitions of `context`. */
-function checkRelation(node, context) {
-	const { relation } = node;
-	const { definitions } = context;
-	if (relation !== void 0 && definitions !== void 0 && !definitions.has(relation)) throw new Error(`Relation "${formatRelationName(relation.key, relation.name)}" is not part of the schema`);
-}
-/** Rejects a nested query bound to `db`, which the error names as `subject`, unless `db` is the `Db` of `context` or `undefined`. */
-function checkDb(db, context, subject) {
-	if (db !== void 0 && db !== context.db) throw new Error(context.db === void 0 ? `${subject} is bound to a Db, so only that Db can compile the query` : `${subject} is bound to another Db`);
-}
+// src/lowering/page.ts
 /**
-* Lowers `node` with `projections`, `filters`, and `orderBy`, the lowered parts of the node, to a statement that evaluates its nested queries, apart from those that it sorts by, over the rows of a derived page.
-* `queryFields` are the fields of the query without literals, and `projections` their lowered projections in the same order.
-* The derived source applies the filters, the order, the limit, and the offset, and replaces the occurrence of the table.
+* Lowers `query`, the statement of a query on its table that sorts by its sort expressions, to a statement that evaluates its nested queries, apart from those that it sorts by, groups by, or compares, over the rows of a derived page, or returns `undefined` for a query that keeps its page on its table.
+* `queryFields` are the fields of the query without literals, whose lowered projections the statement has in the same order.
+* The derived source applies `DISTINCT ON`, the filters, the keys and the condition of the groups, the order, the limit, and the offset, and replaces the occurrence of the table.
+* It selects each key of `distinctOn` that it does not select otherwise, so that it has a select list, which PostgreSQL requires with `DISTINCT ON`, and evaluates each key once; a key of `groupBy` needs no projection of its own, since it compiles as the position of a projection that has its value or as its expression.
 *
-* It returns `undefined` when a nested query that it evaluates over the rows of the page holds a SQL fragment that refers to a column of the table outside the queries nested in the fragment.
-* Such a fragment may hold an aggregate of the query, which the limit and the offset apply after.
+* A query keeps its page on its table without an offset and `distinctOn`, without nested queries that the page would evaluate over its rows, or when `mayAggregateSource` tells that such a nested query may aggregate the rows of the query, which the limit and the offset apply after.
 *
-* The source selects the columns of the table that the fields and the nested queries of the query read, under their keys, and the other scalar fields of the query, which it evaluates before the limit and the offset as the query would, such as a window function over all its rows.
-* A field of an aggregate or of `exists` that the query sorts by is such a scalar field: the order needs its value for every row.
+* The source selects the columns of the table that the fields and the nested queries of the query read, under their keys, and the other scalar fields of the query, which it evaluates before the limit and the offset as the query would, such as a window function over all its rows or an aggregate of a group.
+* A field of an aggregate or of `exists` that the query sorts by or that is a key is such a scalar field: the order and the keys need its value for every row.
 * A column that no field reads stays out of the source, which could not select it beside an aggregate of a SQL fragment, such as `count(*)`.
 * The order of a derived source does not carry into the query that reads it, so the statement sorts the rows of the page again by the sort keys of the source, by positions when `positions` is set.
 */
-function lowerPage(node, queryFields, projections, filters, orderBy, positions, guaranteedBy, recordTemplate) {
-	const { from } = node;
+function lowerPage(query, queryFields, positions) {
+	const { from, projections, orderBy, groupBy, distinctOn, offset } = query;
+	if (offset === void 0 && distinctOn === void 0 || query.distinct || query.lock !== void 0 || !queryFields.some((field, index) => isPagedField(field, projections[index], orderBy, groupBy, distinctOn))) return;
 	const columnKeys = /* @__PURE__ */ new Set();
 	const fields = [];
 	const fieldKeys = [];
 	for (let index = 0; index < projections.length; index++) {
 		const { expression } = projections[index];
 		let key;
-		if (isPagedField(queryFields[index], projections[index], orderBy)) {
-			if (holdsFragmentOfSource(expression, from)) return;
+		if (isPagedField(queryFields[index], projections[index], orderBy, groupBy, distinctOn)) {
+			if (mayAggregateSource(expression, from)) return;
 			collectColumnKeys(expression, from, columnKeys);
 		} else if (expression.kind === "column" && expression.source === from) columnKeys.add(expression.key);
 		else {
@@ -1780,19 +2430,30 @@ function lowerPage(node, queryFields, projections, filters, orderBy, positions,
 		type: text
 	}));
 	for (const field of fields) sourced.push(field);
+	if (distinctOn !== void 0) for (let index = 0; index < distinctOn.length; index++) {
+		const key = distinctOn[index];
+		if (findValueProjection(sourced, key) === -1) sourced.push(Object.freeze({
+			key: `$key${index + 1}`,
+			expression: key,
+			type: text
+		}));
+	}
 	const page = deriveOrderedSource({
 		kind: "select",
 		from,
 		joins: noJoins,
 		projections: sourced,
-		filters,
+		filters: query.filters,
+		groupBy,
+		having: query.having,
 		orderBy,
-		limit: node.limit,
-		offset: node.offset,
+		limit: query.limit,
+		offset,
+		distinctOn,
 		rows: "many",
 		value: false,
 		guaranteedBy: void 0
-	}, true, node.offset, from);
+	}, true, offset, from);
 	const selected = [];
 	for (let index = 0; index < projections.length; index++) {
 		const projection = projections[index];
@@ -1810,142 +2471,111 @@ function lowerPage(node, queryFields, projections, filters, orderBy, positions,
 	return Object.freeze({
 		kind: "select",
 		from: page.source,
-		joins: noJoins,
-		projections: selected,
-		filters: noFilters,
-		orderBy: positions ? sortByPositions(page.order, selected) : page.order,
-		limit: void 0,
-		offset: void 0,
-		rows: node.rows,
-		value: node.value,
-		guaranteedBy,
-		recordTemplate
-	});
-}
-/** Lowers an aggregate query to a statement of the value of its aggregate over the rows that its filters, limit, and offset choose. */
-function lowerAggregate(node, context) {
-	const field = node.projections[0];
-	const aggregate = field.expression;
-	const orderBy = lowerOrder(node.orderBy, context);
-	let from = node.from;
-	let filters = lowerFilters(node.filters, context);
-	let args = lowerEach(aggregate.arguments, context, lowerExpression);
-	let order = field.ordered ? orderBy : noOrder;
-	const counted = aggregate === countProjection.expression;
-	if (node.limit !== void 0 || node.offset !== void 0 || !counted && !refersToSource(args[0], node.from)) {
-		const projections = [];
-		if (!counted) projections.push(Object.freeze({
-			key: "value",
-			expression: args[0],
-			type: field.type
-		}));
-		const rows = deriveOrderedSource({
-			kind: "select",
-			from: node.from,
-			joins: noJoins,
-			projections,
-			filters,
-			orderBy: counted ? noOrder : orderBy,
-			limit: node.limit,
-			offset: node.offset,
-			rows: "many",
-			value: false,
-			guaranteedBy: void 0
-		}, field.ordered);
-		from = rows.source;
-		filters = noFilters;
-		if (!counted) {
-			const sourceArgs = [createNode({
-				kind: "column",
-				source: from,
-				key: "value"
-			})];
-			for (let index = 1; index < args.length; index++) sourceArgs.push(args[index]);
-			args = sourceArgs;
-		}
-		order = rows.order;
-	}
-	const call = args === aggregate.arguments && order.length === 0 ? aggregate : createNode({
-		kind: "aggregate",
-		name: aggregate.name,
-		distinct: aggregate.distinct,
-		arguments: args,
-		orderBy: order
-	});
-	const fallbacks = lowerEach(field.fallbacks, context, lowerExpression);
-	let value = call;
-	if (fallbacks.length > 0) {
-		const values = [call];
-		for (const fallback of fallbacks) values.push(fallback);
-		value = createList("coalesce(", values, ")");
-	}
-	return Object.freeze({
-		kind: "select",
-		from,
-		joins: noJoins,
-		projections: [value === aggregate ? field : Object.freeze({
-			key: field.key,
-			expression: value,
-			type: field.type
-		})],
-		filters,
-		orderBy: noOrder,
+		joins: noJoins,
+		projections: selected,
+		filters: noFilters,
+		orderBy: positions ? sortByPositions(page.order, selected) : page.order,
 		limit: void 0,
 		offset: void 0,
-		rows: node.rows,
-		value: true,
-		guaranteedBy: void 0
+		rows: query.rows,
+		value: query.value,
+		guaranteedBy: query.guaranteedBy,
+		recordTemplate: query.recordTemplate
 	});
 }
 /**
-* Tells whether `node` refers to `source` outside the queries nested in it.
+* Tells whether `field`, a field of a query lowered to `projection`, is a nested query that a derived page evaluates only over its rows: one that no sort key of `orderBy`, the lowered order, sorts by, and that is none of `groupBy` and `distinctOn`, the lowered keys of the query.
 *
-* A reference inside a nested query is not counted, so an argument that refers to the source only there is read from a derived source, which is correct either way.
+* The query evaluates a field that it sorts by, groups by, or compares, of an aggregate or of `exists`, for every row anyway.
 */
-function refersToSource(node, source) {
+function isPagedField(field, projection, orderBy, groupBy, distinctOn) {
+	if (!isNestedSelection(field)) return false;
+	const { expression } = projection;
+	return !orderBy.some((order) => order.expression === expression) && (groupBy === void 0 || !groupBy.includes(expression)) && (distinctOn === void 0 || !distinctOn.includes(expression));
+}
+// src/lowering/lower.ts
+function lowerStatement(node, definitions, db) {
+	const context = createContext(definitions, db);
 	switch (node.kind) {
-		case "column": return node.source === source;
-		case "param":
-		case "boolean":
-		case "values":
-		case "nestedQuery":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery": return false;
-		case "cast":
-		case "not":
-		case "isNull":
-		case "inQuery": return refersToSource(node.operand, source);
-		case "and":
-		case "or": return node.operands.some((operand) => refersToSource(operand, source));
-		case "comparison": return refersToSource(node.left, source) || refersToSource(node.right, source);
-		case "in": return refersToSource(node.operand, source) || node.list.some((item) => refersToSource(item, source));
-		case "raw": return node.values.some((value) => refersToSource(value, source));
-		case "aggregate": return node.arguments.some((argument) => refersToSource(argument, source));
-		default: return node;
+		case "query": return lowerSelect(node, context, true);
+		case "record": return lowerRecord(node, context);
+		case "text": return lowerText(node, context);
+		default: return lowerMutation(node, context);
 	}
 }
-/** Lowers a query of `exists` to `EXISTS` of the rows that its filters, limit, and offset choose. */
-function lowerExists(node, context) {
-	checkRelation(node, context);
-	return createNode({
-		kind: "exists",
-		query: Object.freeze({
-			kind: "select",
-			from: node.from,
-			joins: noJoins,
-			projections: noProjections,
-			filters: lowerFilters(node.filters, context),
-			orderBy: noOrder,
-			limit: node.limit,
-			offset: node.offset,
-			rows: "many",
-			value: false,
-			guaranteedBy: void 0
-		})
+/** Creates the context of lowering a statement with `definitions` and `db`, whose nested queries `lowerSelect` lowers. */
+function createContext(definitions, db) {
+	const context = {
+		definitions,
+		db,
+		lowerSelect: (node, positions) => lowerSelect(node, context, positions),
+		lowerExists: (node) => lowerExists(node, context)
+	};
+	return context;
+}
+/** Lowers a statement of SQL text, replacing the queries in the expressions interpolated into it. */
+function lowerText(node, context) {
+	const sql = lowerExpression(node.sql, context);
+	if (sql === node.sql) return node;
+	return Object.freeze({
+		kind: "text",
+		sql,
+		fields: node.fields,
+		rows: node.rows,
+		value: node.value
+	});
+}
+/** Lowers a query as `lowerQuery` does, or as `lowerStatement` does when `positions` is set, with the conversion of its result. */
+function lowerSelect(node, context, positions) {
+	const statement = lowerSelectStatement(node, context, positions);
+	const { conversion } = node;
+	return conversion === void 0 ? statement : Object.freeze({
+		...statement,
+		conversion
 	});
 }
+/** Lowers a query to its statement, whichever it is: of `exists`, of an aggregate, of a page that evaluates its nested queries only over its rows, or of the rows of its source. */
+function lowerSelectStatement(node, context, positions) {
+	if (isExistsQuery(node)) return selectExists(node, context);
+	checkRelation(node, context);
+	if (isAggregateQuery(node)) return lowerAggregate(node, context);
+	const recordTemplate = createRecordTemplate(node.projections);
+	const selected = dropLiterals(node.projections);
+	const projections = lowerProjections(selected, context);
+	if (node.groupBy.length > 0) checkGroupAggregates(projections, node);
+	const filters = lowerFilters(node.filters, context);
+	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
+	const groupBy = lowerKeys(node.groupBy, context, selected, projections);
+	const having = lowerValue(node.having, context);
+	const distinctOn = lowerKeys(node.distinctOn, context, selected, projections);
+	if (node.distinct) checkDistinct(projections, orderBy);
+	if (distinctOn !== void 0) checkDistinctOn(projections, distinctOn, orderBy);
+	const { relation } = node;
+	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
+	const statement = {
+		kind: "select",
+		from: node.from,
+		joins: noJoins,
+		projections,
+		filters,
+		groupBy,
+		having,
+		orderBy,
+		limit: node.limit,
+		offset: node.offset,
+		distinct: node.distinct,
+		distinctOn,
+		lock: node.lock,
+		rows: node.rows,
+		value: node.value,
+		guaranteedBy,
+		recordTemplate
+	};
+	const page = lowerPage(statement, selected, positions);
+	if (page !== void 0) return page;
+	if (positions && orderBy.length > 0) statement.orderBy = sortByPositions(orderBy, projections);
+	return Object.freeze(statement);
+}
 /** Lowers a query of `exists` to a statement without a source of one row of `EXISTS` of its rows. */
 function selectExists(node, context) {
 	return Object.freeze({
@@ -1962,14 +2592,6 @@ function selectExists(node, context) {
 		guaranteedBy: void 0
 	});
 }
-/** Creates the projection of `EXISTS` of the rows of `node`, a query of `exists`, under `key`, decoded by the type of the projection of `exists`. */
-function projectExists(key, node, context) {
-	return Object.freeze({
-		key,
-		expression: lowerExists(node, context),
-		type: node.projections[0].type
-	});
-}
 /** Lowers a query of `$select` to a statement without a source, which returns one row of its fields. */
 function lowerRecord(node, context) {
 	return Object.freeze({
@@ -1987,236 +2609,433 @@ function lowerRecord(node, context) {
 		recordTemplate: createRecordTemplate(node.projections)
 	});
 }
+// src/query/kind.ts
+/** `then` of every bound query, which executes the query on its `Db`. */
+function executeOnAwait(onFulfilled, onRejected) {
+	return this.db.$execute(this).then(onFulfilled, onRejected);
+}
+/** Compiles `query` as its `toSQL` does: an unbound query with `options`, and a bound query as its `Db` executes it, which takes no options. */
+function compileToSQL(query, options) {
+	const { db } = query;
+	if (db === void 0) {
+		const { text, parameters } = compileStatement(lowerStatement(query.node), options);
+		return createStatement(text, parameters);
+	}
+	if (options !== void 0) throw new Error("A query bound to a Db compiles with the options of its Db");
+	return db.$compile(query);
+}
+// src/query/conversion.ts
+/**
+* Immutable query of a table of state `S` whose whole result `transform` converts after decoding, unbound or bound to a `Db`.
+*
+* It executes and nests in a selection as the query it comes from, with the same SQL, so it has only `transform`, which converts the result further: another method would change what the callback receives, and an expression does not take it, since SQL does not see the conversion.
+* An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
+* A bound query executes on its `Db` when awaited.
+*/
+var TransformedQuery = class {
+	node;
+	/** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+	db;
+	/** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+	then;
+	constructor(node, db) {
+		this.node = node;
+		this.db = db;
+		this.then = db === void 0 ? void 0 : executeOnAwait;
+		Object.freeze(this);
+	}
+	transform(callback) {
+		return transformQuery(this.node, this.db, callback);
+	}
+	toSQL(options) {
+		return compileToSQL(this, options);
+	}
+	/** Rejects the query as an operand of an expression, whose value SQL reads without its conversion. */
+	[operandNode]() {
+		throw new TypeError("An expression takes a query of one value of a table, such as of get, an aggregate, or exists, not a query of transform");
+	}
+};
+/** Creates the query of `transform` of `node`, a query of a table bound to `db` when given, whose whole result `callback` converts after the earlier conversions. */
+function transformQuery(node, db, callback) {
+	return new TransformedQuery(Object.freeze({
+		...node,
+		conversion: addTransform(node.conversion, callback),
+		foundKey: void 0
+	}), db);
+}
+/**
+* Returns `conversion` of a query with `callback` of `map` after its earlier one.
+*
+* It rejects a conversion of `transform`, whose result has no rows to convert.
+*/
+function addMap(conversion, callback) {
+	if (conversion?.transform !== void 0) throw new Error("map cannot be used after transform; convert the rows in its callback instead");
+	return Object.freeze({
+		map: chainConversions(conversion?.map, createConversion(callback, "map")),
+		transform: void 0
+	});
+}
+/** Returns `conversion` of a query with `callback` of `transform` after its earlier one. */
+function addTransform(conversion, callback) {
+	return Object.freeze({
+		map: conversion?.map,
+		transform: chainConversions(conversion?.transform, createConversion(callback, "transform"))
+	});
+}
+/** Returns the conversion that applies `next` after `previous`, if any. */
+function chainConversions(previous, next) {
+	return previous === void 0 ? next : (value) => next(previous(value));
+}
+/**
+* Creates the conversion of `callback` of `method`, which rejects a Promise or another thenable returned by the callback: `SynchronousResult` rejects it in types, and a callback may still return one through `any`.
+*
+* It rejects a `callback` that is not a function when it is called, since decoding calls it long after, where its error would read as a failure of a row.
+*/
+function createConversion(callback, method) {
+	if (typeof callback !== "function") throw new TypeError(`${method} takes a callback`);
+	return (value) => {
+		const result = callback(value);
+		if (typeof result?.then === "function") {
+			if (types.isPromise(result)) result.catch(ignoreRejection);
+			throw new TypeError(`The callback of ${method} must return its result synchronously, not a Promise or a query`);
+		}
+		return result;
+	};
+}
+/** Handles the rejection of a Promise that a callback returned, whose query has failed already. */
+function ignoreRejection() {}
+// src/query/resolve-values.ts
+/**
+* Replaces objects of column values in a predicate with conditions on the columns of `source`.
+*
+* Groups are rebuilt, so constants that appear after resolution, such as an empty object, are simplified.
+*/
+function resolveValues(node, source) {
+	switch (node.kind) {
+		case "values": {
+			const conditions = [];
+			for (const key of Object.keys(node.values)) conditions.push(matchColumn(source, key, node.values[key]));
+			return combineNodes("and", conditions);
+		}
+		case "and":
+		case "or": {
+			const operands = [];
+			for (const operand of node.operands) operands.push(resolveValues(operand, source));
+			return combineNodes(node.kind, operands);
+		}
+		case "not": return negateNode(resolveValues(node.operand, source));
+		case "raw": return createNode({
+			...node,
+			values: node.values.map((value) => resolveValues(value, source))
+		});
+		default: return node;
+	}
+}
+/** Creates the condition of column `key` of `source` in an object of column values: `IS NULL` of `null`, or the `eq` operator of its type for another value. */
+function matchColumn(source, key, value) {
+	const type = findColumn(source.table, key)?.type;
+	const column = createNode({
+		kind: "column",
+		source,
+		key
+	});
+	if (value === null) return createIsNullNode(column);
+	if (type) return matchValue(source, column, type, value);
+	return compareNodes("=", column, value, void 0);
+}
+/** Matches a column with a value of an object condition by calling the `eq` operator of its type, whichever operator it is. */
+function matchValue(source, column, type, value) {
+	const expression = toExpression(column, type);
+	if (typeof expression.eq !== "function") throw new TypeError(`Column "${column.key}" of table "${source.table.name}" has no eq operator; an object condition can only match it with null`);
+	const predicate = expression.eq(value);
+	if (!isExpression(predicate)) throw new TypeError(`The eq operator of column "${column.key}" of table "${source.table.name}" must return an expression`);
+	return toNode(predicate);
+}
+// src/query/filters.ts
+/** Creates query filters with the filter of `where` over `source` with the relations of `context` combined with `AND` with the user filters of `filters`. */
+function addUserFilter(filters, filter, source, context) {
+	const predicate = toFilterNode(filter, source, context);
+	const { user } = filters;
+	return Object.freeze({
+		...filters,
+		user: user ? combineNodes("and", [user, predicate]) : predicate
+	});
+}
+/**
+* Converts a filter of `where` or `having` over `source` with the relations of `context` into the node of its condition, whose objects of column values it resolves.
+*
+* A callback receives the columns with the relations, and what `readSelected` returns, such as the selected fields for `having`.
+*/
+function toFilterNode(filter, source, context, readSelected) {
+	return resolveValues(toConditionNode(typeof filter === "function" ? filter(createSelectionRefs(source, context), readSelected?.()) : filter), source);
+}
+// src/query/find.ts
+/**
+* Returns the object of column values that `find` filters a query of `table` by: `values` of the columns of its primary key, in their order.
+*
+* It rejects a table without a primary key, a number of values other than the number of its columns, and `null` and `undefined`.
+*/
+function toPrimaryKeyValues(table, values) {
+	const { primaryKey } = table.keys;
+	if (primaryKey === void 0) throw new Error(`find takes the values of a primary key, which table "${table.name}" does not have; use findBy with a unique key`);
+	if (values.length !== primaryKey.length) throw new Error(`find takes one value for each column of the primary key of table "${table.name}", ${quoteColumns(primaryKey)}, not ${values.length}`);
+	const filter = {};
+	for (let index = 0; index < primaryKey.length; index++) {
+		const column = primaryKey[index];
+		filter[column] = requireKeyValue(table, column, values[index], "find");
+	}
+	return filter;
+}
+/**
+* Returns the object of column values that `findBy` filters a query of `table` by: a copy of `values`, read once.
+*
+* It rejects columns that are not exactly a key of `table`, primary or unique, as `isKey` tells, and `null` and `undefined`.
+*/
+function toKeyValues(table, values) {
+	if (typeof values !== "object" || values === null) throw new TypeError(`findBy takes an object of the columns of a key of table "${table.name}"`);
+	const columns = Object.keys(values);
+	if (!isKey(table, columns)) {
+		const listed = columns.length === 0 ? "an object without columns" : `columns ${quoteColumns(columns)}`;
+		throw new Error(`findBy takes the columns of one key of table "${table.name}", primary or unique, not ${listed}`);
+	}
+	const filter = {};
+	for (const column of columns) {
+		const value = values[column];
+		filter[column] = requireKeyValue(table, column, value, "findBy");
+	}
+	return filter;
+}
 /**
-* Lowers the fields of a query to projections, packing the rows of each nested query into the value of its field, or selecting the value of an aggregate query or `EXISTS` of a query of `exists`, and replacing the queries in the expressions of the other fields; checks them as `lowerQuery` does.
+* Returns the target of `onConflict` of `columns`: the key of `table` of exactly these columns, primary or unique, in the order of the key, or none for a conflict on any key when there are no columns.
 *
-* Without queries, it returns `selected` itself.
+* It rejects columns that are not exactly a key of `table`, as `isKey` tells.
 */
-function lowerProjections(selected, context) {
-	let lowered;
-	for (let index = 0; index < selected.length; index++) {
-		const field = selected[index];
-		let projection;
-		if (isNestedSelection(field)) {
-			checkDb(field.db, context, `Selected field "${field.key}"`);
-			projection = projectQuery(field.key, field.query, context);
-		} else {
-			const expression = lowerExpression(field.expression, context);
-			projection = expression === field.expression ? field : Object.freeze({
-				key: field.key,
-				expression,
-				type: field.type
-			});
-		}
-		if (lowered !== void 0) lowered.push(projection);
-		else if (projection !== field) {
-			lowered = selected.slice(0, index);
-			lowered.push(projection);
-		}
-	}
-	return lowered ?? selected;
+function toConflictTarget(table, columns) {
+	if (columns.length === 0) return noColumns;
+	const key = findKey(table, columns);
+	if (key === void 0) throw new Error(`onConflict takes the columns of one key of table "${table.name}", primary or unique, or none for any key, not columns ${quoteColumns(columns)}`);
+	return key;
 }
-/** Creates the projection of the value of `node`, a nested query, under `key`: `EXISTS` of a query of `exists`, the value of an aggregate query, or the packed rows of another query. */
-function projectQuery(key, node, context) {
-	if (isExistsQuery(node)) return projectExists(key, node, context);
-	const query = lowerSelect(node, context, false);
-	return isAggregateQuery(node) ? projectAggregateValue(key, query) : projectRows(key, query);
+/** Columns of the target of a conflict on any key. */
+const noColumns = /* @__PURE__ */ Object.freeze([]);
+/** Returns `value` of column `column` of a key of `table` that `method` takes, rejecting `null` and `undefined`. */
+function requireKeyValue(table, column, value, method) {
+	if (value === null || value === void 0) throw new TypeError(`${method} got ${value} for column "${column}" of table "${table.name}"; a value of a key is never null or undefined`);
+	return value;
 }
-/** Creates the projection of the value of `query`, the statement of an aggregate query, under `key`, selected as a scalar subquery and decoded by the type of the aggregate. */
-function projectAggregateValue(key, query) {
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "subquery",
-			query
-		}),
-		type: query.projections[0].type
-	});
+/** Lists `columns` in quotes, separated by commas. */
+function quoteColumns(columns) {
+	return columns.map((column) => `"${column}"`).join(", ");
 }
-/** Lowers the filters of a query, replacing the queries in their expressions; without queries, it returns `filters` itself. */
-function lowerFilters(filters, context) {
-	const { relation, scope, user } = filters;
-	const loweredRelation = relation === void 0 ? void 0 : lowerExpression(relation, context);
-	const loweredScope = scope === void 0 ? void 0 : lowerExpression(scope, context);
-	const loweredUser = user === void 0 ? void 0 : lowerExpression(user, context);
-	if (loweredRelation === relation && loweredScope === scope && loweredUser === user) return filters;
-	const lowered = {};
-	if (loweredRelation !== void 0) lowered.relation = loweredRelation;
-	if (loweredScope !== void 0) lowered.scope = loweredScope;
-	if (loweredUser !== void 0) lowered.user = loweredUser;
-	return Object.freeze(lowered);
+// src/query/order.ts
+/** Direction and placement of `NULL` of a sort key node, by `OrderDirection`. */
+const directions = /* @__PURE__ */ Object.freeze({
+	asc: {
+		direction: "asc",
+		nulls: void 0
+	},
+	desc: {
+		direction: "desc",
+		nulls: void 0
+	},
+	"asc nulls first": {
+		direction: "asc",
+		nulls: "first"
+	},
+	"asc nulls last": {
+		direction: "asc",
+		nulls: "last"
+	},
+	"desc nulls first": {
+		direction: "desc",
+		nulls: "first"
+	},
+	"desc nulls last": {
+		direction: "desc",
+		nulls: "last"
+	}
+});
+const orderingNode = Symbol("kern-orm.ordering.node");
+/** Runtime class of an expression with a direction, which holds its sort key node. */
+var OrderingObject = class {
+	[orderingNode];
+	constructor(node) {
+		this[orderingNode] = node;
+		Object.freeze(this);
+	}
+};
+/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
+function asc(value) {
+	return orderBy(value, "asc");
+}
+/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
+function desc(value) {
+	return orderBy(value, "desc");
+}
+/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
+function orderBy(value, direction) {
+	if (!isOperandSource(value)) throw new TypeError("A sort key must be an expression or a query of one value");
+	return new OrderingObject(createOrderNode(value[operandNode](), direction));
 }
 /**
-* Lowers the sort keys of a query, replacing the queries in their expressions; without queries, it returns `orderBy` itself.
+* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
 *
-* A sort key of a field of `selected`, the fields of the query, takes the expression of its projection among `projections`, the lowered fields, so that the statement still finds the projection that has its value.
-* A field of an aggregate or of `exists` is identified by the node of its reference, which holds the field.
+* `args` are column keys and objects of columns with directions, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one sort key or an array of them.
 */
-function lowerOrder(orderBy, context, selected, projections) {
-	let lowered;
-	for (let index = 0; index < orderBy.length; index++) {
-		const order = orderBy[index];
-		const { expression } = order;
-		const position = selected === void 0 || projections === void 0 || projections === selected ? -1 : selected.findIndex((field) => isFieldValue(field, expression));
-		const sorted = position === -1 ? lowerExpression(expression, context) : projections[position].expression;
-		if (lowered === void 0 && sorted === expression) continue;
-		lowered ??= orderBy.slice(0, index);
-		lowered.push(sorted === expression ? order : Object.freeze({
-			expression: sorted,
-			direction: order.direction,
-			nulls: order.nulls
-		}));
+function addOrder(node, context, args) {
+	const order = node.orderBy.slice();
+	const first = args[0];
+	if (typeof first === "function") {
+		addTerms(order, first(createSelectionRefs(node.from, context), createSelectedRefs(node, "sorted by")), "The callback of orderBy must return");
+		return order;
 	}
-	return lowered ?? orderBy;
+	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
+	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+		const columns = arg;
+		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
+	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
+	return order;
 }
-/** Tells whether the sort expression `expression` is the value of `field`: its expression, or for a field of an aggregate or of `exists`, the node of its reference in the callback of `orderBy`. */
-function isFieldValue(field, expression) {
-	return isNestedSelection(field) ? expression.kind === "nestedQuery" && expression.field === field : field.expression === expression;
+/** Adds to `order` the sort key nodes of `terms`, `OrderTerms` checked at runtime; `subject` starts the error of another value, such as `The callback of orderBy must return`. */
+function addTerms(order, terms, subject) {
+	if (Array.isArray(terms)) for (const term of terms) order.push(readTerm$1(term, subject));
+	else order.push(readTerm$1(terms, subject));
 }
 /**
-* Lowers an expression, replacing each query in it and checking the query as a nested query.
-* A query of `exists`, such as in a condition, becomes `EXISTS` of its rows, another query of one value a scalar subquery of its value, the query of the values of `IN` its statement, and another query in SQL text its statement in parentheses.
+* Creates the sort key node of a sort key, `OrderTerm` checked at runtime, whose error starts with `subject`.
 *
-* It returns `node` itself when it holds no query, and creates only the nodes that hold one.
+* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
 */
-function lowerExpression(node, context) {
-	switch (node.kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "values":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery": return node;
-		case "nestedQuery": return lowerNestedQuery(node, context);
-		case "cast": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "cast",
-				operand,
-				type: node.type
-			});
-		}
-		case "not": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "not",
-				operand
-			});
-		}
-		case "isNull": {
-			const operand = lowerExpression(node.operand, context);
-			return operand === node.operand ? node : createNode({
-				kind: "isNull",
-				operand
-			});
-		}
-		case "and":
-		case "or": {
-			const operands = lowerEach(node.operands, context, lowerExpression);
-			return operands === node.operands ? node : createNode({
-				kind: node.kind,
-				operands
-			});
-		}
-		case "comparison": {
-			const left = lowerExpression(node.left, context);
-			const right = lowerExpression(node.right, context);
-			return left === node.left && right === node.right ? node : createNode({
-				kind: "comparison",
-				operator: node.operator,
-				left,
-				right
-			});
-		}
-		case "in": {
-			const operand = lowerExpression(node.operand, context);
-			const list = lowerEach(node.list, context, lowerExpression);
-			return operand === node.operand && list === node.list ? node : createNode({
-				kind: "in",
-				operand,
-				list
-			});
-		}
-		case "inQuery": {
-			const operand = lowerExpression(node.operand, context);
-			const query = node.query.kind === "nestedQuery" ? lowerQueryOfValues(node.query, context) : node.query;
-			return operand === node.operand && query === node.query ? node : createNode({
-				kind: "inQuery",
-				operand,
-				query
-			});
-		}
-		case "raw": {
-			const values = lowerEach(node.values, context, lowerExpression);
-			return values === node.values ? node : createNode({
-				kind: "raw",
-				fragments: node.fragments,
-				values
-			});
-		}
-		case "aggregate": {
-			const args = lowerEach(node.arguments, context, lowerExpression);
-			const orderBy = lowerOrder(node.orderBy, context);
-			return args === node.arguments && orderBy === node.orderBy ? node : createNode({
-				kind: "aggregate",
-				name: node.name,
-				distinct: node.distinct,
-				arguments: args,
-				orderBy
+function readTerm$1(term, subject) {
+	if (term instanceof OrderingObject) return term[orderingNode];
+	if (isOperandSource(term)) return createOrderNode(term[operandNode](), "asc");
+	throw new TypeError(`${subject} expressions, queries of one value, or sort keys of asc, desc, and orderBy`);
+}
+/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
+function createOrderNode(expression, direction) {
+	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
+	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
+	return Object.freeze({
+		expression,
+		direction: placement.direction,
+		nulls: placement.nulls
+	});
+}
+/** Creates a reference to the column `key` of the table of `source`. */
+function createColumnNode(source, key) {
+	requireColumn(source.table, key);
+	return createNode({
+		kind: "column",
+		source,
+		key
+	});
+}
+/**
+* Creates the references of the callback of `orderBy`, `groupBy`, `distinctOn`, or `having` to the fields selected by `node`; `purpose` completes the error of a field that cannot be read, such as `sorted by`.
+*
+* Each is an expression over the node of its projection, so that a sort key or a key of a group of it is the projection itself; `HAVING` compiles the expression again, since it cannot refer to a projection.
+* A field of an aggregate or of `exists` is an expression of its query that holds the field, by which lowering finds the projection of the field.
+*/
+function createSelectedRefs(node, purpose) {
+	const { projections } = node;
+	if (node.value) return toSelectedExpression(projections[0]);
+	const refs = {};
+	for (const projection of projections) {
+		const { key } = projection;
+		if (isLiteralSelection(projection)) Object.defineProperty(refs, key, {
+			get() {
+				throw new Error(`Field "${key}" holds a literal and cannot be ${purpose}`);
+			},
+			enumerable: true
+		});
+		else if (isNestedSelection(projection)) {
+			if (isSelectedAsValue(projection.query)) refs[key] = toQueryExpression(projection);
+			else Object.defineProperty(refs, key, {
+				get() {
+					throw new Error(`Field "${key}" holds nested rows and cannot be ${purpose}`);
+				},
+				enumerable: true
 			});
-		}
-		default: return node;
+		} else refs[key] = toSelectedExpression(projection);
 	}
+	return refs;
+}
+/** Creates an expression over the node of a projection of a query, which has a type: only lowering adds projections of nested queries. */
+function toSelectedExpression(projection) {
+	return toExpression(projection.expression, projection.type);
+}
+/** Creates an expression of the value of `field`, a selected aggregate query or query of `exists`, with the type of its value. */
+function toQueryExpression(field) {
+	const { query } = field;
+	return toExpression(createNode({
+		kind: "nestedQuery",
+		query,
+		db: field.db,
+		field
+	}), query.projections[0].type);
 }
+// src/query/group.ts
+/** Method that takes the keys of groups, and the phrase of what it does with a field that cannot be a key, for its errors. */
+const keyMethods = {
+	groupBy: "grouped by",
+	distinctOn: "a key of distinctOn"
+};
 /**
-* Lowers a query in an expression to `EXISTS` of the rows of a query of `exists`, to a scalar subquery of the value of another query of one value, or to its statement in parentheses for a query of records or of rows `many`, which only SQL text holds.
+* Creates the keys of `method`, `groupBy` or `distinctOn`, of `node` with the keys of the arguments of the call after its own.
 *
-* In SQL text, a query of `exists` stays `EXISTS` rather than a subquery of its value, so that PostgreSQL can join its rows in a condition, as a semi-join.
+* `args` are column keys, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one key or an array of them.
+* A string names a column, never a selected field, whose key names only the field of a record.
+* It rejects a call without keys, which would leave the rows of a query ungrouped, or keep all of them, when a list built in code is empty.
 */
-function lowerNestedQuery(node, context) {
-	checkDb(node.db, context, "A query in an expression");
-	const { query } = node;
-	if (isExistsQuery(query)) return lowerExists(query, context);
-	return createNode({
-		kind: query.value && query.rows !== "many" ? "subquery" : "textSubquery",
-		query: lowerSelect(query, context, false)
-	});
-}
-/** Lowers the query of the values of `IN` to its statement, whatever its rows. */
-function lowerQueryOfValues(node, context) {
-	checkDb(node.db, context, "A query in an expression");
-	return lowerSelect(node.query, context, false);
-}
-/** Lowers each of `items` with `lower`; when none changes, it returns `items` itself. */
-function lowerEach(items, context, lower) {
-	let lowered;
-	for (let index = 0; index < items.length; index++) {
-		const item = items[index];
-		const result = lower(item, context);
-		if (lowered !== void 0) lowered.push(result);
-		else if (result !== item) {
-			lowered = items.slice(0, index);
-			lowered.push(result);
-		}
+function addGroupKeys(method, node, context, args) {
+	const existing = node[method];
+	const keys = existing.slice();
+	const first = args[0];
+	if (typeof first === "function") {
+		const terms = first(createSelectionRefs(node.from, context), createSelectedRefs(node, keyMethods[method]));
+		if (Array.isArray(terms)) for (const term of terms) keys.push(readTerm(term, method));
+		else keys.push(readTerm(terms, method));
+	} else for (const arg of args) {
+		if (typeof arg !== "string") throw new TypeError(`${method} takes column keys or a callback`);
+		keys.push(createColumnNode(node.from, arg));
 	}
-	return lowered ?? items;
+	if (keys.length === existing.length) throw new TypeError(`${method} requires at least one key`);
+	return keys;
 }
-// src/query/kind.ts
-/** `then` of every bound query, which executes the query on its `Db`. */
-function executeOnAwait(onFulfilled, onRejected) {
-	return this.db.$execute(this).then(onFulfilled, onRejected);
+/**
+* Creates the condition of the groups of `node` with `filter`, what `where` takes, combined with `AND` with its earlier condition.
+*
+* A callback also receives the fields selected so far, as `HavingFields` tells, so that a condition reads an aggregate or a key of an expression by its field.
+* The condition stands apart from the filters of the rows, so it requires keys: without them, `having` would read as a filter of rows while PostgreSQL takes the whole query for one group.
+*/
+function addHaving(node, filter, context) {
+	if (node.groupBy.length === 0) throw new Error("having requires an earlier groupBy; filter the rows with where");
+	const predicate = toFilterNode(filter, node.from, context, () => node.conversion !== void 0 || isAggregateQuery(node) || isExistsQuery(node) ? void 0 : createSelectedRefs(node, "read in having"));
+	return node.having === void 0 ? predicate : combineNodes("and", [node.having, predicate]);
 }
-/** Compiles `query` as its `toSQL` does: an unbound query with `options`, and a bound query as its `Db` executes it, which takes no options. */
-function compileToSQL(query, options) {
-	const { db } = query;
-	if (db === void 0) {
-		const { text, parameters } = compileStatement(lowerStatement(query.node), options);
-		return createStatement(text, parameters);
-	}
-	if (options !== void 0) throw new Error("A query bound to a Db compiles with the options of its Db");
-	return db.$compile(query);
+/**
+* Creates the node of a key returned by the callback of `method`.
+*
+* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
+*/
+function readTerm(term, method) {
+	if (isOperandSource(term)) return term[operandNode]();
+	throw new TypeError(`The callback of ${method} must return expressions or queries of one value`);
+}
+// src/query/lock.ts
+/** Creates the row lock of `strength` for `method`, rejecting a query whose rows it cannot lock and options that contradict each other. */
+function createRowLock(node, method, strength, options = {}) {
+	if (isAggregateQuery(node)) throw new Error(`${method} cannot be used after an aggregate`);
+	if (isExistsQuery(node)) throw new Error(`${method} cannot be used after exists`);
+	if (node.distinct) throw new Error(`${method} cannot be used after distinct, since a row without duplicates comes from several rows of the table`);
+	if (node.distinctOn.length > 0) throw new Error(`${method} cannot be used after distinctOn; PostgreSQL does not allow row locks with DISTINCT ON`);
+	if (node.groupBy.length > 0) throw new Error(`${method} cannot be used after groupBy, since a group comes from several rows of the table`);
+	const { noWait, skipLocked } = options;
+	if (noWait && skipLocked) throw new Error(`${method} takes either noWait or skipLocked, not both`);
+	return Object.freeze({
+		strength,
+		onLocked: noWait ? "NOWAIT" : skipLocked ? "SKIP LOCKED" : void 0
+	});
 }
 // src/query/record.ts
 /**
@@ -2422,7 +3241,7 @@ function selectValue(key, value) {
 		key,
 		literal: value.literal
 	});
-	if (value instanceof SelectQuery) return Object.freeze({
+	if (value instanceof SelectQuery || value instanceof TransformedQuery) return Object.freeze({
 		key,
 		query: value.node,
 		db: value.db
@@ -2501,14 +3320,14 @@ function toInsertRows(table, records, method) {
 	};
 }
 /**
-* Returns the assignments of an update of the rows of `source` that `set` gives: the values of its columns, or a callback that receives the references of `source` with the relations of `context` and returns them, read when it is called.
+* Returns the assignments of an update of the rows of `source` that `set` gives: the values of its columns, or a callback that receives the references of `source` with the relations of `context`, and those of `excluded` for `DO UPDATE` of a conflict, and returns them, read when it is called.
 *
 * A value of `undefined` keeps its column, and an update must set at least one column.
 * It rejects a key that is not a column of the table of `source`, and a query other than of one value.
 */
-function toAssignments(source, set, context) {
+function toAssignments(source, set, context, excluded) {
 	const { table } = source;
-	const values = typeof set === "function" ? set(createSelectionRefs(source, context)) : set;
+	const values = typeof set !== "function" ? set : excluded === void 0 ? set(createSelectionRefs(source, context)) : set(createSelectionRefs(source, context), createSelectionRefs(excluded, noContext));
 	if (typeof values !== "object" || values === null) throw new TypeError(`update takes the values of the columns of table "${table.name}" or a callback that returns them`);
 	const assignments = [];
 	for (const key of Object.keys(values)) {
@@ -2529,7 +3348,7 @@ function resolveValue(table, key, value) {
 /**
 * Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
 *
-* Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
+* Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead, and `map` and `transform` convert them in code.
 * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
 * A bound query executes on its `Db` when awaited.
 */
@@ -2550,6 +3369,7 @@ var MutationQuery = class MutationQuery {
 		Object.freeze(this);
 	}
 	select(...args) {
+		this.rejectConverted("select");
 		const { node } = this;
 		const { returning } = node;
 		if (returning !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
@@ -2565,6 +3385,25 @@ var MutationQuery = class MutationQuery {
 	pluck(arg) {
 		return this.deriveValue(arg, "pluck");
 	}
+	map(callback) {
+		const { node } = this;
+		if (node.returning === void 0) throw new Error("map applies only to a mutation that returns the fields of its rows; select them before map, or call transform to convert the number of the rows");
+		return this.derive({ conversion: addMap(node.conversion, callback) });
+	}
+	transform(callback) {
+		return this.derive({ conversion: addTransform(this.node.conversion, callback) });
+	}
+	use(callback, ...args) {
+		const result = requireDerived(this, callback(this, ...args), "The callback of use");
+		if (this.node.returning === void 0 && result.node.returning?.length === 0) throw new Error("The callback of use must select at least one field, or not call select to return the number of the rows");
+		return result;
+	}
+	onConflict(...columns) {
+		const { node } = this;
+		if (node.kind !== "insert") throw new Error("onConflict applies only to insert and insertMany");
+		if (node.returning !== void 0 || node.conversion !== void 0 || node.conflict !== void 0) throw new Error("onConflict applies right after insert or insertMany, once; call select, get, pluck, map, and transform after its action");
+		return new ConflictTarget(this, toConflictTarget(this.table, columns));
+	}
 	toSQL(options) {
 		return compileToSQL(this, options);
 	}
@@ -2581,6 +3420,7 @@ var MutationQuery = class MutationQuery {
 	}
 	/** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and the relations and returns an expression or a query of one value, of each changed row. */
 	deriveValue(arg, method) {
+		this.rejectConverted(method);
 		const { node } = this;
 		return this.derive({
 			returning: [projectValue(node.target, arg, method, this.context)],
@@ -2588,15 +3428,155 @@ var MutationQuery = class MutationQuery {
 			rows: toValueRows(node.rows)
 		});
 	}
+	/** Rejects `method`, which changes the fields that the mutation returns, on a mutation that `map` or `transform` converts. */
+	rejectConverted(method) {
+		if (this.node.conversion !== void 0) throw new Error(`${method} cannot be used after map or transform; call it before them`);
+	}
+};
+/**
+* Conflict target of an insert of state `S` on the key of columns `K`, or without columns for `never`, with methods that choose the action and return the mutation: without columns, `doNothing` takes any key, and `merge` and `update` the row of a singleton table.
+*
+* It is no query: awaiting it is a type error and rejects, so that an insert without an action does not resolve without running.
+*/
+var ConflictTarget = class {
+	insert;
+	target;
+	constructor(insert, target) {
+		this.insert = insert;
+		this.target = target;
+		Object.freeze(this);
+	}
+	doNothing() {
+		const rows = this.insert.node.rows;
+		return this.derive(Object.freeze({ target: this.target }), rows === "one" ? "optional" : rows);
+	}
+	merge(...columns) {
+		const { insert } = this;
+		const target = this.target;
+		const updateTarget = toUpdateTarget(insert.table, target, "merge");
+		const node = this.insertNode();
+		const merged = columns.length === 0 ? node.columns.filter((key) => !target.includes(key)) : columns;
+		if (merged.length === 0) throw new Error("merge has no column to set, since the insert gives no column apart from the key of onConflict; use doNothing");
+		const excluded = createExcluded(insert.table);
+		const set = [];
+		for (const key of merged) {
+			requireColumn(insert.table, key);
+			if (target.includes(key)) throw new Error(`merge cannot set "${key}", a column of the key of onConflict`);
+			if (set.some((assignment) => assignment.key === key)) throw new Error(`merge takes each column once, not "${key}" twice`);
+			const index = node.columns.indexOf(key);
+			if (index === -1 || node.values.some((row) => row[index] === void 0)) throw new Error(`merge cannot set "${key}", which a record does not give, so that its default would replace the value of the record; give it in every record or leave it out of merge`);
+			set.push(Object.freeze({
+				key,
+				value: createNode({
+					kind: "column",
+					source: excluded,
+					key
+				})
+			}));
+		}
+		return this.derive(Object.freeze({
+			target: updateTarget,
+			update: Object.freeze({
+				set,
+				excluded
+			})
+		}), node.rows);
+	}
+	update(set) {
+		const { insert } = this;
+		const target = toUpdateTarget(insert.table, this.target, "update");
+		const node = this.insertNode();
+		const excluded = createExcluded(insert.table);
+		const assignments = toAssignments(node.target, set, insert.context, excluded);
+		return this.derive(Object.freeze({
+			target,
+			update: Object.freeze({
+				set: assignments,
+				excluded
+			})
+		}), node.rows);
+	}
+	/** Rejects awaiting the conflict target, which needs an action, such as `doNothing()`. */
+	then(_action) {
+		throw new Error("onConflict needs an action before the mutation runs, such as doNothing()");
+	}
+	/** Returns the node of the insert, which `onConflict` takes only of an insert. */
+	insertNode() {
+		return this.insert.node;
+	}
+	/** Creates the insert of the same kind and `Db` with `conflict`, changing rows `rows`. */
+	derive(conflict, rows) {
+		const { insert } = this;
+		const node = this.insertNode();
+		return new MutationQuery(insert.table, Object.freeze({
+			kind: "insert",
+			target: node.target,
+			columns: node.columns,
+			values: node.values,
+			conflict,
+			returning: void 0,
+			rows,
+			value: false
+		}), insert.context, insert.db);
+	}
 };
 /**
+* Returns the target of `DO UPDATE` of `method` of a conflict on the columns `target` of a key of `table`: the columns, or without them the unique index of `(true)` of a singleton table.
+*
+* It rejects a target without columns of another table, since PostgreSQL requires an explicit conflict target for `DO UPDATE`.
+*/
+function toUpdateTarget(table, target, method) {
+	if (target.length > 0) return target;
+	if (table.singleton) return "singleton";
+	throw new Error(`${method} needs the columns of a key in onConflict, since PostgreSQL updates a record only on a conflict of a named key`);
+}
+/** Creates the occurrence of `table` that stands for the row proposed for insertion in `DO UPDATE`, `EXCLUDED` of PostgreSQL. */
+function createExcluded(table) {
+	return Object.freeze({
+		kind: "table",
+		table
+	});
+}
+/**
 * Creates the insert of `records` into the table of `query`, which must have no clauses, in rows mode `rows`: `one` for `insert` and `many` for `insertMany`, named by `method`.
 *
 * It returns the number of the inserted rows, until a selection returns their fields.
+* It rejects an insert of rows `many` into a singleton table, which holds one row.
 */
 function createInsert(query, records, rows, method) {
+	if (!isTableQuery(query.node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
+	const { table } = query;
+	if (rows === "many" && table.singleton) throw new Error(`${method} cannot insert into singleton table "${table.name}", which holds one row; use insert or upsert`);
+	return createInsertInto(query, records, rows, method);
+}
+/**
+* Creates the upsert of `values` by `query`, a query of `find` or `findBy` of a table without other clauses, or of a singleton table without clauses.
+*
+* It inserts the values of the key of `query` with `values`, and on a conflict on that key, or on the row of a singleton table, sets the columns of `values` of the existing record, as `merge` of `onConflict` does.
+* It rejects another query, values that are not an object, a value of a column of the key, and values without a value other than `undefined`.
+*/
+function createUpsert(query, values) {
+	const { table } = query;
+	const { foundKey } = query.node;
+	if (foundKey === void 0) throw new Error("upsert applies only to a query of a singleton table or right after find or findBy of a query of a table, without clauses such as filters, optional, or selected fields; select the fields that it returns after it");
+	if (typeof values !== "object" || values === null) throw new TypeError(`upsert takes the values of the columns of table "${table.name}"`);
+	const key = Object.keys(foundKey);
+	const record = {};
+	for (const column of key) record[column] = foundKey[column];
+	let hasValues = false;
+	for (const column of Object.keys(values)) {
+		const value = values[column];
+		if (value === void 0) continue;
+		if (Object.hasOwn(foundKey, column)) throw new Error(`upsert takes the values of the columns other than the key of find or findBy, not of "${column}"`);
+		record[column] = value;
+		hasValues = true;
+	}
+	if (!hasValues) throw new Error(key.length === 0 ? "upsert takes the value of at least one column; to insert the row unless it exists, use insert(...).onConflict().doNothing()" : "upsert takes the value of at least one column other than the key; to insert the record of the key unless it exists, use insert(...).onConflict(...).doNothing()");
+	return new ConflictTarget(createInsertInto(query, [record], "one", "upsert"), key.length === 0 ? key : findKey(table, key)).merge();
+}
+/** Creates the insert of `records` into the occurrence of the table of `query`, whose clauses it does not read, in rows mode `rows` of the method named by `method`. */
+function createInsertInto(query, records, rows, method) {
 	const { node } = query;
-	if (!isTableQuery(node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
 	const { columns, values } = toInsertRows(node.from.table, records, method);
 	return new MutationQuery(query.table, Object.freeze({
 		kind: "insert",
@@ -2636,160 +3616,20 @@ function createDelete(query) {
 	}), query.context, query.db);
 }
 /**
-* Rejects a query whose rows `method`, `update` or `delete`, cannot change: one of a relation, with selected fields, which a mutation selects after it, with an order, a limit, or an offset, or without a filter that restricts its rows unless `all` allows it.
+* Rejects a query whose rows `method`, `update` or `delete`, cannot change: one of a relation, with selected fields, which a mutation selects after it, with a conversion of `map`, which a mutation takes after it too, with keys of groups, whose rows SQL does not give, with an order, a limit, an offset, `distinct`, or `distinctOn`, with a row lock, which a mutation takes on its rows itself, or without a filter that restricts its rows unless `all` allows it or the table is a singleton table.
 *
 * A filter simplified to `TRUE`, such as `where({})`, restricts no row.
 */
 function checkChangedRows(node, method) {
 	if (node.relation !== void 0) throw new Error(`${method} applies only to a query of a table, not of a relation`);
 	if (node.projections.length > 0) throw new Error(`${method} returns the fields selected after it, not before; call select, get, or pluck after ${method}`);
-	if (node.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, or orderBy`);
+	if (node.conversion !== void 0) throw new Error(`${method} returns what map converts after it, not before; call map after ${method}`);
+	if (node.groupBy.length > 0) throw new Error(`${method} changes rows rather than groups; choose them with where, find, or findBy instead of groupBy`);
+	if (node.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0 || node.distinct || node.distinctOn.length > 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, orderBy, distinct, or distinctOn`);
+	if (node.lock !== void 0) throw new Error(`${method} locks the rows it changes itself, so its query takes no row lock`);
+	if (node.all || node.from.table.singleton) return;
 	const predicate = combineFilters(node.filters);
-	if (!node.all && predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
-}
-// src/query/order.ts
-/** Direction and placement of `NULL` of a sort key node, by `OrderDirection`. */
-const directions = /* @__PURE__ */ Object.freeze({
-	asc: {
-		direction: "asc",
-		nulls: void 0
-	},
-	desc: {
-		direction: "desc",
-		nulls: void 0
-	},
-	"asc nulls first": {
-		direction: "asc",
-		nulls: "first"
-	},
-	"asc nulls last": {
-		direction: "asc",
-		nulls: "last"
-	},
-	"desc nulls first": {
-		direction: "desc",
-		nulls: "first"
-	},
-	"desc nulls last": {
-		direction: "desc",
-		nulls: "last"
-	}
-});
-const orderingNode = Symbol("kern-orm.ordering.node");
-/** Runtime class of an expression with a direction, which holds its sort key node. */
-var OrderingObject = class {
-	[orderingNode];
-	constructor(node) {
-		this[orderingNode] = node;
-		Object.freeze(this);
-	}
-};
-/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
-function asc(value) {
-	return orderBy(value, "asc");
-}
-/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
-function desc(value) {
-	return orderBy(value, "desc");
-}
-/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
-function orderBy(value, direction) {
-	if (!isOperandSource(value)) throw new TypeError("A sort key must be an expression or a query of one value");
-	return new OrderingObject(createOrderNode(value[operandNode](), direction));
-}
-/**
-* Creates the order of `node` with the sort keys of the arguments of `orderBy` after its own.
-*
-* `args` are column keys and objects of columns with directions, or a callback that receives the columns with the relations of `context` and the selected fields, and returns one sort key or an array of them.
-*/
-function addOrder(node, context, args) {
-	const order = node.orderBy.slice();
-	const first = args[0];
-	if (typeof first === "function") {
-		const terms = first(createSelectionRefs(node.from, context), createSelectedRefs(node));
-		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
-		else order.push(readTerm(terms));
-		return order;
-	}
-	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
-	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
-		const columns = arg;
-		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
-	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
-	return order;
-}
-/**
-* Creates the sort key node of a sort key returned by the callback of `orderBy`.
-*
-* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
-*/
-function readTerm(term) {
-	if (term instanceof OrderingObject) return term[orderingNode];
-	if (isOperandSource(term)) return createOrderNode(term[operandNode](), "asc");
-	throw new TypeError("The callback of orderBy must return expressions, queries of one value, or sort keys of asc, desc, and orderBy");
-}
-/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
-function createOrderNode(expression, direction) {
-	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
-	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
-	return Object.freeze({
-		expression,
-		direction: placement.direction,
-		nulls: placement.nulls
-	});
-}
-/** Creates a reference to the column `key` of the table of `source`. */
-function createColumnNode(source, key) {
-	requireColumn(source.table, key);
-	return createNode({
-		kind: "column",
-		source,
-		key
-	});
-}
-/**
-* Creates the references of the callback of `orderBy` to the fields selected by `node`.
-*
-* Each is an expression over the node of its projection, so that a sort key of it is the projection itself.
-* A field of an aggregate or of `exists` is an expression of its query that holds the field, by which lowering finds the projection of the field.
-*/
-function createSelectedRefs(node) {
-	const { projections } = node;
-	if (node.value) return toSelectedExpression(projections[0]);
-	const refs = {};
-	for (const projection of projections) {
-		const { key } = projection;
-		if (isLiteralSelection(projection)) Object.defineProperty(refs, key, {
-			get() {
-				throw new Error(`Field "${key}" holds a literal and cannot be sorted by`);
-			},
-			enumerable: true
-		});
-		else if (isNestedSelection(projection)) {
-			if (isSelectedAsValue(projection.query)) refs[key] = toQueryExpression(projection);
-			else Object.defineProperty(refs, key, {
-				get() {
-					throw new Error(`Field "${key}" holds nested rows and cannot be sorted by`);
-				},
-				enumerable: true
-			});
-		} else refs[key] = toSelectedExpression(projection);
-	}
-	return refs;
-}
-/** Creates an expression over the node of a projection of a query, which has a type: only lowering adds projections of nested queries. */
-function toSelectedExpression(projection) {
-	return toExpression(projection.expression, projection.type);
-}
-/** Creates an expression of the value of `field`, a selected aggregate query or query of `exists`, with the type of its value. */
-function toQueryExpression(field) {
-	const { query } = field;
-	return toExpression(createNode({
-		kind: "nestedQuery",
-		query,
-		db: field.db,
-		field
-	}), query.projections[0].type);
+	if (predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
 }
 // src/query/pagination.ts
 /** Creates the parameter of the number of rows of `limit` or `offset`, named by `method`, of query `node`, rejecting a query of one row and a count that is not a non-negative safe integer. */
@@ -2804,7 +3644,7 @@ function createPageCount(node, method, count) {
 }
 /** Creates the hint of the error of `limit` or `offset` of query `node` of one row: the method to call them before, if any. */
 function createPaginationHint(node) {
-	if (node.relation?.kind === "one") return "";
+	if (node.relation === void 0 ? node.from.table.singleton : node.relation.kind === "one") return "";
 	if (isAggregateQuery(node)) return "; call it before count or another aggregate to aggregate the rows of a page";
 	if (isExistsQuery(node)) return "; call it before exists to check the rows of a page";
 	return "; call it before take or get";
@@ -2871,7 +3711,7 @@ var SelectQuery = class SelectQuery {
 	}
 	count(arg) {
 		if (arg !== void 0) return this.aggregateBy("count", arg);
-		this.rejectAggregate("count");
+		this.rejectAggregation("count");
 		return this.deriveAggregate(countProjection);
 	}
 	countDistinct(arg) {
@@ -2899,10 +3739,11 @@ var SelectQuery = class SelectQuery {
 		return this.aggregateBy("stringAgg", arg, delimiter);
 	}
 	exists() {
-		this.rejectAggregate("exists");
+		this.rejectAggregation("exists");
 		return this.deriveAggregate(getExistsProjection());
 	}
 	coalesce(fallback) {
+		this.rejectMapped("coalesce");
 		const { node } = this;
 		if (!node.value) throw new Error("coalesce applies only to a query of values, such as one made by get, pluck, or an aggregate");
 		return this.derive({ projections: [coalesceValue(node.projections[0], fallback)] });
@@ -2911,6 +3752,18 @@ var SelectQuery = class SelectQuery {
 		const value = this[operandNode]();
 		return toExpression(value, this.node.projections[0].type);
 	}
+	groupBy(...args) {
+		this.rejectAggregate("groupBy");
+		if (this.node.lock !== void 0) throw new Error("groupBy cannot be used after a row lock, since a group comes from several rows of the table");
+		return this.derive({ groupBy: addGroupKeys("groupBy", this.node, this.context, args) });
+	}
+	having(filter) {
+		return this.derive({
+			having: addHaving(this.node, filter, this.context),
+			rows: this.getFilteredRows(),
+			guaranteed: false
+		});
+	}
 	orderBy(...args) {
 		return this.derive({ orderBy: addOrder(this.node, this.context, args) });
 	}
@@ -2920,11 +3773,36 @@ var SelectQuery = class SelectQuery {
 	offset(count) {
 		return this.derive({ offset: createPageCount(this.node, "offset", count) });
 	}
+	distinct() {
+		if (this.node.rows !== "many") throw new Error("distinct applies only to a query of many rows");
+		if (this.node.distinctOn.length > 0) throw new Error("distinct cannot be used after distinctOn, which compares only its keys");
+		if (this.node.lock !== void 0) throw new Error("distinct cannot be used after a row lock, since a row without duplicates comes from several rows of the table");
+		return this.derive({ distinct: true });
+	}
+	distinctOn(...args) {
+		const { node } = this;
+		if (node.rows !== "many") throw new Error("distinctOn applies only to a query of many rows");
+		if (node.distinct) throw new Error("distinctOn cannot be used after distinct, which compares every selected field");
+		if (node.lock !== void 0) throw new Error("distinctOn cannot be used after a row lock; PostgreSQL does not allow row locks with DISTINCT ON");
+		return this.derive({ distinctOn: addGroupKeys("distinctOn", node, this.context, args) });
+	}
+	forUpdate(options) {
+		return this.derive({ lock: createRowLock(this.node, "forUpdate", "UPDATE", options) });
+	}
+	forNoKeyUpdate(options) {
+		return this.derive({ lock: createRowLock(this.node, "forNoKeyUpdate", "NO KEY UPDATE", options) });
+	}
+	forShare(options) {
+		return this.derive({ lock: createRowLock(this.node, "forShare", "SHARE", options) });
+	}
+	forKeyShare(options) {
+		return this.derive({ lock: createRowLock(this.node, "forKeyShare", "KEY SHARE", options) });
+	}
 	optional() {
 		return this.changeOneRow("optional", "optional");
 	}
 	nullable() {
-		if (this.node.value) throw new Error("nullable applies only to a query of records; use optional after get, pluck, or an aggregate");
+		if (this.node.value && this.node.conversion === void 0) throw new Error("nullable applies only to a query of records; use optional after get, pluck, or an aggregate");
 		return this.changeOneRow("nullable", "nullable");
 	}
 	required() {
@@ -2937,6 +3815,9 @@ var SelectQuery = class SelectQuery {
 		if (!Array.isArray(records)) throw new TypeError("insertMany takes an array of records");
 		return createInsert(this, records, "many", "insertMany");
 	}
+	upsert(values) {
+		return createUpsert(this, values);
+	}
 	update(set) {
 		return createUpdate(this, set);
 	}
@@ -2947,6 +3828,12 @@ var SelectQuery = class SelectQuery {
 		if (this.node.rows !== "many") throw new Error("all applies only to a query of many rows");
 		return this.derive({ all: true });
 	}
+	map(callback) {
+		return this.derive({ conversion: addMap(this.node.conversion, callback) });
+	}
+	transform(callback) {
+		return transformQuery(this.node, this.db, callback);
+	}
 	use(callback, ...args) {
 		return requireDerived(this, callback(this, ...args), "The callback of use");
 	}
@@ -2961,6 +3848,7 @@ var SelectQuery = class SelectQuery {
 	[operandNode]() {
 		const { node } = this;
 		if (!node.value || node.rows === "many") throw new TypeError("An expression takes a query of one value, such as of get, an aggregate, or exists, not a query of records or of an array");
+		if (node.conversion !== void 0) throw new TypeError("An expression takes a query of one value, such as of get, an aggregate, or exists, not a query of map");
 		return createNode({
 			kind: "nestedQuery",
 			query: node,
@@ -2975,16 +3863,18 @@ var SelectQuery = class SelectQuery {
 	[valuesQueryNode]() {
 		const { node } = this;
 		if (!node.value) throw new TypeError("in takes a query of values, such as of pluck, not a query of records");
+		if (node.conversion !== void 0) throw new TypeError("in takes a query of values, such as of pluck, not a query of map");
 		return createNode({
 			kind: "nestedQuery",
 			query: node,
 			db: this.db
 		});
 	}
-	/** Creates a query of the same kind and `Db` with the node changes applied. */
+	/** Creates a query of the same kind and `Db` with the node changes applied, dropping the key of `find` and `findBy` unless the changes give it. */
 	derive(changes) {
 		return new SelectQuery(this.table, Object.freeze({
 			...this.node,
+			foundKey: void 0,
 			...changes
 		}), this.context, this.db);
 	}
@@ -3000,18 +3890,25 @@ var SelectQuery = class SelectQuery {
 		}
 		return this.derive(changes);
 	}
-	/** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
+	/**
+	* Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row.
+	*
+	* A query of `distinct` or `distinctOn` keeps the fields that `projection` replaces: `distinct` compares them, and the keys, the order, and the argument of an aggregate read a selected field through its projection.
+	*/
 	deriveAggregate(projection) {
-		return this.derive({
+		const { node } = this;
+		const changes = {
 			projections: [projection],
 			rows: "one",
 			value: true,
 			guaranteed: false
-		});
+		};
+		if (node.distinct || node.distinctOn.length > 0) changes.distinctFields = node.projections;
+		return this.derive(changes);
 	}
 	/** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and the relations and returns an expression or a query of one value; `delimiter` is the delimiter of `stringAgg`. */
 	aggregateBy(method, arg, delimiter) {
-		this.rejectAggregate(method);
+		this.rejectAggregation(method);
 		return this.deriveAggregate(projectAggregate(method, projectValue(this.node.from, arg, method, this.context), delimiter));
 	}
 	/** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
@@ -3019,14 +3916,24 @@ var SelectQuery = class SelectQuery {
 		const { node } = this;
 		return {
 			filters: addUserFilter(node.filters, filter, node.from, this.context),
-			rows: toFilteredRows(node.rows, node.value, node.guaranteed),
+			rows: this.getFilteredRows(),
 			guaranteed: false
 		};
 	}
-	/** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
+	/** Returns the rows mode of this query after a filter, as `FilteredStateRows` gives it in types. */
+	getFilteredRows() {
+		const { node } = this;
+		return toFilteredRows(node.rows, node.value && node.conversion === void 0, node.guaranteed);
+	}
+	/**
+	* Creates the query of `find` and `findBy`: `where` of `values`, an object of the values of the columns of a key, returning one row like `take`.
+	*
+	* On a query of a table without clauses, it keeps `values` as the key that `upsert` inserts.
+	*/
 	takeWhere(values) {
 		const changes = this.addFilter(values);
 		if (changes.rows === "many") changes.rows = "one";
+		if (isTableQuery(this.node)) changes.foundKey = Object.freeze(values);
 		return this.derive(changes);
 	}
 	/** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
@@ -3037,33 +3944,43 @@ var SelectQuery = class SelectQuery {
 			guaranteed: false
 		});
 	}
+	/** Rejects `method`, which reads or changes the fields of the query, on a query that `map` converts. */
+	rejectMapped(method) {
+		if (this.node.conversion !== void 0) throw new Error(`${method} cannot be used after map; call it before map`);
+	}
 	/** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
 	rejectValue(method) {
+		this.rejectMapped(method);
 		if (!this.node.value) return;
 		this.rejectAggregate(method);
 		throw new Error(`${method} cannot be used after get or pluck; call get or pluck to replace the value`);
 	}
 	/** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
 	rejectAggregate(method) {
+		this.rejectMapped(method);
 		const { node } = this;
 		if (isAggregateQuery(node)) throw new Error(`${method} cannot be used after an aggregate`);
 		if (isExistsQuery(node)) throw new Error(`${method} cannot be used after exists`);
 	}
+	/** Rejects `method`, an aggregate method or `exists`, on a query made by one of them or with a row lock. */
+	rejectAggregation(method) {
+		this.rejectAggregate(method);
+		if (this.node.lock !== void 0) throw new Error(`${method} cannot be used after a row lock, since it returns no rows of the table to lock`);
+	}
 };
 /**
-* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
+* Returns `result`, which a callback named by `subject` returned for `query`, a query of a table or a mutation, after checking that it is `query` or a query of the same class derived from it.
 *
 * An ancestor of `query` also passes, since only the source occurrence is compared.
 */
 function requireDerived(query, result, subject) {
-	if (!(result instanceof SelectQuery) || result.node.from !== query.node.from) throw new Error(`${subject} must return the query it receives or one derived from it`);
+	if (!(query instanceof SelectQuery ? result instanceof SelectQuery && result.node.from === query.node.from : result instanceof MutationQuery && result.node.target === query.node.target)) throw new Error(`${subject} must return the query it receives or one derived from it`);
 	return result;
 }
 /** Binds a query to `db`, so that awaiting it executes it there. */
 function bindQuery(query, db) {
 	return new SelectQuery(query.table, query.node, query.context, db);
 }
-/** Starts a query over a new occurrence of the table. */
 function from(table) {
 	return startQuery(table, noContext);
 }
@@ -3247,6 +4164,7 @@ function toRawSqlNode(strings, values) {
 function toInterpolatedNode(value) {
 	if (value instanceof SelectQuery) {
 		const { node } = value;
+		if (node.conversion !== void 0) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of map or transform");
 		return isTableQuery(node) ? createNode({
 			kind: "tableName",
 			table: value.table,
@@ -3257,7 +4175,7 @@ function toInterpolatedNode(value) {
 			db: value.db
 		});
 	}
-	if (value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of $select, a mutation, or a query of SQL text");
+	if (value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery || value instanceof TransformedQuery) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of $select, a mutation, a query of SQL text, or a query of map or transform");
 	return toValueNode(value);
 }
 // src/execution/db.ts
@@ -3284,6 +4202,7 @@ function bindSchema(schema, database, options = {}) {
 		},
 		async $execute(query) {
 			const compiled = compile(query);
+			if (compiled.locksRows && !database.isInTransaction()) throw new Error("Cannot lock the rows of a query outside a transaction, where the locks would end with its statement; a test transaction alone does not count");
 			return decodeStatement(compiled, await database.execute(compiled));
 		},
 		$select: (selection) => startRecordQuery(selection, db),
@@ -3303,124 +4222,316 @@ function bindSchema(schema, database, options = {}) {
 	const db = defineEntries(methods, schema.$tables, (key) => bindQuery(startQuery(schema.$tables[key], contexts[key]), db));
 	return db;
 }
-// src/execution/transaction.ts
+// src/execution/transaction/abort.ts
 /**
-* Routes statements and scripts to the ambient transaction of the current async context or to the pool.
+* Runs `start` and settles as its promise, or rejects with the reason of `signal` when it aborts first and `abort`, called on the abort, returns `true`.
 *
-* This is the only place that decides which connection executes a statement.
+* It listens from before `start`, which may abort the signal before it returns, and stops once the promise of `start` settles, such as for the signal that `node:test` aborts after every test.
+* A later rejection of that promise stays handled, and a value it resolves with after the rejection goes to `discard`, which handles its own failures.
 */
-var TransactionCoordinator = class {
-	driver;
-	test;
-	#storage = new AsyncLocalStorage();
-	/** Open test fixtures, the innermost last. */
-	#fixtures = [];
-	/** Changes of the fixture stack, run one after another so that each one sees the stack the previous one left. */
-	#transitions = Promise.resolve();
-	/**
-	* The `close` functions of the test fixtures that are still opening, from the call that starts the opening until the fixture enters the stack or the opening ends otherwise.
-	*
-	* An opening holds the queue of the fixture stack while its seed runs, so a closing of the stack queued behind it would wait for a seed that may never settle.
-	* Closing the stack therefore calls these first: each one tells its opening to stop waiting for the seed.
-	*/
-	#openings = /* @__PURE__ */ new Set();
-	/**
-	* Outermost fixture in the stack whose closing is queued but has not finished.
-	*
-	* Openings that start after that closing is requested nest outside of the fixture once it closes, so a repeated closing of it, or a closing of a fixture nested in it, must not close them.
-	*/
-	#closing;
-	/** Closing of the database, set by the first `close`; from then on, operations outside a transaction reject. */
-	#closed;
-	constructor(driver, test = false) {
-		this.driver = driver;
-		this.test = test;
+function settleUnlessAborted(start, signal, abort, discard) {
+	const settled = Promise.withResolvers();
+	let abandoned = false;
+	const onAbort = () => {
+		if (abort()) {
+			abandoned = true;
+			settled.reject(signal.reason);
+		}
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	let running;
+	try {
+		running = start();
+	} catch (error) {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+		return settled.promise;
 	}
-	execute(statement) {
-		const target = this.#route("execute a query");
-		return target instanceof Error ? Promise.reject(target) : target.execute(statement);
+	running.then((value) => {
+		signal.removeEventListener("abort", onAbort);
+		if (abandoned) discard?.(value);
+		else settled.resolve(value);
+	}, (error) => {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+	});
+	return settled.promise;
+}
+/**
+* Acquires a connection for a test transaction, rejecting with the reason of `signal` when it aborts first.
+*
+* A connection acquired after the abort returns to the pool as best-effort cleanup: the test transaction has already rejected, so nothing awaits the release, and its failure is ignored.
+*/
+function acquireUnlessAborted(driver, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return settleUnlessAborted(() => driver.acquire(), signal, () => true, (connection) => {
+		Promise.resolve().then(() => connection.release()).catch(() => {});
+	});
+}
+// src/execution/transaction/settings.ts
+/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
+function getLevelSettings(options) {
+	return options?.searchPath ? [{
+		name: "search_path",
+		value: options.searchPath.map(quoteIdentifier).join(", ")
+	}] : void 0;
+}
+/**
+* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
+*
+* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
+*/
+async function applySettings(level, settings) {
+	if (level.cleanup) return;
+	if (level.parent) {
+		let text = "SELECT";
+		const names = [];
+		for (const { name } of settings) {
+			names.push(name);
+			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
+		}
+		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
+		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
+			name,
+			value: values[index]
+		})));
+		if (level.cleanup) return;
 	}
-	/** Executes a script of statements without parameters where `execute` executes a statement. */
-	executeScript(text) {
-		const target = this.#route("execute a script");
-		return target instanceof Error ? Promise.reject(target) : target.executeScript(text);
+	await level.connection.execute(createSettingStatement(settings));
+}
+/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
+function createSettingStatement(settings) {
+	let text = "SELECT";
+	const parameters = [];
+	for (const { name, value } of settings) {
+		parameters.push(name, value);
+		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
 	}
-	/** Returns the connection of the ambient transaction or the driver of the pool that runs `operation`, or the error that rejects it. */
-	#route(operation) {
-		const level = this.#storage.getStore();
-		if (!level) {
-			if (this.#closed) return createDatabaseClosedError(operation);
-			return this.test ? new Error(describeOutsideTest(operation)) : this.driver;
+	return createStatement(text, parameters);
+}
+// src/execution/transaction/level.ts
+/** Statement that starts the transaction of a level without a parent: a transaction of `transaction`, a test transaction, or the first test fixture. */
+const beginStatement = /* @__PURE__ */ createStatement("BEGIN");
+const commitStatement = /* @__PURE__ */ createStatement("COMMIT");
+const rollbackStatement = /* @__PURE__ */ createStatement("ROLLBACK");
+/**
+* Creates the state of a `starting` level on `connection`, nested in `parent` if given.
+*
+* It sends no SQL and does not reserve the level as the `child` of `parent`; the caller does both.
+* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
+*/
+function createLevel(connection, parent, transaction) {
+	return {
+		connection,
+		parent,
+		depth: parent ? parent.depth + 1 : 0,
+		inTransaction: transaction || (parent?.inTransaction ?? false),
+		state: "starting",
+		child: void 0,
+		rollbackOnly: void 0,
+		cleanup: void 0,
+		endedBy: void 0,
+		restore: void 0
+	};
+}
+/**
+* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
+*
+* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
+* A level whose settings fail rolls back to its savepoint first.
+* The failure suppresses the reason of `signal` when the signal aborted before it.
+*/
+async function startNestedLevel(parent, transaction, signal, settings) {
+	const level = createLevel(parent.connection, parent, transaction);
+	parent.child = level;
+	try {
+		await level.connection.execute(createStatement(`SAVEPOINT ${getSavepointName(level)}`));
+	} catch (error) {
+		if (!level.cleanup) {
+			closeStarting(level);
+			throw suppressAbortReason(error, signal);
 		}
-		return createUnavailableError(level, operation) ?? level.connection;
+		throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
 	}
-	/**
-	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
-	*
-	* Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
-	* A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
-	*/
-	transaction(callback, options) {
-		const settings = getLevelSettings(options);
-		const parent = this.#storage.getStore();
-		if (parent) return this.#runNested(parent, callback, true, void 0, settings);
-		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a transaction"));
-		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true, void 0, settings);
+	if (settings) try {
+		await applySettings(level, settings);
+	} catch (error) {
+		throw suppressAbortReason(combineRejections({ error }, await endLevel(level, false)).error, signal);
 	}
-	/**
-	* Runs `callback` in the current transaction, or in a new transaction outside of one.
-	*
-	* Joining starts no savepoint, so a rejection of `callback` does not undo its changes.
-	* It rejects without calling `callback` when the current level accepts no statements, as a nested transaction would.
-	*/
-	async ensureTransaction(callback) {
-		const level = this.#storage.getStore();
-		if (!level?.inTransaction) return this.transaction(callback);
-		const unavailable = createUnavailableError(level, "join the transaction");
-		if (unavailable) throw unavailable;
-		return callback();
+	return level;
+}
+/**
+* Runs `callback` in the context of a started `level` in `storage`, then ends the level.
+*
+* A level that `commits` commits only when the callback resolves with no nested level running and no nested level that failed to end.
+* When `signal` aborts, the level ends at once without waiting for the callback, and its outcome is a rejection with the reason of the signal.
+*/
+async function runLevel(storage, level, callback, commits, signal) {
+	if (level.cleanup) return getEndedOutcome(level.cleanup, createClosedError(level, void 0));
+	let result;
+	let rejection;
+	if (signal?.aborted) endLevel(level, false, "abort");
+	else {
+		level.state = "open";
+		try {
+			result = await (signal ? settleUnlessAborted(() => storage.run(level, callback), signal, () => {
+				endLevel(level, false, "abort");
+				return true;
+			}) : storage.run(level, callback));
+		} catch (error) {
+			rejection = { error };
+		}
 	}
-	/**
-	* Tells whether the current async context runs in a transaction of `transaction`.
-	*
-	* A test transaction and the seed of a test fixture are not transactions, unless they run inside one, so that code under test behaves as in production.
-	*/
-	isInTransaction() {
-		return this.#storage.getStore()?.inTransaction ?? false;
+	if (level.cleanup) return getEndedOutcome(level.cleanup, level.endedBy === "abort" ? signal?.reason : createClosedError(level, rejection));
+	if (!rejection && level.child) rejection = { error: /* @__PURE__ */ new Error("Transaction was rolled back: a nested transaction was still running when its callback finished") };
+	if (!rejection && level.rollbackOnly) rejection = { error: new Error("Transaction was rolled back: a nested transaction failed to end", { cause: level.rollbackOnly.error }) };
+	const cleanup = await endLevel(level, commits && !rejection);
+	return {
+		result,
+		rejection: combineRejections(rejection, cleanup),
+		failure: cleanup.failure
+	};
+}
+/**
+* Ends `level` once, whoever ends it: later calls return the cleanup already started.
+*
+* Statements of the level and of all levels nested in it fail from the start of the cleanup, and the nested levels end before it.
+*/
+function endLevel(level, commit, endedBy) {
+	if (level.cleanup) return level.cleanup;
+	level.endedBy = endedBy;
+	level.state = "closing";
+	level.cleanup = cleanUpLevel(level, commit, level.child && endLevel(level.child, false, "enclosing level"));
+	return level.cleanup;
+}
+async function cleanUpLevel(level, commit, nested) {
+	const nestedCleanup = await nested;
+	const { parent } = level;
+	const cleanup = parent ? await endSavepoint(level, commit && !level.rollbackOnly) : await endTransaction(level.connection, commit);
+	level.state = "closed";
+	if (parent) {
+		if (parent.child === level) parent.child = void 0;
+		parent.rollbackOnly ??= cleanup.rejection;
+	}
+	return {
+		rejection: combineRejections(nestedCleanup?.rejection, cleanup),
+		failure: cleanup.failure
+	};
+}
+/** Ends a transaction with `COMMIT` or `ROLLBACK`. */
+async function endTransaction(connection, commit) {
+	try {
+		const { command } = await connection.execute(commit ? commitStatement : rollbackStatement);
+		if (commit && command !== "COMMIT") return { rejection: { error: /* @__PURE__ */ new Error("Transaction was rolled back: a statement in it failed") } };
+		return {};
+	} catch (error) {
+		return {
+			rejection: { error },
+			failure: { error }
+		};
+	}
+}
+/**
+* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
+*
+* Before a release, it restores the settings that the level changed; a rollback restores them itself.
+*/
+async function endSavepoint(level, commit) {
+	const name = getSavepointName(level);
+	try {
+		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
+		else if (level.restore) await level.connection.execute(level.restore);
+		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
+		return {};
+	} catch (error) {
+		return { rejection: { error } };
+	}
+}
+/** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
+function getSavepointName(level) {
+	return `kern_${level.depth}`;
+}
+/** Closes a nested level whose `SAVEPOINT` failed, freeing its parent for other statements. */
+function closeStarting(level) {
+	level.state = "closed";
+	if (level.parent?.child === level) level.parent.child = void 0;
+}
+/**
+* Creates the error of `operation` on a level that rejects statements and nested levels, or returns `undefined` when it accepts them.
+*
+* A level that can only roll back keeps the failure of its nested level as the cause.
+*/
+function createUnavailableError(level, operation) {
+	if (level.state !== "open") return /* @__PURE__ */ new Error(`Cannot ${operation}: its transaction is already finished`);
+	if (level.child) return /* @__PURE__ */ new Error(`Cannot ${operation}: a nested transaction is running; await it first`);
+	if (level.rollbackOnly) return new Error(`Cannot ${operation}: a nested transaction failed to end, so the transaction can only roll back`, { cause: level.rollbackOnly.error });
+}
+/** Error of a level that another level ended, keeping the rejection of its callback as the cause. */
+function createClosedError(level, rejection) {
+	return new Error(level.endedBy === "preemption" ? "Transaction was rolled back: its test fixture started another level before it finished" : "Transaction was rolled back: its enclosing transaction ended first", rejection && { cause: rejection.error });
+}
+/** Outcome of a level that something other than its callback ended: a rejection with `error`, which a failed cleanup suppresses. */
+async function getEndedOutcome(cleanup, error) {
+	const ended = await cleanup;
+	return {
+		rejection: combineRejections({ error }, ended),
+		failure: ended.failure
+	};
+}
+/** Returns the connection of a transaction to the driver, keeping a failed release as a rejection that suppresses `rejection`. */
+async function releaseConnection(connection, failure, rejection) {
+	try {
+		await connection.release(failure);
+		return rejection;
+	} catch (error) {
+		return suppress(error, rejection, "Releasing the transaction connection failed");
 	}
+}
+/** Error of a failure to start a test transaction, which suppresses the reason of `signal` when the signal aborted before the failure. */
+function suppressAbortReason(error, signal) {
+	return signal?.aborted ? suppress(error, { error: signal.reason }, "Starting the test transaction failed").error : error;
+}
+/** Rejection with the error of a cleanup, which suppresses the `earlier` rejection if there is one. */
+function combineRejections(earlier, cleanup) {
+	return cleanup.rejection ? suppress(cleanup.rejection.error, earlier, "Transaction rollback failed") : earlier;
+}
+/** Rejection with `error`, which suppresses the `earlier` rejection if there is one. */
+function suppress(error, earlier, message) {
+	return { error: earlier ? new SuppressedError(error, earlier.error, message) : error };
+}
+// src/execution/transaction/fixture-stack.ts
+/** Open test fixtures of a transaction coordinator and the queue of the changes of their stack. */
+var TestFixtureStack = class {
+	#driver;
+	/** Async context of the levels of the coordinator, which tells whether a call runs inside a level. */
+	#storage;
+	/** Open test fixtures, the innermost last. */
+	#fixtures = [];
+	/** Changes of the fixture stack, run one after another so that each one sees the stack the previous one left. */
+	#transitions = Promise.resolve();
 	/**
-	* Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
+	* The `close` functions of the test fixtures that are still opening, from the call that starts the opening until the fixture enters the stack or the opening ends otherwise.
 	*
-	* Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
-	* When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
-	* Once the level ends, the transaction rejects with the reason of the signal.
-	* A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
-	* Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
+	* An opening holds the queue of the fixture stack while its seed runs, so a closing of the stack queued behind it would wait for a seed that may never settle.
+	* Closing the stack therefore calls these first: each one tells its opening to stop waiting for the seed.
 	*/
-	testTransaction(callback, { signal } = {}) {
-		if (!this.test) return Promise.reject(/* @__PURE__ */ new Error("testTransaction requires a database created with test: true"));
-		if (signal?.aborted) return Promise.reject(signal.reason);
-		const parent = this.#storage.getStore();
-		if (parent) return this.#runNested(parent, callback, false, signal);
-		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a test transaction"));
-		return this.#startTestLevel(signal).then((level) => level ? this.#runStarted(level, callback, false, signal) : this.#runRoot(callback, false, signal));
-	}
+	#openings = /* @__PURE__ */ new Set();
 	/**
-	* Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
+	* Outermost fixture in the stack whose closing is queued but has not finished.
 	*
-	* Test transactions started outside any transaction run in the innermost fixture.
-	* A fixture whose `seed` rejects rolls back and closes.
+	* Openings that start after that closing is requested nest outside of the fixture once it closes, so a repeated closing of it, or a closing of a fixture nested in it, must not close them.
 	*/
-	createTestFixture(seed) {
-		return this.startTestFixture(seed).fixture;
+	#closing;
+	constructor(driver, storage) {
+		this.#driver = driver;
+		this.#storage = storage;
 	}
 	/**
-	* Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
+	* Starts opening a test fixture, see `startTestFixture` of the coordinator, or, given `refusal`, returns a fixture that rejects with it.
 	*
-	* Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
-	* Closing an open fixture also closes the fixtures opening in it.
+	* The `close` of a refused fixture resolves once the earlier changes of the stack end.
 	*/
-	startTestFixture(seed) {
+	start(seed, refusal) {
 		let level;
 		let closeRequested = false;
 		const closing = Promise.withResolvers();
@@ -3447,16 +4558,8 @@ var TransactionCoordinator = class {
 				if (rejection) throw rejection.error;
 			});
 		};
-		if (!this.test) return {
-			fixture: Promise.reject(/* @__PURE__ */ new Error("createTestFixture requires a database created with test: true")),
-			close
-		};
-		if (this.#storage.getStore()) return {
-			fixture: Promise.reject(/* @__PURE__ */ new Error("Cannot create a test fixture inside a transaction")),
-			close
-		};
-		if (this.#closed) return {
-			fixture: Promise.reject(createDatabaseClosedError("create a test fixture")),
+		if (refusal) return {
+			fixture: Promise.reject(refusal),
 			close
 		};
 		/**
@@ -3506,34 +4609,31 @@ var TransactionCoordinator = class {
 		};
 	}
 	/**
-	* Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
+	* Starts the level of a test transaction in the innermost test fixture as a change of the fixture stack, resolving to `undefined` when no fixture is open.
 	*
-	* A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
-	* A failed closing of the driver suppresses the failures of closing the fixtures.
-	* From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
+	* Aborted while it waits for its turn, it rejects at once and its change starts nothing, so that a test that has already ended never preempts the active level of the fixture.
+	* From its turn on, it settles with its change.
 	*/
-	close() {
-		if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close the database inside a transaction"));
-		this.#closed ??= this.#close();
-		return this.#closed;
+	startTestLevel(signal) {
+		let waiting = true;
+		const start = () => this.#enqueue(() => {
+			if (signal?.aborted) return;
+			waiting = false;
+			const fixture = this.#fixtures.at(-1);
+			return fixture && this.#startInFixture(fixture, signal);
+		});
+		return signal ? settleUnlessAborted(start, signal, () => waiting) : start();
 	}
-	/** Closes the test fixtures and then the driver, see `close`. */
-	async #close() {
-		let rejection;
-		try {
-			await this.#closeAfterOpenings(() => this.#enqueue(() => {
-				const root = this.#fixtures[0];
-				return root && this.#closeFixture(root);
-			}));
-		} catch (error) {
-			rejection = { error };
-		}
-		try {
-			await this.driver.close();
-		} catch (error) {
-			rejection = suppress(error, rejection, "Closing the driver failed");
-		}
-		if (rejection) throw rejection.error;
+	/**
+	* Closes every fixture, including those still opening, rejecting with the failures of all of them.
+	*
+	* Unlike closing a fixture, it closes every opening, including one started after a closing of the stack was requested, since nothing may stay open.
+	*/
+	close() {
+		return this.#closeAfterOpenings(() => this.#enqueue(() => {
+			const root = this.#fixtures[0];
+			return root && this.#closeFixture(root);
+		}));
 	}
 	/**
 	* Closes the fixtures still opening and runs `closeStack`, rejecting with the failures of all of them.
@@ -3555,7 +4655,7 @@ var TransactionCoordinator = class {
 	*/
 	async #seedFixture(fixture, seed) {
 		try {
-			return await this.#run(await this.#startNested(fixture, false), seed, true);
+			return await runLevel(this.#storage, await startNestedLevel(fixture, false), seed, true);
 		} catch (error) {
 			return { rejection: { error } };
 		}
@@ -3574,56 +4674,179 @@ var TransactionCoordinator = class {
 	}
 	/** Rolls back a fixture and releases the connection of the first one, returning the error to reject with. */
 	async #endFixture(fixture) {
-		const cleanup = await this.#end(fixture, false);
+		const cleanup = await endLevel(fixture, false);
 		return fixture.parent ? cleanup.rejection : releaseConnection(fixture.connection, cleanup.failure, cleanup.rejection);
 	}
-	/**
-	* Starts the level of a test transaction in the innermost test fixture as a change of the fixture stack, resolving to `undefined` when no fixture is open.
-	*
-	* Aborted while it waits for its turn, it rejects at once and its change starts nothing, so that a test that has already ended never preempts the active level of the fixture.
-	* From its turn on, it settles with its change.
-	*/
-	#startTestLevel(signal) {
-		let waiting = true;
-		const start = () => this.#enqueue(() => {
-			if (signal?.aborted) return;
-			waiting = false;
-			const fixture = this.#fixtures.at(-1);
-			return fixture && this.#startInFixture(fixture, signal);
-		});
-		return signal ? settleUnlessAborted(start, signal, () => waiting) : start();
-	}
 	/** Runs a change of the fixture stack after the earlier ones. */
 	#enqueue(transition) {
 		const result = this.#transitions.then(transition);
 		this.#transitions = result.catch(() => {});
 		return result;
 	}
-	/** Starts the first test fixture: a transaction on a reserved connection. */
-	async #beginFixture() {
-		const connection = await this.driver.acquire();
-		try {
-			await connection.execute(beginStatement);
-		} catch (error) {
-			throw (await releaseConnection(connection, { error }, { error })).error;
-		}
-		return createLevel(connection, void 0, false);
+	/** Starts the first test fixture: a transaction on a reserved connection. */
+	async #beginFixture() {
+		const connection = await this.#driver.acquire();
+		try {
+			await connection.execute(beginStatement);
+		} catch (error) {
+			throw (await releaseConnection(connection, { error }, { error })).error;
+		}
+		return createLevel(connection, void 0, false);
+	}
+	/**
+	* Starts a nested level of a test fixture, preempting its active one.
+	*
+	* A fixture runs one nested level at a time, so a new one ends the previous one, such as a test that timed out.
+	* A level whose `signal` aborts while it preempts rejects with its reason instead of starting, and a failure to start after the abort suppresses the reason.
+	*/
+	async #startInFixture(fixture, signal) {
+		if (fixture.child) {
+			const cleanup = await endLevel(fixture.child, false, "preemption");
+			if (cleanup.rejection) throw suppressAbortReason(new Error("Cannot start a level of the test fixture: ending its active level failed", { cause: cleanup.rejection.error }), signal);
+		}
+		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
+		if (unavailable) throw suppressAbortReason(unavailable, signal);
+		signal?.throwIfAborted();
+		return startNestedLevel(fixture, false, signal);
+	}
+};
+// src/execution/transaction/coordinator.ts
+/**
+* Routes statements and scripts to the ambient transaction of the current async context or to the pool.
+*
+* This is the only place that decides which connection executes a statement.
+*/
+var TransactionCoordinator = class {
+	driver;
+	test;
+	#storage = new AsyncLocalStorage();
+	#fixtures;
+	/** Closing of the database, set by the first `close`; from then on, operations outside a transaction reject. */
+	#closed;
+	constructor(driver, test = false) {
+		this.driver = driver;
+		this.test = test;
+		this.#fixtures = new TestFixtureStack(driver, this.#storage);
+	}
+	execute(statement) {
+		const target = this.#route("execute a query");
+		return target instanceof Error ? Promise.reject(target) : target.execute(statement);
+	}
+	/** Executes a script of statements without parameters where `execute` executes a statement. */
+	executeScript(text) {
+		const target = this.#route("execute a script");
+		return target instanceof Error ? Promise.reject(target) : target.executeScript(text);
+	}
+	/** Returns the connection of the ambient transaction or the driver of the pool that runs `operation`, or the error that rejects it. */
+	#route(operation) {
+		const level = this.#storage.getStore();
+		if (!level) {
+			if (this.#closed) return createDatabaseClosedError(operation);
+			return this.test ? new Error(describeOutsideTest(operation)) : this.driver;
+		}
+		return createUnavailableError(level, operation) ?? level.connection;
+	}
+	/**
+	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
+	*
+	* Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
+	* A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
+	*/
+	transaction(callback, options) {
+		const settings = getLevelSettings(options);
+		const parent = this.#storage.getStore();
+		if (parent) return this.#runNested(parent, callback, true, void 0, settings);
+		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a transaction"));
+		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true, void 0, settings);
+	}
+	/**
+	* Runs `callback` in the current transaction, or in a new transaction outside of one.
+	*
+	* Joining starts no savepoint, so a rejection of `callback` does not undo its changes.
+	* It rejects without calling `callback` when the current level accepts no statements, as a nested transaction would.
+	*/
+	async ensureTransaction(callback) {
+		const level = this.#storage.getStore();
+		if (!level?.inTransaction) return this.transaction(callback);
+		const unavailable = createUnavailableError(level, "join the transaction");
+		if (unavailable) throw unavailable;
+		return callback();
+	}
+	/**
+	* Tells whether the current async context runs in a transaction of `transaction`.
+	*
+	* A test transaction and the seed of a test fixture are not transactions, unless they run inside one, so that code under test behaves as in production.
+	*/
+	isInTransaction() {
+		return this.#storage.getStore()?.inTransaction ?? false;
+	}
+	/**
+	* Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
+	*
+	* Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
+	* When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
+	* Once the level ends, the transaction rejects with the reason of the signal.
+	* A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
+	* Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
+	*/
+	testTransaction(callback, { signal } = {}) {
+		if (!this.test) return Promise.reject(/* @__PURE__ */ new Error("testTransaction requires a database created with test: true"));
+		if (signal?.aborted) return Promise.reject(signal.reason);
+		const parent = this.#storage.getStore();
+		if (parent) return this.#runNested(parent, callback, false, signal);
+		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a test transaction"));
+		return this.#fixtures.startTestLevel(signal).then((level) => level ? this.#runStarted(level, callback, false, signal) : this.#runRoot(callback, false, signal));
+	}
+	/**
+	* Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
+	*
+	* Test transactions started outside any transaction run in the innermost fixture.
+	* A fixture whose `seed` rejects rolls back and closes.
+	*/
+	createTestFixture(seed) {
+		return this.startTestFixture(seed).fixture;
+	}
+	/**
+	* Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
+	*
+	* Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
+	* Closing an open fixture also closes the fixtures opening in it.
+	*/
+	startTestFixture(seed) {
+		return this.#fixtures.start(seed, this.#getFixtureRefusal());
+	}
+	/** Returns the error that rejects a test fixture created now, or `undefined` when it can open. */
+	#getFixtureRefusal() {
+		if (!this.test) return /* @__PURE__ */ new Error("createTestFixture requires a database created with test: true");
+		if (this.#storage.getStore()) return /* @__PURE__ */ new Error("Cannot create a test fixture inside a transaction");
+		if (this.#closed) return createDatabaseClosedError("create a test fixture");
 	}
 	/**
-	* Starts a nested level of a test fixture, preempting its active one.
+	* Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
 	*
-	* A fixture runs one nested level at a time, so a new one ends the previous one, such as a test that timed out.
-	* A level whose `signal` aborts while it preempts rejects with its reason instead of starting, and a failure to start after the abort suppresses the reason.
+	* A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
+	* A failed closing of the driver suppresses the failures of closing the fixtures.
+	* From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
 	*/
-	async #startInFixture(fixture, signal) {
-		if (fixture.child) {
-			const cleanup = await this.#end(fixture.child, false, "preemption");
-			if (cleanup.rejection) throw suppressAbortReason(new Error("Cannot start a level of the test fixture: ending its active level failed", { cause: cleanup.rejection.error }), signal);
+	close() {
+		if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close the database inside a transaction"));
+		this.#closed ??= this.#close();
+		return this.#closed;
+	}
+	/** Closes the test fixtures and then the driver, see `close`. */
+	async #close() {
+		let rejection;
+		try {
+			await this.#fixtures.close();
+		} catch (error) {
+			rejection = { error };
 		}
-		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
-		if (unavailable) throw suppressAbortReason(unavailable, signal);
-		signal?.throwIfAborted();
-		return this.#startNested(fixture, false, signal);
+		try {
+			await this.driver.close();
+		} catch (error) {
+			rejection = suppress(error, rejection, "Closing the driver failed");
+		}
+		if (rejection) throw rejection.error;
 	}
 	async #runRoot(callback, commits, signal, settings) {
 		const connection = await (signal ? acquireUnlessAborted(this.driver, signal) : this.driver.acquire());
@@ -3642,9 +4865,9 @@ var TransactionCoordinator = class {
 		if (!outcome && settings) try {
 			await applySettings(level, settings);
 		} catch (error) {
-			outcome = await getEndedOutcome(this.#end(level, false), error);
+			outcome = await getEndedOutcome(endLevel(level, false), error);
 		}
-		outcome ??= await this.#run(level, callback, commits, signal);
+		outcome ??= await runLevel(this.#storage, level, callback, commits, signal);
 		const rejection = await releaseConnection(connection, outcome.failure, outcome.rejection);
 		if (rejection) throw rejection.error;
 		return outcome.result;
@@ -3652,171 +4875,15 @@ var TransactionCoordinator = class {
 	async #runNested(parent, callback, commits, signal, settings) {
 		const unavailable = createUnavailableError(parent, "start a nested transaction");
 		if (unavailable) throw unavailable;
-		return this.#runStarted(await this.#startNested(parent, commits, signal, settings), callback, commits, signal);
-	}
-	/**
-	* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
-	*
-	* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
-	* A level whose settings fail rolls back to its savepoint first.
-	* The failure suppresses the reason of `signal` when the signal aborted before it.
-	*/
-	async #startNested(parent, transaction, signal, settings) {
-		const level = createLevel(parent.connection, parent, transaction);
-		parent.child = level;
-		try {
-			await level.connection.execute(createStatement(`SAVEPOINT ${getSavepointName(level)}`));
-		} catch (error) {
-			if (!level.cleanup) {
-				closeStarting(level);
-				throw suppressAbortReason(error, signal);
-			}
-			throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
-		}
-		if (settings) try {
-			await applySettings(level, settings);
-		} catch (error) {
-			throw suppressAbortReason(combineRejections({ error }, await this.#end(level, false)).error, signal);
-		}
-		return level;
+		return this.#runStarted(await startNestedLevel(parent, commits, signal, settings), callback, commits, signal);
 	}
 	/** Runs `callback` in a started level, returning its result or throwing its rejection. */
 	async #runStarted(level, callback, commits, signal) {
-		const { result, rejection } = await this.#run(level, callback, commits, signal);
+		const { result, rejection } = await runLevel(this.#storage, level, callback, commits, signal);
 		if (rejection) throw rejection.error;
 		return result;
 	}
-	/**
-	* Runs `callback` in the context of a started `level`, then ends the level.
-	*
-	* A level that `commits` commits only when the callback resolves with no nested level running and no nested level that failed to end.
-	* When `signal` aborts, the level ends at once without waiting for the callback, and its outcome is a rejection with the reason of the signal.
-	*/
-	async #run(level, callback, commits, signal) {
-		if (level.cleanup) return getEndedOutcome(level.cleanup, createClosedError(level, void 0));
-		let result;
-		let rejection;
-		if (signal?.aborted) this.#end(level, false, "abort");
-		else {
-			level.state = "open";
-			try {
-				result = await (signal ? settleUnlessAborted(() => this.#storage.run(level, callback), signal, () => {
-					this.#end(level, false, "abort");
-					return true;
-				}) : this.#storage.run(level, callback));
-			} catch (error) {
-				rejection = { error };
-			}
-		}
-		if (level.cleanup) return getEndedOutcome(level.cleanup, level.endedBy === "abort" ? signal?.reason : createClosedError(level, rejection));
-		if (!rejection && level.child) rejection = { error: /* @__PURE__ */ new Error("Transaction was rolled back: a nested transaction was still running when its callback finished") };
-		if (!rejection && level.rollbackOnly) rejection = { error: new Error("Transaction was rolled back: a nested transaction failed to end", { cause: level.rollbackOnly.error }) };
-		const cleanup = await this.#end(level, commits && !rejection);
-		return {
-			result,
-			rejection: combineRejections(rejection, cleanup),
-			failure: cleanup.failure
-		};
-	}
-	/**
-	* Ends `level` once, whoever ends it: later calls return the cleanup already started.
-	*
-	* Statements of the level and of all levels nested in it fail from the start of the cleanup, and the nested levels end before it.
-	*/
-	#end(level, commit, endedBy) {
-		if (level.cleanup) return level.cleanup;
-		level.endedBy = endedBy;
-		level.state = "closing";
-		const nested = level.child && this.#end(level.child, false, "enclosing level");
-		level.cleanup = this.#cleanUp(level, commit, nested);
-		return level.cleanup;
-	}
-	async #cleanUp(level, commit, nested) {
-		const nestedCleanup = await nested;
-		const { parent } = level;
-		const cleanup = parent ? await endSavepoint(level, commit && !level.rollbackOnly) : await endTransaction(level.connection, commit);
-		level.state = "closed";
-		if (parent) {
-			if (parent.child === level) parent.child = void 0;
-			parent.rollbackOnly ??= cleanup.rejection;
-		}
-		return {
-			rejection: combineRejections(nestedCleanup?.rejection, cleanup),
-			failure: cleanup.failure
-		};
-	}
 };
-const beginStatement = createStatement("BEGIN");
-const commitStatement = createStatement("COMMIT");
-const rollbackStatement = createStatement("ROLLBACK");
-function createLevel(connection, parent, transaction) {
-	return {
-		connection,
-		parent,
-		depth: parent ? parent.depth + 1 : 0,
-		inTransaction: transaction || (parent?.inTransaction ?? false),
-		state: "starting",
-		child: void 0,
-		rollbackOnly: void 0,
-		cleanup: void 0,
-		endedBy: void 0,
-		restore: void 0
-	};
-}
-/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
-function getLevelSettings(options) {
-	return options?.searchPath ? [{
-		name: "search_path",
-		value: options.searchPath.map(quoteIdentifier).join(", ")
-	}] : void 0;
-}
-/**
-* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
-*
-* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
-*/
-async function applySettings(level, settings) {
-	if (level.cleanup) return;
-	if (level.parent) {
-		let text = "SELECT";
-		const names = [];
-		for (const { name } of settings) {
-			names.push(name);
-			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
-		}
-		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
-		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
-			name,
-			value: values[index]
-		})));
-		if (level.cleanup) return;
-	}
-	await level.connection.execute(createSettingStatement(settings));
-}
-/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
-function createSettingStatement(settings) {
-	let text = "SELECT";
-	const parameters = [];
-	for (const { name, value } of settings) {
-		parameters.push(name, value);
-		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
-	}
-	return createStatement(text, parameters);
-}
-/** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
-function getSavepointName(level) {
-	return `kern_${level.depth}`;
-}
-/**
-* Creates the error of `operation` on a level that rejects statements and nested levels, or returns `undefined` when it accepts them.
-*
-* A level that can only roll back keeps the failure of its nested level as the cause.
-*/
-function createUnavailableError(level, operation) {
-	if (level.state !== "open") return /* @__PURE__ */ new Error(`Cannot ${operation}: its transaction is already finished`);
-	if (level.child) return /* @__PURE__ */ new Error(`Cannot ${operation}: a nested transaction is running; await it first`);
-	if (level.rollbackOnly) return new Error(`Cannot ${operation}: a nested transaction failed to end, so the transaction can only roll back`, { cause: level.rollbackOnly.error });
-}
 /** Error message of an operation outside a test transaction on a coordinator created for tests. */
 function describeOutsideTest(operation) {
 	return `Cannot ${operation} outside a test transaction: the database was created with test: true, so wrap the test in testTransaction`;
@@ -3825,118 +4892,6 @@ function describeOutsideTest(operation) {
 function createDatabaseClosedError(operation) {
 	return /* @__PURE__ */ new Error(`Cannot ${operation}: the database is closed`);
 }
-/** Closes a nested level whose `SAVEPOINT` failed, freeing its parent for other statements. */
-function closeStarting(level) {
-	level.state = "closed";
-	if (level.parent?.child === level) level.parent.child = void 0;
-}
-/** Error of a level that another level ended, keeping the rejection of its callback as the cause. */
-function createClosedError(level, rejection) {
-	return new Error(level.endedBy === "preemption" ? "Transaction was rolled back: its test fixture started another level before it finished" : "Transaction was rolled back: its enclosing transaction ended first", rejection && { cause: rejection.error });
-}
-/** Error of a failure to start a test transaction, which suppresses the reason of `signal` when the signal aborted before the failure. */
-function suppressAbortReason(error, signal) {
-	return signal?.aborted ? suppress(error, { error: signal.reason }, "Starting the test transaction failed").error : error;
-}
-/** Outcome of a level that something other than its callback ended: a rejection with `error`, which a failed cleanup suppresses. */
-async function getEndedOutcome(cleanup, error) {
-	const ended = await cleanup;
-	return {
-		rejection: combineRejections({ error }, ended),
-		failure: ended.failure
-	};
-}
-/**
-* Runs `start` and settles as its promise, or rejects with the reason of `signal` when it aborts first and `abort`, called on the abort, returns `true`.
-*
-* It listens from before `start`, which may abort the signal before it returns, and stops once the promise of `start` settles, such as for the signal that `node:test` aborts after every test.
-* A later rejection of that promise stays handled, and a value it resolves with after the rejection goes to `discard`, which handles its own failures.
-*/
-function settleUnlessAborted(start, signal, abort, discard) {
-	const settled = Promise.withResolvers();
-	let abandoned = false;
-	const onAbort = () => {
-		if (abort()) {
-			abandoned = true;
-			settled.reject(signal.reason);
-		}
-	};
-	signal.addEventListener("abort", onAbort, { once: true });
-	let running;
-	try {
-		running = start();
-	} catch (error) {
-		signal.removeEventListener("abort", onAbort);
-		settled.reject(error);
-		return settled.promise;
-	}
-	running.then((value) => {
-		signal.removeEventListener("abort", onAbort);
-		if (abandoned) discard?.(value);
-		else settled.resolve(value);
-	}, (error) => {
-		signal.removeEventListener("abort", onAbort);
-		settled.reject(error);
-	});
-	return settled.promise;
-}
-/**
-* Acquires a connection for a test transaction, rejecting with the reason of `signal` when it aborts first.
-*
-* A connection acquired after the abort returns to the pool as best-effort cleanup: the test transaction has already rejected, so nothing awaits the release, and its failure is ignored.
-*/
-function acquireUnlessAborted(driver, signal) {
-	if (signal.aborted) return Promise.reject(signal.reason);
-	return settleUnlessAborted(() => driver.acquire(), signal, () => true, (connection) => {
-		Promise.resolve().then(() => connection.release()).catch(() => {});
-	});
-}
-/** Returns the connection of a transaction to the driver, keeping a failed release as a rejection that suppresses `rejection`. */
-async function releaseConnection(connection, failure, rejection) {
-	try {
-		await connection.release(failure);
-		return rejection;
-	} catch (error) {
-		return suppress(error, rejection, "Releasing the transaction connection failed");
-	}
-}
-/** Ends a transaction with `COMMIT` or `ROLLBACK`. */
-async function endTransaction(connection, commit) {
-	try {
-		const { command } = await connection.execute(commit ? commitStatement : rollbackStatement);
-		if (commit && command !== "COMMIT") return { rejection: { error: /* @__PURE__ */ new Error("Transaction was rolled back: a statement in it failed") } };
-		return {};
-	} catch (error) {
-		return {
-			rejection: { error },
-			failure: { error }
-		};
-	}
-}
-/**
-* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
-*
-* Before a release, it restores the settings that the level changed; a rollback restores them itself.
-*/
-async function endSavepoint(level, commit) {
-	const name = getSavepointName(level);
-	try {
-		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
-		else if (level.restore) await level.connection.execute(level.restore);
-		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
-		return {};
-	} catch (error) {
-		return { rejection: { error } };
-	}
-}
-/** Rejection with the error of a cleanup, which suppresses the `earlier` rejection if there is one. */
-function combineRejections(earlier, cleanup) {
-	return cleanup.rejection ? suppress(cleanup.rejection.error, earlier, "Transaction rollback failed") : earlier;
-}
-/** Rejection with `error`, which suppresses the `earlier` rejection if there is one. */
-function suppress(error, earlier, message) {
-	return { error: earlier ? new SuppressedError(error, earlier.error, message) : error };
-}
 // src/execution/database.ts
 /** Creates a database over a driver; its transactions are shared by every schema bound to it. */
 function createDatabase({ driver, test }) {
@@ -3965,4 +4920,4 @@ function createDatabase({ driver, test }) {
 function createLockStatement(key) {
 	return createStatement("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key]);
 }
-export { not as C, isColumnValues as S, combineNodes as T, NotFoundError as _, defineSchema as a, literal as b, requireDerived as c, orderBy as d, many as f, defineTable as g, matchColumn as h, sql as i, asc as l, createStatement as m, identifier as n, SelectQuery as o, one as p, param as r, from as s, createDatabase as t, desc as u, RequiredRelationError as v, or as w, and as x, ResultDecodeError as y };
+export { not as A, countType as C, literal as D, toAggregateType as E, combineNodes as M, and as O, countProjection as S, createCountCall as T, createTableFactory as _, defineSchema as a, RequiredRelationError as b, requireDerived as c, desc as d, orderBy as f, createStatement as g, one as h, sql as i, or as j, isColumnValues as k, addTerms as l, many as m, identifier as n, SelectQuery as o, matchColumn as p, param as r, from as s, createDatabase as t, asc as u, defineTable as v, createAggregateCall as w, ResultDecodeError as x, NotFoundError as y };