kern-orm 0.14.0 → 0.16.0

package/dist/index.mjs

@@ -1,3575 +1,13 @@
-import { A as valuesQueryNode, B as oneNode, C as defineType, D as equalityOperators, E as Column, F as falseNode, I as noFilters, L as noJoins, M as createList, N as createNode, P as createSelectNode, R as noOrder, S as getBooleanType, T as isType$1, V as trueNode, _ as toCastValueNode, b as toNode, c as compare, d as getType, f as isExpression, g as toBooleanExpression, h as rejectSqlQueryOperand, i as textOperators, j as defineGenericOperator, k as isEqualityCompatible, l as compareNodes, m as operandNode, n as text, p as isOperandSource, s as orderingOperators, u as createIsNullNode, v as toExpression, w as describeRejectedDbType, x as toValueNode, y as toFunctionOperandNode, z as noProjections } from "./text-ucmJCsCN.mjs";
-import { SqlFragment, SqlQuery, assertUntypedValue, bindParameter, createFieldDecodeError, createResultDecodeError, encodeParameter, isRecordKey, quoteIdentifier, renderFragment, startSqlQuery, takeOnlyRow, toMissingResult, toValueRows } from "kern-db/builder";
-import { ConnectionError, NotFoundError, NotFoundError as NotFoundError$1, QueryError, ResultDecodeError, ResultDecodeError as ResultDecodeError$1, TransactionConnectionError, createDatabase, createStatement, createStatement as createStatement$1, identifier as identifier$1, isOutcomeUnknown, isQueryError, toDriverError } from "kern-db";
-import { types } from "node:util";
-// src/ast/boolean.ts
-/** Combines predicate nodes with `AND` or `OR`, flattening nested groups of the same kind. */
-function combineNodes(kind, operands) {
-	const neutral = kind === "and";
-	const flat = [];
-	for (const operand of operands) if (operand.kind === "boolean") {
-		if (operand.value !== neutral) return operand;
-	} else if (operand.kind === kind) flat.push(...operand.operands);
-	else flat.push(operand);
-	if (flat.length === 0) return neutral ? trueNode : falseNode;
-	return flat.length === 1 ? flat[0] : createNode({
-		kind,
-		operands: flat
-	});
-}
-/** Negates a predicate node, simplifying constants and double negation. */
-function negateNode(operand) {
-	if (operand.kind === "boolean") return operand.value ? falseNode : trueNode;
-	if (operand.kind === "not") return operand.operand;
-	return createNode({
-		kind: "not",
-		operand
-	});
-}
-/** Combines the filters of a query into its effective predicate, `relation AND scope AND user`, which is `TRUE` when they restrict no row. */
-function combineFilters(filters) {
-	const operands = [];
-	if (filters.relation !== void 0) operands.push(filters.relation);
-	if (filters.scope !== void 0) operands.push(filters.scope);
-	if (filters.user !== void 0) operands.push(filters.user);
-	return combineNodes("and", operands);
-}
-// src/expression/predicates.ts
-/** Converts a condition operand into a node: a query nests in it, and an object of column values stays unresolved until `where`; it rejects any other value. */
-function toConditionNode(operand) {
-	if (isOperandSource(operand)) return operand[operandNode]();
-	if (operand instanceof SqlQuery) rejectSqlQueryOperand();
-	if (!isColumnValues(operand)) throw new TypeError("A condition must be an expression, such as TRUE or FALSE, a query of one Boolean value, or an object of column values");
-	return createNode({
-		kind: "values",
-		values: operand
-	});
-}
-/** Tells whether `value` can be an object of column values: a plain object, of this or another realm, or an object that has keys. */
-function isColumnValues(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || Object.getPrototypeOf(prototype) === null || Object.keys(value).length > 0;
-}
-function and(...operands) {
-	return combineConditions("and", operands);
-}
-function or(...operands) {
-	return combineConditions("or", operands);
-}
-function not(operand) {
-	return toBooleanExpression(negateNode(toConditionNode(operand)));
-}
-function combineConditions(kind, operands) {
-	const nodes = [];
-	for (const operand of operands) nodes.push(toConditionNode(operand));
-	return toBooleanExpression(combineNodes(kind, nodes));
-}
-// src/expression/constants.ts
-/** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
-const TRUE = /* @__PURE__ */ toExpression(trueNode, /* @__PURE__ */ getBooleanType());
-/** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
-const FALSE = /* @__PURE__ */ toExpression(falseNode, /* @__PURE__ */ getBooleanType());
-// src/query/literal.ts
-/**
-* Field of a selection whose value is `T`, made by `literal`.
-*
-* It is not an expression: it has no SQL, so only a selection takes it.
-*/
-var Literal = class {
-	literal;
-	constructor(literal) {
-		this.literal = literal;
-		Object.freeze(this);
-	}
-	/** Rejects the literal as an operand of an expression: a statement has no SQL of it. */
-	[operandNode]() {
-		throw new TypeError("A literal is only a selected field and has no SQL; pass a value to an expression through param");
-	}
-};
-/**
-* Creates a field of a selection with `value` in every record, without selecting anything in SQL: the query returns the value itself, not a copy of it, whatever it is.
-*
-* It lets a branch of a selection skip a column or a nested query, such as `withHint ? field.hint : literal(null)`.
-* To use a value in SQL, such as in a condition, pass it through `param` instead.
-*/
-function literal(value) {
-	return new Literal(value);
-}
-// src/query/exists.ts
-let existsProjection;
-/** Returns the projection of whether a query has a row, the only projection of a query made by `exists`. */
-function getExistsProjection() {
-	existsProjection ??= Object.freeze({
-		key: "exists",
-		expression: trueNode,
-		type: getBooleanType()
-	});
-	return existsProjection;
-}
-/** Tells whether `node` is a query of `exists`, whose value is whether the rows that its filters, limit, and offset choose exist. */
-function isExistsQuery(node) {
-	return node.value && isExistsProjection(node.projections[0]);
-}
-/** Tells whether a selected field is the projection of `exists`, which only `exists` selects. */
-function isExistsProjection(field) {
-	return field === existsProjection;
-}
-// src/query/aggregate.ts
-/** Type of a count: a `bigint` of PostgreSQL decoded as a number, rejecting a count that a number cannot hold exactly. */
-const countType = /* @__PURE__ */ defineType({ sqlType: "bigint" }).transform({
-	decode: (text) => decodeSafeInteger(text, "Count"),
-	encode: (value) => String(value)
-}).withOperators(orderingOperators);
-/** Types of the sums of the values of `smallint` and `integer` types, by the type of the values, created once for each. */
-const sumTypes = /* @__PURE__ */ new WeakMap();
-const noFallbacks = /* @__PURE__ */ Object.freeze([]);
-/** Definitions of the aggregate methods that take a column or an expression. */
-const aggregateDefinitions = /* @__PURE__ */ Object.freeze({
-	count: {
-		name: "count",
-		distinct: false,
-		ordered: false,
-		type: toCountType
-	},
-	countDistinct: {
-		name: "count",
-		distinct: true,
-		ordered: false,
-		type: toCountType
-	},
-	min: {
-		name: "min",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	max: {
-		name: "max",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	sum: {
-		name: "sum",
-		distinct: false,
-		ordered: false,
-		type: toSumType
-	},
-	avg: {
-		name: "avg",
-		distinct: false,
-		ordered: false,
-		type: toAverageType
-	},
-	every: {
-		name: "bool_and",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	some: {
-		name: "bool_or",
-		distinct: false,
-		ordered: false,
-		type: toArgumentType
-	},
-	stringAgg: {
-		name: "string_agg",
-		distinct: false,
-		ordered: true,
-		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",
-	expression: /* @__PURE__ */ createNode({
-		kind: "aggregate",
-		name: "count",
-		distinct: false,
-		arguments: [allRowsNode],
-		orderBy: noOrder,
-		filter: void 0
-	}),
-	type: countType,
-	ordered: false,
-	fallbacks: noFallbacks
-});
-/**
-* Creates the projection of the aggregate of `method` over the values of `argument`, the projection of a column or an expression of each row.
-*
-* `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];
-	if (delimiter !== void 0) args.push(createNode({
-		kind: "param",
-		value: delimiter,
-		type: void 0
-	}));
-	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();
-	fallbacks.push(fallback);
-	return Object.freeze({
-		key: field.key,
-		expression: field.expression,
-		type: field.type,
-		ordered: field.ordered,
-		fallbacks
-	});
-}
-/** Tells whether `node` is an aggregate query, whose value is the aggregate over the rows that its filters, limit, and offset choose. */
-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, unless `map` or `transform` converts its value. */
-function isSelectedAsValue(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) {
-	return "ordered" in field;
-}
-function toCountType() {
-	return countType;
-}
-function toArgumentType(argument) {
-	return argument;
-}
-/** Returns the type of the sum of the values of type `argument`: for `smallint` and `integer` values, a `bigint` with the operators of `argument` that rejects a sum that a number cannot hold exactly, and `argument` for others. */
-function toSumType(argument) {
-	if (argument.castType !== "smallint" && argument.castType !== "integer") return argument;
-	let type = sumTypes.get(argument);
-	if (type === void 0) {
-		type = defineType({ sqlType: "bigint" }).transform({
-			decode: (text) => {
-				decodeSafeInteger(text, "Sum");
-				return argument.decode(text);
-			},
-			encode: (value) => argument.encode(value)
-		}).withOperators(argument.operators);
-		sumTypes.set(argument, type);
-	}
-	return type;
-}
-/** Returns the type of the average of the values of type `argument`, which decodes a fractional value where PostgreSQL gives one, such as `Number` of `integer`; rejects a type of the SQL type `bigint`. */
-function toAverageType(argument) {
-	if (argument.castType === "bigint") throw new TypeError("avg of bigint values requires a type that can represent fractional values; average a sql fragment of the column with t.doublePrecision or t.numeric");
-	return argument;
-}
-/** Decodes `text` of a `bigint` as a number, rejecting one that a number cannot hold exactly; `subject` names it in the error. */
-function decodeSafeInteger(text, subject) {
-	const number = Number(text);
-	if (!Number.isSafeInteger(number)) throw new RangeError(`${subject} ${text} is outside the safe integer range of numbers`);
-	return number;
-}
-// src/query/column-refs.ts
-/** Context of a query whose table has no relations, such as one of `from(table)`. */
-const noContext = /* @__PURE__ */ Object.freeze({ relations: /* @__PURE__ */ Object.freeze({}) });
-/** Creates the references of the callbacks of queries over `source`: expressions of its columns, each with the type of its column, and the relations of `context`. */
-function createSelectionRefs(source, context) {
-	const refs = {};
-	const { columns } = source.table;
-	for (const key of Object.keys(columns)) refs[key] = toExpression(createNode({
-		kind: "column",
-		source,
-		key
-	}), 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/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 "$"`);
-		if (!isRecordKey(key)) throw new Error(`Column key "__proto__" of table "${name}" is not allowed; use columnName("__proto__")`);
-		const column = toColumn(definition);
-		if (!column) {
-			const rejected = describeRejectedDbType(definition);
-			throw new TypeError(`Column "${key}" of table "${name}" must be a type of kern-orm or a column${rejected ? `, not ${rejected}` : ""}`);
-		}
-		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),
-		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.
-* It rejects a primary key declared twice, a key of the options with fewer than two columns, an unknown column or a column listed twice in such a key, a nullable column of the primary key, and two keys of the same columns.
-*/
-function defineKeys(name, columns, options) {
-	let primaryKey;
-	const unique = [];
-	for (const key of Object.keys(columns)) {
-		const keyKind = columns[key].attributes.keyKind;
-		if (keyKind === "primaryKey") {
-			if (primaryKey !== void 0) throw new Error(`Table "${name}" marks columns "${primaryKey[0]}" and "${key}" with primaryKey(); list the columns of a primary key of several columns in the options`);
-			primaryKey = Object.freeze([key]);
-		} else if (keyKind === "unique") unique.push(Object.freeze([key]));
-	}
-	if (options?.primaryKey !== void 0) {
-		if (primaryKey !== void 0) throw new Error(`Table "${name}" declares its primary key both on column "${primaryKey[0]}" and in the options`);
-		primaryKey = toKeyColumns(name, columns, options.primaryKey);
-	}
-	if (options?.unique !== void 0) {
-		if (!Array.isArray(options.unique)) throw new TypeError(`Unique keys in the options of table "${name}" must be an array`);
-		for (const key of options.unique) unique.push(toKeyColumns(name, columns, key));
-	}
-	for (const key of primaryKey ?? []) if (columns[key].type.isNullable) throw new Error(`Primary key column "${key}" of table "${name}" must not be nullable`);
-	const keys = primaryKey === void 0 ? unique : [primaryKey, ...unique];
-	for (let index = 1; index < keys.length; index++) for (let other = 0; other < index; other++) if (hasSameColumns(keys[index], keys[other])) throw new Error(`Table "${name}" declares the key of columns ${keys[index].map((key) => `"${key}"`).join(", ")} twice`);
-	return Object.freeze({
-		primaryKey,
-		unique: Object.freeze(unique)
-	});
-}
-/** Returns the column keys of a key of several columns from the options of table `name`, frozen, rejecting what `defineKeys` rejects in such a key. */
-function toKeyColumns(name, columns, key) {
-	if (!Array.isArray(key) || key.length < 2) throw new Error(`A key in the options of table "${name}" must list at least two columns; mark a key of one column with primaryKey() or unique()`);
-	for (let index = 0; index < key.length; index++) {
-		const column = key[index];
-		if (typeof column !== "string" || !Object.hasOwn(columns, column)) throw new Error(`A key in the options of table "${name}" lists unknown column "${column}"`);
-		if (key.indexOf(column) !== index) throw new Error(`A key in the options of table "${name}" lists column "${column}" twice`);
-	}
-	return Object.freeze(key.slice());
-}
-/** Tells whether keys `key` and `other` have the same columns, in any order; neither lists a column twice. */
-function hasSameColumns(key, other) {
-	return key.length === other.length && key.every((column) => other.includes(column));
-}
-/** Finds the column of `table` under `key`, ignoring properties inherited from the object prototype, such as `toString`. */
-function findColumn(table, key) {
-	return Object.hasOwn(table.columns, key) ? table.columns[key] : void 0;
-}
-/** 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);
-	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) {
-	const listed = new Set(columns);
-	return someKey(table, (key) => isKeyAmong(key, listed));
-}
-/** Tells whether `predicate` holds for a key of `table`, primary or unique. */
-function someKey(table, predicate) {
-	const { primaryKey, unique } = table.keys;
-	return primaryKey !== void 0 && predicate(primaryKey) || unique.some(predicate);
-}
-/** Tells whether every column of `key` is in `columns`. */
-function isKeyAmong(key, columns) {
-	return key.every((column) => columns.has(column));
-}
-/** Returns the column of `table` under `key` as `findColumn` finds it, rejecting a key that is not a column. */
-function requireColumn(table, key) {
-	const column = findColumn(table, key);
-	if (!column) throw new Error(`Unknown column "${key}" of table "${table.name}"`);
-	return column;
-}
-/** Creates a column from a column definition, or returns `undefined` for a value that is neither a type nor a column. */
-function toColumn(definition) {
-	if (definition instanceof Column) return definition;
-	return isType$1(definition) ? new Column(definition, {
-		name: void 0,
-		keyKind: void 0,
-		hasDefault: false
-	}) : void 0;
-}
-// src/compiler/postgres/identifier.ts
-/** Most bytes a character other than ASCII takes in a server encoding, such as UTF-8 and EUC_TW ([PostgreSQL](https://www.postgresql.org/docs/current/multibyte.html)). */
-const maxCharacterBytes = 4;
-/**
-* Returns the longest prefix of `name` that takes at most `maxBytes` bytes in any server encoding.
-*
-* Every server encoding takes one byte for an ASCII character, and a character other than ASCII counts as the most bytes it can take.
-*/
-function cutIdentifier(name, maxBytes) {
-	if (name.length * maxCharacterBytes <= maxBytes) return name;
-	let bytes = 0;
-	for (let index = 0; index < name.length;) {
-		const code = name.codePointAt(index);
-		bytes += code < 128 ? 1 : maxCharacterBytes;
-		if (bytes > maxBytes) return name.slice(0, index);
-		index += code < 65536 ? 1 : 2;
-	}
-	return name;
-}
-/**
-* Returns the SQL name of the projection with `key` at `index` of its query.
-*
-* A key of up to 50 bytes is the name itself.
-* A longer key is named by its prefix of at most 54 bytes, which takes more than 50 since a character takes at most 4, and by its position, so the name differs from the names of the other projections.
-*/
-function nameProjection(key, index) {
-	if (cutIdentifier(key, 50).length === key.length) return key;
-	return `${cutIdentifier(key, 54)}_${index + 1}`;
-}
-// src/compiler/postgres/context.ts
-/**
-* State of one compilation shared by all queries of the statement, never by reusable nodes: parameters and the aliases of all sources.
-*
-* It binds the parameters of the fragments of the database layer that the statement interpolates, numbering them with its own.
-*/
-var CompileContext = class {
-	schemaName;
-	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, where `bindParam` binds the parameter of a cast once. */
-	grouped = false;
-	#aliases = /* @__PURE__ */ new Set();
-	#placeholders;
-	constructor(schemaName, tables = void 0, db = void 0) {
-		this.schemaName = schemaName;
-		this.tables = tables;
-		this.db = db;
-	}
-	/**
-	* Creates an alias based on `name` that is unique in the statement, so that no source shadows another one in SQL.
-	*
-	* The name is cut to 50 bytes and numbered when the statement already has it, so an alias fits an identifier and PostgreSQL compares aliases as created rather than truncated.
-	*/
-	createAlias(name) {
-		const base = cutIdentifier(name.toWellFormed(), 50);
-		let alias = base;
-		for (let index = 2; this.#aliases.has(alias); index++) alias = `${base}_${index}`;
-		this.#aliases.add(alias);
-		return alias;
-	}
-	/** Adds a parameter of the statement and returns its placeholder, rejecting more parameters than PostgreSQL takes. */
-	bind(value) {
-		return bindParameter(this.parameters, value);
-	}
-	/**
-	* Binds `value` as the parameter of the cast that `key` identifies, such as its node, and returns its placeholder.
-	*
-	* In a query of groups, it binds the parameter unless it has bound it for `key` before.
-	*/
-	bindParam(key, value) {
-		if (!this.grouped) return this.bind(value);
-		this.#placeholders ??= /* @__PURE__ */ new Map();
-		let placeholder = this.#placeholders.get(key);
-		if (placeholder === void 0) {
-			placeholder = this.bind(value);
-			this.#placeholders.set(key, 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. */
-function needsParentheses(kind, position) {
-	switch (kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "values":
-		case "nestedQuery":
-		case "tableName":
-		case "subquery":
-		case "exists":
-		case "textSubquery":
-		case "aggregate": return false;
-		case "cast": return position === "interpolation";
-		case "raw":
-		case "fragment": return position !== "interpolation";
-		case "and":
-		case "or": return true;
-		case "not":
-		case "comparison":
-		case "in":
-		case "inQuery":
-		case "isNull": return position !== "condition";
-		default: return kind;
-	}
-}
-// src/compiler/postgres/scope.ts
-/**
-* Declares a source of `FROM` on top of `outer` with a new alias.
-*
-* It rejects a source already visible there, such as a query nested in itself: a column reference could not tell its occurrences apart.
-*/
-function declareSource(context, outer, source) {
-	if (findSource(outer, source) !== void 0 || source.kind === "derived" && source.replaces !== void 0 && findSource(outer, source.replaces) !== void 0) throw new Error(`An occurrence of ${describeSource(source)} appears where it is already visible, so its column references would be ambiguous`);
-	const name = source.kind === "table" ? source.table.name : source.replaces?.table.name ?? "subquery";
-	return {
-		source,
-		alias: context.createAlias(name),
-		outer
-	};
-}
-/**
-* Returns the declared source that a column reference reads in `scope`: its source, or a derived source that replaces it; rejects a source that is not visible there.
-*/
-function resolveSource(scope, column) {
-	const declared = findSource(scope, column.source);
-	if (declared === void 0) throw new Error(`Column "${column.key}" of ${describeSource(column.source)} refers to a source that is not visible where it is used`);
-	return declared;
-}
-/** Returns the declared source of `scope` that is `source` or replaces it, or `undefined` when the source is not visible there. */
-function findSource(scope, source) {
-	for (let current = scope; current; current = current.outer) {
-		const declared = current.source;
-		if (declared === source || declared.kind === "derived" && declared.replaces === source) return current;
-	}
-}
-function describeSource(source) {
-	return source.kind === "table" ? `table "${source.table.name}"` : "a subquery";
-}
-// src/compiler/postgres/compile.ts
-const noFields = /* @__PURE__ */ Object.freeze([]);
-/**
-* Compiles a statement for PostgreSQL with the result plan that decodes its result: a select statement or a mutation.
-*
-* With `tables`, such as the tables of the schema of a `Db`, an occurrence or an interpolated name of any other table at any depth of the statement is rejected.
-* `db` is the `Db` that runs the statement: a table interpolated from a query bound to another `Db`, or to any `Db` without it, is rejected.
-*/
-function compileStatement(node, options = {}, tables, db) {
-	const context = new CompileContext(options.schemaName, tables, db);
-	switch (node.kind) {
-		case "select": return {
-			text: compileQuery(context, void 0, node),
-			parameters: context.parameters,
-			fields: node.projections,
-			recordTemplate: node.recordTemplate,
-			conversion: node.conversion,
-			rows: node.rows,
-			value: node.value,
-			counted: void 0,
-			locksRows: context.locksRows
-		};
-		default: {
-			const { returning } = node;
-			return {
-				text: compileMutation(context, node),
-				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,
-				locksRows: false
-			};
-		}
-	}
-}
-/**
-* Compiles the SQL text of a statement, such as of `$query`, with the checks of `compileStatement` of the tables that it names.
-*
-* It has no result plan: the query of SQL text that runs it holds its own.
-*/
-function compileTextStatement(node, options = {}, tables, db) {
-	const context = new CompileContext(options.schemaName, tables, db);
-	const text = compileExpression(context, void 0, node);
-	return createStatement$1(text, context.parameters);
-}
-/** 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)}${compileConflict(context, scope, node)}`;
-			break;
-		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;
-		default: return node;
-	}
-	const { returning } = node;
-	if (returning !== void 0 && returning.length > 0) text += ` RETURNING${compileProjections(context, scope, returning)}`;
-	return text;
-}
-/** Compiles the columns and the rows of `VALUES` of an insert, or `DEFAULT VALUES` for one row of the defaults of every column. */
-function compileValues(context, node) {
-	const { columns, values } = node;
-	if (columns.length === 0) {
-		if (values.length !== 1) throw new Error("An insert of several rows must list a column");
-		return " DEFAULT VALUES";
-	}
-	let text = " (";
-	for (let index = 0; index < columns.length; index++) text += `${index === 0 ? "" : ", "}${compileColumnName(node.target, columns[index])}`;
-	text += ") VALUES";
-	for (let row = 0; row < values.length; row++) {
-		const items = values[row];
-		text += row === 0 ? " (" : ", (";
-		for (let index = 0; index < items.length; index++) {
-			const item = items[index];
-			text += `${index === 0 ? "" : ", "}${item === void 0 ? "DEFAULT" : compileExpression(context, void 0, item)}`;
-		}
-		text += ")";
-	}
-	return text;
-}
-/** 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);
-}
-/** Compiles a query at a position of the statement where the sources of `outer` are visible. */
-function compileQuery(context, outer, node) {
-	const { from } = node;
-	if (from === void 0 && node.joins.length > 0) throw new Error("A query without FROM cannot join sources");
-	const fromScope = from === void 0 ? void 0 : declareSource(context, outer, from);
-	let scope = fromScope ?? outer;
-	const joinScopes = [];
-	for (const join of node.joins) {
-		scope = declareSource(context, scope, join.source);
-		joinScopes.push(scope);
-	}
-	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++) {
-			const joinScope = joinScopes[index];
-			text += ` LEFT JOIN ${compileSource(context, outer, joinScope)} ON ${compileExpression(context, joinScope, node.joins[index].on)}`;
-		}
-	}
-	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. */
-function compileProjections(context, scope, projections) {
-	let text = "";
-	for (let index = 0; index < projections.length; index++) {
-		const projection = projections[index];
-		text += `${index === 0 ? " " : ", "}${compileExpression(context, scope, projection.expression)} AS ${quoteIdentifier(nameProjection(projection.key, index))}`;
-	}
-	return text;
-}
-/** Compiles the `WHERE` clause of the effective predicate of `filters` after a space, or nothing when they restrict no row. */
-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";
-	for (let index = 0; index < orderBy.length; index++) {
-		const order = orderBy[index];
-		text += `${index === 0 ? " " : ", "}${compileExpression(context, scope, order.expression)}`;
-		if (order.direction === "desc") text += " DESC";
-		if (order.nulls !== void 0) text += order.nulls === "first" ? " NULLS FIRST" : " NULLS LAST";
-	}
-	return text;
-}
-/** Compiles a declared source of a query at a position of the statement where the sources of `outer` are visible. */
-function compileSource(context, outer, declared) {
-	const { source, alias } = declared;
-	if (source.kind === "table") return `${compileTableName(context, source.table)} AS ${quoteIdentifier(alias)}`;
-	const query = compileQuery(context, source.lateral ? declared.outer : outer, source.query);
-	return `${source.lateral ? "LATERAL " : ""}(${query}) AS ${quoteIdentifier(alias)}`;
-}
-/** Compiles the name of `table`, qualified by the PostgreSQL schema of the statement, rejecting a table outside the tables of the statement. */
-function compileTableName(context, table) {
-	if (context.tables !== void 0 && !context.tables.has(table)) throw new Error(`Table "${table.name}" is not part of the schema`);
-	return context.schemaName === void 0 ? quoteIdentifier(table.name) : `${quoteIdentifier(context.schemaName)}.${quoteIdentifier(table.name)}`;
-}
-/** Compiles the name of a table interpolated into a SQL fragment, rejecting a table of a query bound to a `Db` other than the one that runs the statement. */
-function compileInterpolatedTable(context, node) {
-	const { db, table } = node;
-	if (db !== void 0 && db !== context.db) throw new Error(context.db === void 0 ? `Table "${table.name}" interpolated into SQL is bound to a Db, so only that Db can compile the query` : `Table "${table.name}" interpolated into SQL is bound to another Db`);
-	return compileTableName(context, table);
-}
-function compileColumn(scope, node) {
-	const { key } = node;
-	const declared = resolveSource(scope, node);
-	const { source } = declared;
-	let name;
-	if (source.kind === "table") name = requireColumn(source.table, key).attributes.name ?? key;
-	else {
-		const index = source.query.projections.findIndex((projection) => projection.key === key);
-		if (index === -1) throw new Error(`Unknown field "${key}" of a subquery`);
-		name = nameProjection(key, index);
-	}
-	return `${quoteIdentifier(declared.alias)}.${quoteIdentifier(name)}`;
-}
-function compileExpression(context, scope, node) {
-	switch (node.kind) {
-		case "column": return compileColumn(scope, node);
-		case "param": return context.bind(encodeParameter(node.value, node.type));
-		case "cast": {
-			const { operand } = node;
-			return `${operand.kind === "param" ? context.bindParam(node, encodeParameter(operand.value, operand.type)) : 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 ");
-		case "not": return `NOT ${compileOperand(context, scope, node.operand, "condition")}`;
-		case "values": throw new Error("An object condition can only be used in `where`");
-		case "nestedQuery": throw new Error("A query in an expression must be lowered before compilation");
-		case "comparison": return `${compileOperand(context, scope, node.left, "value")} ${node.operator} ${compileOperand(context, scope, node.right, "value")}`;
-		case "in": {
-			let text = `${compileOperand(context, scope, node.operand, "value")} IN (${compileOperand(context, scope, node.list[0], "value")}`;
-			for (let index = 1; index < node.list.length; index++) text += `, ${compileOperand(context, scope, node.list[index], "value")}`;
-			return `${text})`;
-		}
-		case "inQuery": {
-			const { query } = node;
-			if (query.kind === "nestedQuery") throw new Error("A query in an expression must be lowered before compilation");
-			return `${compileOperand(context, scope, node.operand, "value")} IN ${compileSubquery(context, scope, query, "A subquery of IN")}`;
-		}
-		case "isNull": return `${compileOperand(context, scope, node.operand, "value")} IS NULL`;
-		case "raw": {
-			let text = node.fragments[0];
-			for (let index = 0; index < node.values.length; index++) text += compileOperand(context, scope, node.values[index], "interpolation") + node.fragments[index + 1];
-			return text;
-		}
-		case "fragment": return renderFragment(node.fragment, context);
-		case "tableName": return compileInterpolatedTable(context, node);
-		case "subquery": return compileSubquery(context, scope, node.query, "A scalar subquery");
-		case "exists": return `EXISTS (${compileQuery(context, scope, node.query)})`;
-		case "textSubquery": return `(${compileQuery(context, scope, node.query)})`;
-		case "aggregate": {
-			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)}`;
-			text += ")";
-			if (node.filter !== void 0) text += ` FILTER (WHERE ${compileExpression(context, scope, node.filter)})`;
-			return text;
-		}
-		default: return node;
-	}
-}
-/** Compiles `query` in parentheses as a subquery of one field, and rejects a query of another number of fields, naming the subquery as `subject`. */
-function compileSubquery(context, scope, query, subject) {
-	const { length } = query.projections;
-	if (length !== 1) throw new Error(`${subject} must select one field, not ${length}`);
-	return `(${compileQuery(context, scope, query)})`;
-}
-/** Compiles an operand at `position` of its parent, parenthesizing it where its own operators could regroup with the parent. */
-function compileOperand(context, scope, node, position) {
-	const sql = compileExpression(context, scope, node);
-	return needsParentheses(node.kind, position) ? `(${sql})` : sql;
-}
-// 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 toKeyList(key) {
-	return Object.freeze(Array.isArray(key) ? key.slice() : [key]);
-}
-/**
-* Defines relation `name` of table `source`, declared under its key `key` in a schema, checking its target and its keys.
-*
-* `findKey` returns the key of a table in the schema, or `undefined` for a table outside it.
-* Each pair of columns of the keys must satisfy `isEqualityCompatible`, the columns `to` of a relation `one` must include a key of the target, and the columns `from` of a required relation must not be nullable by `isNullable` of their types.
-*/
-function defineRelation(source, key, name, declaration, findKey) {
-	const subject = `Relation "${formatRelationName(key, name)}"`;
-	if (!isRelationDeclaration(declaration)) throw new TypeError(`${subject} must be declared with many or one`);
-	if (name.startsWith("$")) throw new Error(`${subject}: a relation name must not start with "$"`);
-	if (findColumn(source, name)) throw new Error(`${subject}: a relation name must differ from the column keys of table "${source.name}"`);
-	const { kind, target, from, to, required } = declaration;
-	const targetKey = findKey(target);
-	if (targetKey === void 0) throw new Error(`${subject} refers to table "${target.name}", which is not part of the schema`);
-	if (from.length === 0 || from.length !== to.length) throw new Error(`${subject} must list as many columns in "to" as in "from", at least one`);
-	for (let index = 0; index < from.length; index++) {
-		const fromColumn = findColumn(source, from[index]);
-		if (!fromColumn) throw new Error(`${subject}: unknown column "${from[index]}" of table "${source.name}"`);
-		if (required && fromColumn.type.isNullable) throw new Error(`${subject} cannot be required: column "${from[index]}" of table "${source.name}" is nullable`);
-		const toColumn = findColumn(target, to[index]);
-		if (!toColumn) throw new Error(`${subject}: unknown column "${to[index]}" of table "${target.name}"`);
-		if (!isEqualityCompatible(fromColumn.type, toColumn.type)) throw new Error(`${subject} cannot compare column "${from[index]}" (${fromColumn.type.sqlType}) with column "${to[index]}" (${toColumn.type.sqlType}) of table "${target.name}" by SQL =`);
-	}
-	if (kind === "one" && !containsKey(target, to)) throw new Error(`${subject}: columns "to" must include a key of table "${target.name}", primary or unique`);
-	return Object.freeze({
-		kind,
-		name,
-		key,
-		source,
-		target,
-		targetKey,
-		from,
-		to,
-		required
-	});
-}
-/** Adds `definition` of relation `name` of the table under `key` to `relations`, rejecting another definition of the relation there. */
-function addRelation(relations, key, name, definition) {
-	let named = relations.get(key);
-	if (named === void 0) {
-		named = /* @__PURE__ */ new Map();
-		relations.set(key, named);
-	}
-	const existing = named.get(name);
-	if (existing !== void 0 && existing !== definition) throw new Error(`Relation "${formatRelationName(key, name)}" has two different definitions`);
-	named.set(name, definition);
-}
-/** Adds the relation definitions of a schema to `relations`, rejecting another definition of a relation there. */
-function addRelations(relations, added) {
-	for (const key of Object.keys(added)) {
-		const named = added[key];
-		for (const name of Object.keys(named)) addRelation(relations, key, name, named[name]);
-	}
-}
-/** Collects the relation definitions of a schema, which a `Db` of the schema accepts in its queries. */
-function collectDefinitions(relations) {
-	const definitions = /* @__PURE__ */ new Set();
-	for (const key of Object.keys(relations)) {
-		const named = relations[key];
-		for (const name of Object.keys(named)) definitions.add(named[name]);
-	}
-	return definitions;
-}
-/** Creates frozen relations of a schema from `relations`; objects without a prototype keep any key, such as `__proto__`, an own property. */
-function freezeRelations(relations) {
-	const result = Object.create(null);
-	for (const [key, named] of relations) {
-		const table = Object.create(null);
-		for (const [name, definition] of named) table[name] = definition;
-		result[key] = Object.freeze(table);
-	}
-	return Object.freeze(result);
-}
-function isRelationDeclaration(value) {
-	return typeof value === "object" && value !== null && declarationBrand in value;
-}
-// 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";
-}
-/** 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;
-}
-// 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 a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation.
-*
-* 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 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
-	});
-}
-/** 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;
-}
-/** 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/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
-/**
-* 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.
-*
-* It returns `node` itself when it holds no query, and creates only the nodes that hold one.
-*/
-function lowerExpression(node, context) {
-	switch (node.kind) {
-		case "column":
-		case "param":
-		case "boolean":
-		case "values":
-		case "fragment":
-		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
-	});
-}
-/**
-* 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 "fragment":
-		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);
-	});
-}
-/**
-* 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.
-*
-* 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 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 found;
-}
-/**
-* Tells whether an aggregate belongs to an enclosing query rather than the query of `source`.
-*
-* 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 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;
-}
-/** 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;
-}
-/**
-* 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 "column":
-		case "param":
-		case "boolean":
-		case "fragment":
-		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;
-	}
-}
-/**
-* 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, 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);
-			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
-			});
-		}
-		case "update": {
-			const set = lowerEach(node.set, context, lowerAssignment);
-			const filters = lowerFilters(node.filters, context);
-			if (lowered === returning && set === node.set && filters === node.filters) return node;
-			return Object.freeze({
-				kind: "update",
-				target,
-				set,
-				filters,
-				returning: lowered,
-				recordTemplate,
-				conversion,
-				rows,
-				value
-			});
-		}
-		case "delete": {
-			const filters = lowerFilters(node.filters, context);
-			if (lowered === returning && filters === node.filters) return node;
-			return Object.freeze({
-				kind: "delete",
-				target,
-				filters,
-				returning: lowered,
-				recordTemplate,
-				conversion,
-				rows,
-				value
-			});
-		}
-		default: return node;
-	}
-}
-/** Lowers a row of `VALUES` of an insert, whose `undefined` stands for `DEFAULT`. */
-function lowerRow(row, context) {
-	return lowerEach(row, context, lowerValue);
-}
-/** 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);
-	return value === assignment.value ? assignment : Object.freeze({
-		key: assignment.key,
-		value
-	});
-}
-// src/lowering/page.ts
-/**
-* 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.
-*
-* 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 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(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, groupBy, distinctOn)) {
-			if (mayAggregateSource(expression, from)) return;
-			collectColumnKeys(expression, from, columnKeys);
-		} else if (expression.kind === "column" && expression.source === from) columnKeys.add(expression.key);
-		else {
-			key = `$field${index + 1}`;
-			fields.push(Object.freeze({
-				key,
-				expression,
-				type: text
-			}));
-		}
-		fieldKeys.push(key);
-	}
-	const sourced = [];
-	for (const key of columnKeys) sourced.push(Object.freeze({
-		key,
-		expression: createNode({
-			kind: "column",
-			source: from,
-			key
-		}),
-		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: query.filters,
-		groupBy,
-		having: query.having,
-		orderBy,
-		limit: query.limit,
-		offset,
-		distinctOn,
-		rows: "many",
-		value: false,
-		guaranteedBy: void 0
-	}, true, offset, from);
-	const selected = [];
-	for (let index = 0; index < projections.length; index++) {
-		const projection = projections[index];
-		const key = fieldKeys[index];
-		selected.push(key === void 0 ? projection : Object.freeze({
-			key: projection.key,
-			expression: createNode({
-				kind: "column",
-				source: page.source,
-				key
-			}),
-			type: projection.type
-		}));
-	}
-	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: query.rows,
-		value: query.value,
-		guaranteedBy: query.guaranteedBy,
-		recordTemplate: query.recordTemplate
-	});
-}
-/**
-* 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.
-*
-* The query evaluates a field that it sorts by, groups by, or compares, of an aggregate or of `exists`, for every row anyway.
-*/
-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 "query": return lowerSelect(node, context, true);
-		case "record": return lowerRecord(node, context);
-		default: return lowerMutation(node, context);
-	}
-}
-/** Lowers the SQL text of a statement, such as of `$query`, replacing the queries in the expressions interpolated into it, and checking them as `lowerStatement` does. */
-function lowerTextStatement(node, definitions, db) {
-	return lowerExpression(node, createContext(definitions, db));
-}
-/** 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 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({
-		kind: "select",
-		from: void 0,
-		joins: noJoins,
-		projections: [projectExists(node.projections[0].key, node, context)],
-		filters: noFilters,
-		orderBy: noOrder,
-		limit: void 0,
-		offset: void 0,
-		rows: node.rows,
-		value: true,
-		guaranteedBy: void 0
-	});
-}
-/** 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({
-		kind: "select",
-		from: void 0,
-		joins: noJoins,
-		projections: lowerProjections(dropLiterals(node.projections), context),
-		filters: noFilters,
-		orderBy: noOrder,
-		limit: void 0,
-		offset: void 0,
-		rows: "one",
-		value: false,
-		guaranteedBy: void 0,
-		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$1(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;
-}
-/**
-* 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.
-*
-* It rejects columns that are not exactly a key of `table`, as `isKey` tells.
-*/
-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;
-}
-/** 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;
-}
-/** Lists `columns` in quotes, separated by commas. */
-function quoteColumns(columns) {
-	return columns.map((column) => `"${column}"`).join(", ");
-}
-// 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") {
-		addTerms(order, first(createSelectionRefs(node.from, context), createSelectedRefs(node, "sorted by")), "The callback of orderBy must return");
-		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;
-}
-/** 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));
-}
-/**
-* Creates the sort key node of a sort key, `OrderTerm` checked at runtime, whose error starts with `subject`.
-*
-* A query is converted by the method of `operandNode`, which rejects a query other than of one value.
-*/
-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
-			});
-		} 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"
-};
-/**
-* Creates the keys of `method`, `groupBy` or `distinctOn`, of `node` with the keys of the arguments of the call after its own.
-*
-* `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 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));
-	}
-	if (keys.length === existing.length) throw new TypeError(`${method} requires at least one key`);
-	return keys;
-}
-/**
-* 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]);
-}
-/**
-* 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
-/**
-* Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and of literals and the results of independent queries, selected in one statement.
-*
-* 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 RecordQuery = 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);
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-	[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 $select");
-	}
-};
-/**
-* Starts the query of `$select` of `selection`, an object of expressions, queries, and literals by key, bound to `db` when given.
-*
-* It reads the keys and values of `selection` when it is called.
-*/
-function startRecordQuery(selection, db) {
-	const projections = [];
-	addSelection(projections, selection);
-	return new RecordQuery(Object.freeze({
-		kind: "record",
-		projections
-	}), db);
-}
-// src/query/projections.ts
-/**
-* Creates the fields of `select` over `source`, appending new keys and replacing existing ones in place.
-*
-* `args` are the arguments of `select`: `"*"`, column keys, or a callback that receives the references of `source` with the relations of `context` and returns a selection.
-*/
-function mergeProjections(projections, source, args, context) {
-	const result = projections.slice();
-	const first = args[0];
-	if (typeof first === "function") addSelection(result, first(createSelectionRefs(source, context)));
-	else {
-		const keys = first === "*" ? Object.keys(source.table.columns) : args;
-		for (const key of keys) setProjection(result, projectColumn(source, key));
-	}
-	return result;
-}
-/** Adds the fields of `selection`, expressions, queries, and literals by key, to `projections`, replacing existing keys in place. */
-function addSelection(projections, selection) {
-	for (const key of Reflect.ownKeys(selection)) {
-		if (typeof key === "symbol") throw new TypeError("A selected field must have a string key");
-		setProjection(projections, selectValue(key, selection[key]));
-	}
-}
-/**
-* Creates the projection of the value of `get` or `pluck`, or of the argument of an aggregate method, such as `max`, over `source`.
-*
-* `arg` is the argument of `method`: a column key, or a callback that receives the references of `source` with the relations of `context` and returns an expression or a query of one value.
-* The value of such a query is that of `expr`, `NULL` without its row, since the projection holds one scalar rather than nested rows.
-*/
-function projectValue(source, arg, method, context) {
-	if (typeof arg !== "function") return projectColumn(source, arg);
-	const result = arg(createSelectionRefs(source, context));
-	const value = result instanceof SelectQuery ? result.expr() : result;
-	if (!isExpression(value)) throw new TypeError(`The callback of ${method} must return an expression or a query of one value`);
-	const type = getType(value);
-	if (!type) throw new TypeError(`The expression of ${method} has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
-	return projectExpression("value", value, type);
-}
-/**
-* Creates the projection of the value of `field`, the only projection of a query of values, whose `NULL` `fallback` replaces: a value that the type of the field encodes, an expression, or a query of one value.
-*
-* The projection of an aggregate keeps its call, which lowering builds, and adds the fallback after its earlier ones.
-* The projection of `exists` stays as it is, since `EXISTS` is never `NULL`.
-*/
-function coalesceValue(field, fallback) {
-	const value = toFunctionOperandNode(fallback, field.type, "coalesce");
-	if (isExistsProjection(field)) return field;
-	if (isAggregateProjection(field)) return addFallback(field, value);
-	return Object.freeze({
-		key: field.key,
-		expression: createList("coalesce(", [field.expression, value], ")"),
-		type: field.type
-	});
-}
-/** Creates the field of a value of a selection under `key`: an expression with a type, a query whose rows become its value, or a literal. */
-function selectValue(key, value) {
-	if (value instanceof Literal) return Object.freeze({
-		key,
-		literal: value.literal
-	});
-	if (value instanceof SelectQuery || value instanceof TransformedQuery) return Object.freeze({
-		key,
-		query: value.node,
-		db: value.db
-	});
-	if (value instanceof RecordQuery) throw new TypeError(`Selected field "${key}" is a query of $select, which cannot be nested; select its fields directly instead`);
-	if (value instanceof MutationQuery) throw new TypeError(`Selected field "${key}" is a query of insert, update, or delete, which cannot be nested`);
-	if (value instanceof SqlQuery) throw new TypeError(`Selected field "${key}" is a query of SQL text, which cannot be nested`);
-	if (!isExpression(value)) throw new TypeError(`Selected field "${key}" must be an expression, a query, or a literal`);
-	const type = getType(value);
-	if (!type) throw new TypeError(`Selected field "${key}" has no type to decode its values; build a sql fragment with a type, such as sql(t.integer)`);
-	return projectExpression(key, value, type);
-}
-/** Creates the projection of a column of the table of `source` under its key. */
-function projectColumn(source, key) {
-	const { type } = requireColumn(source.table, key);
-	return Object.freeze({
-		key,
-		expression: createNode({
-			kind: "column",
-			source,
-			key
-		}),
-		type
-	});
-}
-/** Creates the projection of an expression under `key`, decoded with `type`, the type of the expression. */
-function projectExpression(key, value, type) {
-	return Object.freeze({
-		key,
-		expression: toNode(value),
-		type
-	});
-}
-/** Adds or replaces a field by key, rejecting a key that a record cannot have. */
-function setProjection(projections, projection) {
-	const { key } = projection;
-	if (!isRecordKey(key)) throw new Error(`Field "${key}" cannot be selected: it is not a valid record key`);
-	for (let index = 0; index < projections.length; index++) if (projections[index].key === key) {
-		projections[index] = projection;
-		return;
-	}
-	projections.push(projection);
-}
-// src/query/values.ts
-/**
-* Returns the columns and the rows of `VALUES` of an insert of `records`, at least one, into `table`, reading the keys and values of each record when it is called.
-*
-* The columns are those that some record gives a value other than `undefined`, in the order that the records first give them, and a record that omits one inserts its `DEFAULT`.
-* Several records without values insert the `DEFAULT` of the first column of the table, since `DEFAULT VALUES` inserts one row.
-* It rejects a key that is not a column of `table`, and a query other than of one value.
-*/
-function toInsertRows(table, records, method) {
-	if (records.length === 0) throw new Error(`${method} takes at least one record`);
-	const columns = [];
-	const rows = [];
-	for (const record of records) {
-		if (typeof record !== "object" || record === null) throw new TypeError(`${method} takes records of the values of the columns of table "${table.name}"`);
-		const row = [];
-		for (const key of Object.keys(record)) {
-			const value = record[key];
-			if (value === void 0) continue;
-			let index = columns.indexOf(key);
-			if (index === -1) index = columns.push(key) - 1;
-			row[index] = resolveValue(table, key, value);
-		}
-		rows.push(row);
-	}
-	if (columns.length === 0 && rows.length > 1) {
-		const first = Object.keys(table.columns)[0];
-		if (first !== void 0) columns.push(first);
-	}
-	for (const row of rows) while (row.length < columns.length) row.push(void 0);
-	return {
-		columns,
-		values: rows
-	};
-}
-/**
-* 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, excluded) {
-	const { table } = source;
-	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)) {
-		const value = values[key];
-		if (value !== void 0) assignments.push(Object.freeze({
-			key,
-			value: resolveValue(table, key, value)
-		}));
-	}
-	if (assignments.length === 0) throw new Error(`update takes the value of at least one column of table "${table.name}"; a column given as undefined keeps its value`);
-	return assignments;
-}
-/** Returns the node of `value` of the column of `table` under `key`: an expression or a query of one value, which lowering replaces with a scalar subquery, or a parameter encoded with the type of the column. */
-function resolveValue(table, key, value) {
-	return toValueNode(value, requireColumn(table, key).type);
-}
-// src/query/mutation.ts
-/**
-* 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, 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.
-*/
-var MutationQuery = class MutationQuery {
-	table;
-	node;
-	context;
-	/** `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(table, node, context, db) {
-		this.table = table;
-		this.node = node;
-		this.context = context;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		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");
-		return this.derive({
-			returning: mergeProjections(returning ?? [], node.target, args, this.context),
-			value: false
-		});
-	}
-	get(arg) {
-		if (this.node.rows === "many") throw new Error("get applies only to a query that changes one row, such as of insert or find; use pluck to return the values of several rows");
-		return this.deriveValue(arg, "get");
-	}
-	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);
-	}
-	/** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-	[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 insert, update, or delete");
-	}
-	/** Creates a mutation of the same kind and `Db` with the node changes applied. */
-	derive(changes) {
-		return new MutationQuery(this.table, Object.freeze({
-			...this.node,
-			...changes
-		}), this.context, this.db);
-	}
-	/** 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)],
-			value: true,
-			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;
-	const { columns, values } = toInsertRows(node.from.table, records, method);
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "insert",
-		target: node.from,
-		columns,
-		values,
-		returning: void 0,
-		rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the update of the rows of `query` that `set` gives, as `update` takes it, in the rows mode of the query. */
-function createUpdate(query, set) {
-	const { node } = query;
-	checkChangedRows(node, "update");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "update",
-		target: node.from,
-		set: toAssignments(node.from, set, query.context),
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), query.context, query.db);
-}
-/** Creates the delete of the rows of `query`, in the rows mode of the query. */
-function createDelete(query) {
-	const { node } = query;
-	checkChangedRows(node, "delete");
-	return new MutationQuery(query.table, Object.freeze({
-		kind: "delete",
-		target: node.from,
-		filters: node.filters,
-		returning: void 0,
-		rows: node.rows,
-		value: false
-	}), 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 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.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 (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. */
-function createPageCount(node, method, count) {
-	if (node.rows !== "many") throw new Error(`${method} applies only to a query of many rows${createPaginationHint(node)}`);
-	if (!Number.isSafeInteger(count) || count < 0) throw new RangeError(`${method} takes a non-negative integer, not ${count}`);
-	return createNode({
-		kind: "param",
-		value: count,
-		type: void 0
-	});
-}
-/** 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 === 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";
-}
-// src/query/select.ts
-/**
-* Immutable select query of state `S`, unbound or bound to a `Db`.
-*
-* Every method returns a query of the same kind and leaves this query unchanged.
-* 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 SelectQuery = class SelectQuery {
-	table;
-	node;
-	context;
-	/** `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(table, node, context, db) {
-		this.table = table;
-		this.node = node;
-		this.context = context;
-		this.db = db;
-		this.then = db === void 0 ? void 0 : executeOnAwait;
-		Object.freeze(this);
-	}
-	where(filter) {
-		return this.derive(this.addFilter(filter));
-	}
-	select(...args) {
-		this.rejectValue("select");
-		return this.derive({ projections: mergeProjections(this.node.projections, this.node.from, args, this.context) });
-	}
-	clearSelect() {
-		this.rejectValue("clearSelect");
-		return this.derive({ projections: [] });
-	}
-	take() {
-		return this.deriveTaken({});
-	}
-	find(...values) {
-		return this.takeWhere(toPrimaryKeyValues(this.table, values));
-	}
-	findBy(values) {
-		return this.takeWhere(toKeyValues(this.table, values));
-	}
-	get(arg) {
-		this.rejectAggregate("get");
-		return this.deriveTaken({
-			projections: [projectValue(this.node.from, arg, "get", this.context)],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	pluck(arg) {
-		this.rejectAggregate("pluck");
-		return this.derive({
-			projections: [projectValue(this.node.from, arg, "pluck", this.context)],
-			value: true,
-			rows: toValueRows(this.node.rows)
-		});
-	}
-	count(arg) {
-		if (arg !== void 0) return this.aggregateBy("count", arg);
-		this.rejectAggregation("count");
-		return this.deriveAggregate(countProjection);
-	}
-	countDistinct(arg) {
-		return this.aggregateBy("countDistinct", arg);
-	}
-	min(arg) {
-		return this.aggregateBy("min", arg);
-	}
-	max(arg) {
-		return this.aggregateBy("max", arg);
-	}
-	sum(arg) {
-		return this.aggregateBy("sum", arg);
-	}
-	avg(arg) {
-		return this.aggregateBy("avg", arg);
-	}
-	every(arg) {
-		return this.aggregateBy("every", arg);
-	}
-	some(arg) {
-		return this.aggregateBy("some", arg);
-	}
-	stringAgg(arg, delimiter) {
-		return this.aggregateBy("stringAgg", arg, delimiter);
-	}
-	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)] });
-	}
-	expr() {
-		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) });
-	}
-	limit(count) {
-		return this.derive({ limit: createPageCount(this.node, "limit", count) });
-	}
-	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 && 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() {
-		return this.changeOneRow("required", "one");
-	}
-	insert(values) {
-		return createInsert(this, [values], "one", "insert");
-	}
-	insertMany(records) {
-		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);
-	}
-	delete() {
-		return createDelete(this);
-	}
-	all() {
-		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");
-	}
-	toSQL(options) {
-		return compileToSQL(this, options);
-	}
-	/**
-	* Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
-	*
-	* It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
-	*/
-	[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,
-			db: this.db
-		});
-	}
-	/**
-	* Returns the node of the query as the values of `in`, which lowering replaces with its statement.
-	*
-	* It rejects a query of records, which `ValuesQuery` rejects in types.
-	*/
-	[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, 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);
-	}
-	/**
-	* Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
-	*
-	* It adds the changes of `take` to `changes`, which must leave the limit as it is.
-	*/
-	deriveTaken(changes) {
-		if ((changes.rows ?? this.node.rows) === "many") {
-			changes.limit = limitToOne(this.node.limit);
-			changes.rows = "one";
-		}
-		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.
-	*
-	* 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) {
-		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.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. */
-	addFilter(filter) {
-		const { node } = this;
-		return {
-			filters: addUserFilter(node.filters, filter, node.from, this.context),
-			rows: this.getFilteredRows(),
-			guaranteed: false
-		};
-	}
-	/** 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. */
-	changeOneRow(method, rows) {
-		if (this.node.rows === "many") throw new Error(`${method} applies only to a query of one row, such as one made by take`);
-		return this.derive({
-			rows,
-			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`, 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 (!(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);
-}
-function from(table) {
-	return startQuery(table, noContext);
-}
-/** Starts a query over a new occurrence of the table with the relations of `context`, such as a query of a table of a schema. */
-function startQuery(table, context) {
-	return new SelectQuery(table, createQueryNode(Object.freeze({
-		kind: "table",
-		table
-	})), context);
-}
+import { C as defineType, D as equalityOperators, F as falseNode, M as createList, N as createNode, R as noOrder, S as getBooleanType, T as isType$1, V as trueNode, _ as toCastValueNode, b as toNode, c as compare, d as getType, f as isExpression, g as toBooleanExpression, i as textOperators, j as defineGenericOperator, m as operandNode, p as isOperandSource, s as orderingOperators, v as toExpression, w as describeRejectedDbType, x as toValueNode, y as toFunctionOperandNode } from "./text-ucmJCsCN.mjs";
+import { A as countProjection, B as combineNodes, D as compileTextStatement, E as compileStatement, F as literal, I as and, L as isColumnValues, M as createAggregateCall, N as createCountCall, O as createTableFactory, P as toAggregateType, R as not, S as collectDefinitions, T as one, _ as matchColumn, a as SelectQuery, b as lowerTextStatement, c as requireDerived, d as RecordQuery, f as startRecordQuery, g as orderBy, h as desc, i as createQueryContexts, j as countType, k as defineTable, l as startQuery, m as asc, n as defineSchema, o as bindQuery, p as addTerms, r as schemaRelations, s as from, t as defineEntries, u as MutationQuery, v as TransformedQuery, w as many, x as isTableQuery, y as lowerStatement, z as or } from "./schema-lVpsWpEF.mjs";
+import { SqlFragment, SqlQuery, assertUntypedValue, createFieldDecodeError, createResultDecodeError, startSqlQuery, takeOnlyRow, toMissingResult } from "kern-db/builder";
+import { ConnectionError, NotFoundError, NotFoundError as NotFoundError$1, QueryError, ResultDecodeError, ResultDecodeError as ResultDecodeError$1, TransactionConnectionError, createDatabase, createStatement, createStatement as createStatement$1, identifier as identifier$1, isDatabase, isOutcomeUnknown, isQueryError, toDriverError } from "kern-db";
+import { AsyncLocalStorage } from "node:async_hooks";
+// src/expression/constants.ts
+/** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
+const TRUE = /* @__PURE__ */ toExpression(trueNode, /* @__PURE__ */ getBooleanType());
+/** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
+const FALSE = /* @__PURE__ */ toExpression(falseNode, /* @__PURE__ */ getBooleanType());
 // src/expression/functions.ts
 function coalesce(first, ...rest) {
 	return callFunction("coalesce", first, rest);
@@ -4012,122 +450,13 @@ function toInterpolatedNode(value) {
 	if (!isOperandSource(value)) assertUntypedValue(value);
 	return toValueNode(value);
 }
-// src/query/relations.ts
-/** Creates the contexts of the queries of the tables under `keys` in a schema of relations `relations`, by table key. */
-function createQueryContexts(keys, relations) {
-	const contexts = Object.create(null);
-	for (const key of keys) {
-		const named = relations[key];
-		if (named === void 0) {
-			contexts[key] = noContext;
-			continue;
-		}
-		const getters = Object.create(null);
-		for (const name of Object.keys(named)) {
-			const definition = named[name];
-			getters[name] = Object.freeze({
-				get() {
-					return startRelated(this, definition, contexts[definition.targetKey]);
-				},
-				enumerable: true
-			});
-		}
-		contexts[key] = Object.freeze({ relations: Object.freeze(getters) });
-	}
-	return Object.freeze(contexts);
-}
-/**
-* Starts the query of the records of relation `definition` of the row of `parent`, the references of the callback of a query, in the context of the target table.
-*
-* The relation filter compares the key columns of the target with those of `parent` with SQL `=` directly rather than with the `eq` operators of their types, which a custom type can replace.
-*/
-function startRelated(parent, definition, context) {
-	const { target, from, to } = definition;
-	const source = Object.freeze({
-		kind: "table",
-		table: target
-	});
-	const conditions = [];
-	for (let index = 0; index < from.length; index++) conditions.push(createNode({
-		kind: "comparison",
-		operator: "=",
-		left: createNode({
-			kind: "column",
-			source,
-			key: to[index]
-		}),
-		right: toNode(parent[from[index]])
-	}));
-	return new SelectQuery(target, createQueryNode(source, definition, Object.freeze({ relation: combineNodes("and", conditions) })), context);
-}
-// src/schema/schema.ts
-const schemaBrand = Symbol("kern-orm.schema");
-/** Key of the relation definitions of a schema, which composition reads. */
-const schemaRelations = Symbol("kern-orm.schema.relations");
-/**
-* Defines a schema of the tables of `parts`, keyed by their names in queries.
-*
-* A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
-* A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
-*/
-function defineSchema(...parts) {
-	const tables = /* @__PURE__ */ new Map();
-	const keys = /* @__PURE__ */ new Map();
-	const relations = /* @__PURE__ */ new Map();
-	for (const part of parts) {
-		const partTables = isSchema(part) ? part.$tables : part;
-		for (const key of Object.keys(partTables)) {
-			if (key.startsWith("$")) throw new Error(`Table key "${key}" must not start with "$"`);
-			const table = partTables[key];
-			const keyTable = tables.get(key);
-			if (keyTable !== void 0 && keyTable !== table) throw new Error(`Table key "${key}" refers to two different tables`);
-			const tableKey = keys.get(table);
-			if (tableKey !== void 0 && tableKey !== key) throw new Error(`Table "${table.name}" is included under two keys, "${tableKey}" and "${key}"`);
-			tables.set(key, table);
-			keys.set(table, key);
-		}
-		if (isSchema(part)) addRelations(relations, part[schemaRelations]);
-	}
-	return createSchema(Object.freeze(Object.fromEntries(tables)), keys, freezeRelations(relations));
-}
-/** Creates a schema of tables and relation definitions that are already checked; `keys` gives the key of each table. */
-function createSchema(tables, keys, relations) {
-	const methods = {
-		[schemaBrand]: true,
-		$tables: tables,
-		[schemaRelations]: relations,
-		$relations(declarations) {
-			const added = /* @__PURE__ */ new Map();
-			addRelations(added, relations);
-			for (const key of Object.keys(declarations)) {
-				if (!Object.hasOwn(tables, key)) throw new Error(`Relations are declared for table key "${key}", which is not part of the schema`);
-				const named = declarations[key];
-				if (named === void 0) continue;
-				for (const name of Object.keys(named)) addRelation(added, key, name, defineRelation(tables[key], key, name, named[name], (table) => keys.get(table)));
-			}
-			return createSchema(tables, keys, freezeRelations(added));
-		},
-		$select: (selection) => startRecordQuery(selection)
-	};
-	const contexts = createQueryContexts(Object.keys(tables), relations);
-	return defineEntries(methods, tables, (key) => startQuery(tables[key], contexts[key]));
-}
-function isSchema(part) {
-	return schemaBrand in part;
-}
-/** Adds a getter per table key to `methods` that starts a query with `start`, and freezes the result. */
-function defineEntries(methods, tables, start) {
-	const result = Object.defineProperties(methods, Object.fromEntries(Object.keys(tables).map((key) => [key, {
-		get: () => start(key),
-		enumerable: true
-	}])));
-	return Object.freeze(result);
-}
 // src/execution/db.ts
 /**
 * Binds a schema to a database, placing its tables in a PostgreSQL schema.
 *
 * Schemas bound to the same database, such as tenant and SaaS schemas, share its connections and transactions.
+* Given a function instead of a database, such as one that reads it from dependency injection, the `Db` calls it for each statement and at the start of each transaction, session, and lock, in the async context of the caller.
+* The function must return the same database within a transaction or session; in the callback of a transaction or session of the `Db`, a statement for which it returns another database rejects.
 */
 function bindSchema(schema, database, options = {}) {
 	const tables = new Set(Object.values(schema.$tables));
@@ -4135,6 +464,7 @@ function bindSchema(schema, database, options = {}) {
 	const definitions = collectDefinitions(relations);
 	const { schemaName } = options;
 	const resolveSchemaName = () => typeof schemaName === "function" ? schemaName() : schemaName;
+	const { resolveDatabase, executor, track } = createDatabaseResolver(database);
 	function compile(query) {
 		if (query instanceof SqlQuery) throw new TypeError("A query of SQL text executes when it is awaited and compiles with its toSQL, not with $execute or $compile");
 		if (query.db !== void 0 && query.db !== db) throw new Error("Cannot run a query bound to another Db");
@@ -4146,7 +476,9 @@ function bindSchema(schema, database, options = {}) {
 	}
 	const methods = {
 		$schema: schema,
-		$database: database,
+		get $database() {
+			return resolveDatabase();
+		},
 		get $schemaName() {
 			return resolveSchemaName();
 		},
@@ -4156,33 +488,69 @@ function bindSchema(schema, database, options = {}) {
 		},
 		async $execute(query) {
 			const compiled = compile(query);
+			const database = resolveDatabase();
 			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),
 		$query(strings, ...values) {
 			const node = toRawSqlNode(strings, values);
-			return startSqlQuery(() => compileText(node), database);
+			return startSqlQuery(() => compileText(node), executor);
 		},
 		async $script(script, ...values) {
-			if (typeof script === "string") return database.script(script);
+			if (typeof script === "string") return resolveDatabase().script(script);
 			const { text, parameters } = compileText(toRawSqlNode(script, values));
 			if (parameters.length > 0) throw new Error("A script has no parameters, so it takes no values, also in the queries and sql fragments that it interpolates");
-			return database.script(text);
+			return resolveDatabase().script(text);
+		},
+		async $transaction(callback, options) {
+			const database = resolveDatabase();
+			return database.transaction(track(database, callback), options);
+		},
+		async $ensureTransaction(callback) {
+			const database = resolveDatabase();
+			return database.ensureTransaction(track(database, callback));
+		},
+		$isInTransaction: () => resolveDatabase().isInTransaction(),
+		$isInTransactionBlock: () => resolveDatabase().isInTransactionBlock(),
+		async $session(callback, options) {
+			const database = resolveDatabase();
+			return database.session(track(database, callback), options);
 		},
-		$transaction: (callback, options) => database.transaction(callback, options),
-		$ensureTransaction: (callback) => database.ensureTransaction(callback),
-		$isInTransaction: () => database.isInTransaction(),
-		$isInTransactionBlock: () => database.isInTransactionBlock(),
-		$session: (callback, options) => database.session(callback, options),
-		$lock: (key) => database.lock(key),
-		$tryLock: (key) => database.tryLock(key),
-		$pollLock: (key, options) => database.pollLock(key, options)
+		$lock: async (key) => resolveDatabase().lock(key),
+		$tryLock: async (key) => resolveDatabase().tryLock(key),
+		$pollLock: async (key, options) => resolveDatabase().pollLock(key, options)
 	};
 	const contexts = createQueryContexts(Object.keys(schema.$tables), relations);
 	const db = defineEntries(methods, schema.$tables, (key) => bindQuery(startQuery(schema.$tables[key], contexts[key]), db));
 	return db;
 }
+/**
+* Creates the resolver of `database`, the database given to `bindSchema` or a function that returns it.
+*
+* Only the callbacks of the transactions and sessions of the `Db` are checked: a transaction of its database or of another `Db` is not known here, and checking it would require kern-db to expose the transactions of every database in the async context.
+*/
+function createDatabaseResolver(database) {
+	if (typeof database !== "function") return {
+		resolveDatabase: () => database,
+		executor: database,
+		track: (_, callback) => callback
+	};
+	const getDatabase = database;
+	const started = new AsyncLocalStorage();
+	function resolveDatabase() {
+		const resolved = getDatabase();
+		if (!isDatabase(resolved)) throw new TypeError("The function passed to bindSchema must return a database");
+		const current = started.getStore();
+		if (current !== void 0 && current !== resolved) throw new Error("The function passed to bindSchema returned another database inside the callback of a transaction or session of the Db; it must return the same database there");
+		return resolved;
+	}
+	return {
+		resolveDatabase,
+		executor: { execute: (statement) => resolveDatabase().execute(statement) },
+		track: (resolved, callback) => started.getStore() === resolved ? callback : () => started.run(resolved, callback)
+	};
+}
 // src/table/snake-case.ts
 const wordStart = /(?<=[\p{Ll}\p{N}])(?=\p{Lu})|(?<=\p{Lu})(?=\p{Lu}(?!s$)\p{Ll})/gu;
 /**