kern-orm 0.4.0 → 0.6.0

package/dist/database-CP4oapsQ.mjs

@@ -0,0 +1,4693 @@
+import { B as noOrder, C as toNode, D as isType, E as defineType, F as createNode, H as oneNode, I as createSelectNode, L as falseNode, M as valuesQueryNode, O as Column, P as createList, R as noFilters, S as toFunctionOperandNode, T as getBooleanType, U as trueNode, V as noProjections, _ as isOperandSource, a as stringifyJson, b as toCastValueNode, d as orderingOperators, g as isExpression, h as getType, j as isEqualityCompatible, m as createIsNullNode, n as text, p as compareNodes, s as encodeBytea, v as operandNode, w as toValueNode, x as toExpression, y as toBooleanExpression, z as noJoins } from "./text-Cti9QLK7.mjs";
+import { types } from "node:util";
+import { AsyncLocalStorage } from "node:async_hooks";
+// src/ast/boolean.ts
+/** Combines predicate nodes with `AND` or `OR`, flattening nested groups of the same kind. */
+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 (!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/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/result/result.ts
+/** Error thrown when a query of one row finds no row, executed or nested, unless a required relation guarantees the row. */
+var NotFoundError = class extends Error {
+	name = "NotFoundError";
+	/** Path of the missing nested rows from the result field that holds them, such as `user` or `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`; `undefined` when the executed query itself finds no row. */
+	path;
+	constructor(message, path) {
+		super(message);
+		this.path = path;
+	}
+};
+/**
+* Error thrown when a required relation, such as `field.form`, has no record for a row.
+*
+* A required relation promises the record, so its absence means that the database breaks the promise, such as without a foreign key, or that the relation should not be required.
+*/
+var RequiredRelationError = class extends Error {
+	relation;
+	path;
+	name = "RequiredRelationError";
+	constructor(relation, path) {
+		super(`Required relation "${relation}" has no record for result field "${path}"`);
+		this.relation = relation;
+		this.path = path;
+	}
+};
+/** Error thrown when a row does not match the result fields, a value fails to decode, or a callback of `transform` or `map` fails; the failure is its cause. */
+var ResultDecodeError = class extends Error {
+	path;
+	name = "ResultDecodeError";
+	constructor(message, path, options) {
+		super(message, options);
+		this.path = path;
+	}
+};
+/** Tells whether `key` can be a key of a decoded record, such as a column key: assigning `__proto__` would change the prototype of the record instead. */
+function isRecordKey(key) {
+	return key !== "__proto__";
+}
+/**
+* Decodes the result of a statement by its plan: its rows, as `decodeResult` does, or the number of the rows of its command tag, such as of the rows that a mutation changes.
+*
+* A statement of one row that returns its number or a record without fields rejects as a query of one row does: with `NotFoundError` without a row, unless it is optional or nullable, and with several rows.
+*/
+function decodeStatement(plan, result) {
+	const { counted, conversion } = plan;
+	if (counted === void 0) return decodeResult(plan, plan.named ? selectColumns(plan, result) : result.rows);
+	const decoded = decodeCount(plan, counted, result.count);
+	return conversion === void 0 ? decoded : convertTopResult(plan, conversion, decoded, counted === "records" && plan.rows !== "many" && result.count === 0);
+}
+/** Returns what a statement resolves to by `count`, the number of the rows of its command tag, as `counted` tells: the number, or as many records without fields. */
+function decodeCount(plan, counted, count) {
+	if (plan.rows !== "many") {
+		if (count > 1) throw new Error(plan.named ? `Query of one row reported ${count} rows` : `Query of one row changed ${count} rows`);
+		if (count === 0) {
+			if (plan.rows === "one") throw new NotFoundError(plan.named ? "Query reported no rows" : "Query found no row to change");
+			if (counted === "records") return decodeMissing(plan);
+		}
+	}
+	if (counted === "number") return count;
+	if (plan.rows !== "many") return createRecord(plan);
+	const records = [];
+	for (let index = 0; index < count; index++) records.push(createRecord(plan));
+	return records;
+}
+/**
+* Returns the rows of `result` with the values of the fields of `plan` in their order, read from the result columns of their keys: a value from the only column.
+*
+* It rejects a missing column or one that the result has twice, and other columns than one for a value; it ignores the other columns of records.
+*/
+function selectColumns(plan, result) {
+	const { columns, rows } = result;
+	if (plan.value) {
+		if (columns.length !== 1) throw new ResultDecodeError(`Statement returned ${columns.length} columns for one value`, void 0);
+		return rows;
+	}
+	const { fields } = plan;
+	const indexes = [];
+	let ordered = fields.length === columns.length;
+	for (let index = 0; index < fields.length; index++) {
+		const { key } = fields[index];
+		const column = columns.indexOf(key);
+		if (column === -1) throw new ResultDecodeError(`Statement returned no column "${key}"`, void 0);
+		if (columns.indexOf(key, column + 1) !== -1) throw new ResultDecodeError(`Statement returned column "${key}" more than once`, void 0);
+		indexes.push(column);
+		ordered &&= column === index;
+	}
+	if (ordered) return rows;
+	const selected = [];
+	for (let row = 0; row < rows.length; row++) {
+		const values = [];
+		for (let index = 0; index < indexes.length; index++) values.push(rows[row][indexes[index]]);
+		selected.push(values);
+	}
+	return selected;
+}
+/**
+* Decodes driver rows into the result of a query by its result plan, and converts the result as its conversion tells.
+*
+* It rejects a row whose values do not match the result fields, and names the path of the value that fails to decode from its result field, such as `fields[2].label`, after the index of the row of rows `many`, such as `[2].fields[2].label`.
+*/
+function decodeResult(plan, rows) {
+	const result = decodeRows(plan, rows);
+	const { conversion } = plan;
+	return conversion === void 0 ? result : convertTopResult(plan, conversion, result, rows.length === 0);
+}
+/** Converts `result`, which `plan` decoded for a statement rather than for nested rows, as `convertResult` does, rejecting with the error of the statement. */
+function convertTopResult(plan, conversion, result, missing) {
+	try {
+		return convertResult(plan, conversion, result, missing);
+	} catch (error) {
+		throw error instanceof NestedFailure ? createRowError("", error) : new ResultDecodeError(`Cannot convert the result${describeCause(error)}`, void 0, { cause: error });
+	}
+}
+/**
+* Converts `result`, which `plan` decoded, by `conversion`.
+*
+* It tells a missing row by `missing` rather than by the value, since a row may decode to `null` or `undefined`.
+* A failure of `map` of rows `many` is a `NestedFailure` of the index of its row; any other failure is the error of the callback, which the enclosing field adds its path to.
+*/
+function convertResult(plan, conversion, result, missing) {
+	const { map, transform } = conversion;
+	let converted = result;
+	if (map !== void 0) {
+		if (plan.rows === "many") {
+			const rows = result;
+			let index = 0;
+			try {
+				for (; index < rows.length; index++) rows[index] = map(rows[index]);
+			} catch (error) {
+				throw new NestedFailure(`[${index}]`, error);
+			}
+		} else if (!missing) converted = map(result);
+	}
+	return transform === void 0 ? converted : transform(converted);
+}
+/** Decodes driver rows into the result of a query before its conversion: an array of rows `many`, one row, or the result of a missing row. */
+function decodeRows(plan, rows) {
+	if (plan.rows === "many") {
+		const results = [];
+		let index = 0;
+		try {
+			for (; index < rows.length; index++) results.push(decodeRow(plan, rows[index], false));
+		} catch (error) {
+			throw createRowError(`[${index}].`, error);
+		}
+		return results;
+	}
+	if (rows.length > 1) throw new Error(`Query of one row returned ${rows.length} rows`);
+	const row = rows[0];
+	if (row === void 0) {
+		if (plan.rows === "one") throw new NotFoundError("Query returned no rows");
+		return decodeMissing(plan);
+	}
+	try {
+		return decodeRow(plan, row, false);
+	} catch (error) {
+		throw createRowError("", error);
+	}
+}
+/** Returns the result of a query of rows `nullable` or `optional` without a row: `null` or `undefined`. */
+function decodeMissing(plan) {
+	return plan.rows === "nullable" ? null : void 0;
+}
+/** Missing row of nested rows `one`, which the query turns into its error once the path is known. */
+var MissingRow = class extends Error {
+	guaranteedBy;
+	constructor(guaranteedBy) {
+		super();
+		this.guaranteedBy = guaranteedBy;
+	}
+};
+/**
+* Failure inside a row, with the path to it, such as `[2].label` from the field of nested rows or `fields[2].label` from a row of the driver: a missing row or a value that fails to decode.
+*
+* Every enclosing level adds its own part of the path, and the query turns it into its error.
+*/
+var NestedFailure = class extends Error {
+	path;
+	cause;
+	constructor(path, cause) {
+		super();
+		this.path = path;
+		this.cause = cause;
+	}
+};
+/** Adds `segment` before the path of a failure inside a row. */
+function prefixPath(segment, error) {
+	return error instanceof NestedFailure ? new NestedFailure(segment + error.path, error.cause) : new NestedFailure(segment, error);
+}
+/**
+* Creates the error of a query from the failure of a row of the driver, adding `prefix`, such as the index of the row, before its path: `NotFoundError` or `RequiredRelationError` for a missing row of nested rows, and `ResultDecodeError` for a value that fails to decode.
+*
+* A missing row keeps its class wherever it is nested, so it is never reported as a decoding failure.
+* A row of another width than the result fields is already the error of the query.
+*/
+function createRowError(prefix, error) {
+	if (!(error instanceof NestedFailure)) return error;
+	const path = prefix + error.path;
+	const { cause } = error;
+	if (cause instanceof MissingRow) return cause.guaranteedBy === void 0 ? new NotFoundError(`Nested query of result field "${path}" returned no rows`, path) : new RequiredRelationError(cause.guaranteedBy, path);
+	return new ResultDecodeError(`Cannot decode result field "${path}"${describeCause(cause)}`, path, { cause });
+}
+/** Describes the failure `cause` at the end of the message of an error. */
+function describeCause(cause) {
+	return cause instanceof Error ? `: ${cause.message}` : "";
+}
+/**
+* Decodes a row into a record keyed by the result fields, or into the value of its only field.
+*
+* A row of the driver holds text and `null`; a packed row of nested rows holds parsed JSON.
+*/
+function decodeRow(plan, row, packed) {
+	const { fields } = plan;
+	if (row.length !== fields.length) {
+		if (packed) throw new Error(`Nested row of ${row.length} values for ${fields.length} result fields`);
+		throw new ResultDecodeError(`Driver returned a row of ${row.length} values for ${fields.length} result fields`, void 0);
+	}
+	let index = 0;
+	try {
+		if (plan.value) return packed ? decodePackedValue(fields[0], row[0]) : decodeDriverValue(fields[0], row[0]);
+		const record = createRecord(plan);
+		for (; index < fields.length; index++) {
+			const field = fields[index];
+			record[field.key] = packed ? decodePackedValue(field, row[index]) : decodeDriverValue(field, row[index]);
+		}
+		return record;
+	} catch (error) {
+		const { key } = fields[index];
+		throw prefixPath(packed ? `.${key}` : key, error);
+	}
+}
+/** Creates a record of `plan` before the values of a row are assigned: empty, or with the fields of its template. */
+function createRecord(plan) {
+	const record = {};
+	const { recordTemplate } = plan;
+	if (recordTemplate !== void 0) for (let index = 0; index < recordTemplate.length; index++) {
+		const { key, value } = recordTemplate[index];
+		record[key] = value;
+	}
+	return record;
+}
+/** Decodes the value of a field in a row of the driver: a scalar from its text, keeping `NULL` as `null`, or nested rows from JSON text. */
+function decodeDriverValue(field, value) {
+	if (value === void 0) throw new Error("Driver returned no value");
+	if (field.nested !== void 0) return decodeNested(field.nested, value === null ? null : JSON.parse(value));
+	return value === null ? null : field.type.decode(value);
+}
+/** Decodes the value of a field in a packed row: a scalar from its text, keeping JSON `null` as `null`, or nested rows from parsed JSON. */
+function decodePackedValue(field, value) {
+	if (field.nested !== void 0) return decodeNested(field.nested, value);
+	if (value === null) return null;
+	if (typeof value !== "string") throw new TypeError(`Nested value must be text, not ${describeJson(value)}`);
+	return field.type.decode(value);
+}
+/** Decodes the rows of a nested query from JSON, as `decodeNestedRows` does, and converts them as the conversion of `plan` tells. */
+function decodeNested(plan, json) {
+	const result = decodeNestedRows(plan, json);
+	const { conversion } = plan;
+	return conversion === void 0 ? result : convertResult(plan, conversion, result, json === null);
+}
+/** Decodes the rows of a nested query from JSON: an array of packed rows for rows `many`, and a packed row or `null` otherwise. */
+function decodeNestedRows(plan, json) {
+	if (plan.rows === "many") {
+		if (!Array.isArray(json)) throw new TypeError(`Nested rows must be an array, not ${describeJson(json)}`);
+		const results = [];
+		let index = 0;
+		try {
+			for (; index < json.length; index++) results.push(decodePackedRow(plan, json[index]));
+		} catch (error) {
+			throw prefixPath(`[${index}]`, error);
+		}
+		return results;
+	}
+	if (json === null) {
+		if (plan.rows === "one") throw new MissingRow(plan.guaranteedBy);
+		return decodeMissing(plan);
+	}
+	return decodePackedRow(plan, json);
+}
+/** Decodes a packed row, which must be an array. */
+function decodePackedRow(plan, json) {
+	if (!Array.isArray(json)) throw new TypeError(`Nested row must be an array, not ${describeJson(json)}`);
+	return decodeRow(plan, json, true);
+}
+/** Describes the kind of a parsed JSON value for an error message. */
+function describeJson(value) {
+	if (value === null) return "null";
+	if (typeof value === "object") return Array.isArray(value) ? "an array" : "an object";
+	return `a ${typeof value}`;
+}
+// src/table/table.ts
+function defineTable(name, definitions, options) {
+	return createTable(name, definitions, options, void 0);
+}
+/**
+* Creates a table-definition function with the given naming convention, for an application to define its tables with.
+*
+* Its tables have the same types as those of `defineTable`.
+*/
+function createTableFactory(factoryOptions) {
+	const deriveColumnName = factoryOptions.columnName;
+	if (typeof deriveColumnName !== "function") throw new TypeError("The columnName option of createTableFactory must be a function");
+	return ((name, definitions, options) => createTable(name, definitions, options, deriveColumnName));
+}
+/** Creates the table that `defineTable` defines, naming its columns by `deriveColumnName` if given. */
+function createTable(name, definitions, options, deriveColumnName) {
+	const columns = {};
+	for (const [key, definition] of Object.entries(definitions)) {
+		if (key.startsWith("$")) throw new Error(`Column key "${key}" of table "${name}" must not start with "$"`);
+		if (!isRecordKey(key)) throw new Error(`Column key "__proto__" of table "${name}" is not allowed; use columnName("__proto__")`);
+		const column = toColumn(definition);
+		if (!column) throw new TypeError(`Column "${key}" of table "${name}" must be a type or a column`);
+		columns[key] = column;
+	}
+	if (deriveColumnName) nameColumns(name, columns, deriveColumnName);
+	return Object.freeze({
+		kind: "table",
+		name,
+		columns: Object.freeze(columns),
+		keys: defineKeys(name, columns, options)
+	});
+}
+/**
+* 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) {
+	const listed = new Set(columns);
+	return someKey(table, (key) => key.length === listed.size && isKeyAmong(key, listed));
+}
+/** 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(definition) ? new Column(definition, {
+		name: void 0,
+		keyKind: void 0,
+		hasDefault: false
+	}) : void 0;
+}
+// src/type/untyped.ts
+/** Encodes a parameter without a type, such as a value interpolated into `sql`, by its JavaScript type. */
+function encodeUntyped(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return value ? "t" : "f";
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Uint8Array) return encodeBytea(value);
+	if (Array.isArray(value)) throw new TypeError("Pass an array with param(type, value), so that its elements are encoded by type");
+	return stringifyJson(value);
+}
+// 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;
+function quoteIdentifier(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+/**
+* 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
+/** Most parameters that PostgreSQL takes in a statement. */
+const maxParameters = 65535;
+/** State of one compilation shared by all queries of the statement, never by reusable nodes: parameters and the aliases of all sources. */
+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, which binds the parameter of a cast once by `bindOnce`. */
+	grouped = false;
+	#aliases = /* @__PURE__ */ new Set();
+	#placeholders;
+	constructor(schemaName, tables = void 0, db = void 0) {
+		this.schemaName = schemaName;
+		this.tables = tables;
+		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) {
+		if (this.parameters.length === 65535) throw new Error(`Statement has more than ${maxParameters} parameters, which PostgreSQL does not take; split it into several statements, such as in a transaction`);
+		this.parameters.push(value);
+		return `$${this.parameters.length}`;
+	}
+	/** Binds `value` as the parameter of `cast` unless `bindOnce` has bound the cast before, and returns its placeholder. */
+	bindOnce(cast, value) {
+		this.#placeholders ??= /* @__PURE__ */ new Map();
+		let placeholder = this.#placeholders.get(cast);
+		if (placeholder === void 0) {
+			placeholder = this.bind(value);
+			this.#placeholders.set(cast, placeholder);
+		}
+		return placeholder;
+	}
+};
+// src/compiler/postgres/parentheses.ts
+/** Tells whether an operand of `kind` needs parentheses at `position`, so that the SQL keeps the structure of the tree. */
+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": 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: a select statement, a mutation, or a statement of SQL text.
+*
+* 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,
+			named: false,
+			locksRows: context.locksRows
+		};
+		case "text": {
+			const { fields } = node;
+			return {
+				text: compileExpression(context, void 0, node.sql),
+				parameters: context.parameters,
+				fields: fields ?? noFields,
+				rows: node.rows,
+				value: node.value,
+				counted: fields === void 0 ? "number" : void 0,
+				named: true,
+				locksRows: false
+			};
+		}
+		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,
+				named: false,
+				locksRows: false
+			};
+		}
+	}
+}
+/** Compiles a mutation, whose expressions see only the occurrence of its table, apart from the values of an insert, which see no source. */
+function compileMutation(context, node) {
+	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)}`;
+			break;
+		case "update": {
+			text = `UPDATE ${target} SET`;
+			const { set } = node;
+			for (let index = 0; index < set.length; index++) {
+				const { key, value } = set[index];
+				text += `${index === 0 ? " " : ", "}${compileColumnName(node.target, key)} = ${compileExpression(context, scope, value)}`;
+			}
+			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;
+}
+/** Compiles the physical name of the column of the table of `target` under `key`, as `SET` and the column list of an insert name it, without an alias. */
+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));
+		case "cast": {
+			const { operand } = node;
+			return `${context.grouped && operand.kind === "param" ? context.bindOnce(node, encodeParameter(operand)) : compileOperand(context, scope, operand, "value")}::${node.type.castType}`;
+		}
+		case "boolean": return node.value ? "TRUE" : "FALSE";
+		case "and":
+		case "or": return node.operands.map((operand) => compileOperand(context, scope, operand, "condition")).join(node.kind === "and" ? " AND " : " OR ");
+		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 "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)})`;
+}
+/** Encodes the value of a parameter node with its type, or by its JavaScript type without one. */
+function encodeParameter(node) {
+	if (node.value === void 0) throw new TypeError("Query parameter is undefined; use null for NULL");
+	if (node.value === null) return null;
+	return node.type ? node.type.encode(node.value) : encodeUntyped(node.value);
+}
+/** 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/execution/driver.ts
+/** Creates a statement from SQL text and the text representations of its parameters, such as `createStatement("BEGIN")`. */
+function createStatement(text, parameters = []) {
+	return {
+		text,
+		parameters
+	};
+}
+// 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 of the records of `relation`, as `RelationRows` gives it in types. */
+function getRelationRows(relation) {
+	if (relation.kind === "many") return "many";
+	return relation.required ? "one" : "nullable";
+}
+/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
+function toFilteredRows(rows, value, guaranteed) {
+	if (!guaranteed || rows !== "one") return rows;
+	return value ? "optional" : "nullable";
+}
+/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
+function limitToOne(limit) {
+	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
+}
+/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
+function toValueRows(rows) {
+	return rows === "nullable" ? "optional" : rows;
+}
+// src/query/node.ts
+/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
+function createQueryNode(from, relation, filters = noFilters) {
+	return Object.freeze({
+		kind: "query",
+		from,
+		relation,
+		projections: [],
+		filters,
+		groupBy: [],
+		having: void 0,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		distinct: false,
+		distinctOn: [],
+		distinctFields: void 0,
+		lock: void 0,
+		rows: relation === void 0 ? "many" : getRelationRows(relation),
+		value: false,
+		guaranteed: relation?.required ?? false,
+		all: false,
+		conversion: 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 `many`, `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 === "many" && !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 "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 "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 "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);
+			if (lowered === returning && values === node.values) return node;
+			return Object.freeze({
+				kind: "insert",
+				target,
+				columns: node.columns,
+				values,
+				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);
+}
+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);
+		case "text": return lowerText(node, context);
+		default: return lowerMutation(node, context);
+	}
+}
+/** Creates the context of lowering a statement with `definitions` and `db`, whose nested queries `lowerSelect` lowers. */
+function createContext(definitions, db) {
+	const context = {
+		definitions,
+		db,
+		lowerSelect: (node, positions) => lowerSelect(node, context, positions),
+		lowerExists: (node) => lowerExists(node, context)
+	};
+	return context;
+}
+/** Lowers a statement of SQL text, replacing the queries in the expressions interpolated into it. */
+function lowerText(node, context) {
+	const sql = lowerExpression(node.sql, context);
+	if (sql === node.sql) return node;
+	return Object.freeze({
+		kind: "text",
+		sql,
+		fields: node.fields,
+		rows: node.rows,
+		value: node.value
+	});
+}
+/** Lowers a query as `lowerQuery` does, or as `lowerStatement` does when `positions` is set, with the conversion of its result. */
+function lowerSelect(node, context, positions) {
+	const statement = lowerSelectStatement(node, context, positions);
+	const { conversion } = node;
+	return conversion === void 0 ? statement : Object.freeze({
+		...statement,
+		conversion
+	});
+}
+/** Lowers a query to its statement, whichever it is: of `exists`, of an aggregate, of a page that evaluates its nested queries only over its rows, or of the rows of its source. */
+function lowerSelectStatement(node, context, positions) {
+	if (isExistsQuery(node)) return selectExists(node, context);
+	checkRelation(node, context);
+	if (isAggregateQuery(node)) return lowerAggregate(node, context);
+	const recordTemplate = createRecordTemplate(node.projections);
+	const selected = dropLiterals(node.projections);
+	const projections = lowerProjections(selected, context);
+	if (node.groupBy.length > 0) checkGroupAggregates(projections, node);
+	const filters = lowerFilters(node.filters, context);
+	const orderBy = lowerOrder(node.orderBy, context, selected, projections);
+	const groupBy = lowerKeys(node.groupBy, context, selected, projections);
+	const having = lowerValue(node.having, context);
+	const distinctOn = lowerKeys(node.distinctOn, context, selected, projections);
+	if (node.distinct) checkDistinct(projections, orderBy);
+	if (distinctOn !== void 0) checkDistinctOn(projections, distinctOn, orderBy);
+	const { relation } = node;
+	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
+	const statement = {
+		kind: "select",
+		from: node.from,
+		joins: noJoins,
+		projections,
+		filters,
+		groupBy,
+		having,
+		orderBy,
+		limit: node.limit,
+		offset: node.offset,
+		distinct: node.distinct,
+		distinctOn,
+		lock: node.lock,
+		rows: node.rows,
+		value: node.value,
+		guaranteedBy,
+		recordTemplate
+	};
+	const page = lowerPage(statement, selected, positions);
+	if (page !== void 0) return page;
+	if (positions && orderBy.length > 0) statement.orderBy = sortByPositions(orderBy, projections);
+	return Object.freeze(statement);
+}
+/** Lowers a query of `exists` to a statement without a source of one row of `EXISTS` of its rows. */
+function selectExists(node, context) {
+	return Object.freeze({
+		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(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)
+	}), 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 `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/sql-query.ts
+/**
+* Immutable query of a statement of SQL text, bound to the `Db` that executes it when awaited.
+*
+* Without a selection, it resolves to the number of the rows of the command tag of its statement, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of the rows of the statement instead, decoded by types.
+*/
+var SqlQuery = class SqlQuery {
+	node;
+	db;
+	/** Executes the query on its `Db`. */
+	then;
+	constructor(node, db) {
+		this.node = node;
+		this.db = db;
+		this.then = executeOnAwait;
+		Object.freeze(this);
+	}
+	select(fields) {
+		const { node } = this;
+		if (node.fields !== void 0 && node.value) throw new Error("select cannot be used after get or pluck; call get or pluck to replace the value");
+		if (typeof fields !== "object" || fields === null) throw new TypeError("select takes an object of the types of the fields by their columns");
+		const added = Reflect.ownKeys(fields);
+		const selected = [];
+		for (const field of node.fields ?? []) if (!added.includes(field.key)) selected.push(field);
+		for (const key of added) {
+			if (typeof key === "symbol") throw new TypeError("A selected field must have a string key");
+			if (!isRecordKey(key)) throw new Error(`Field "${key}" cannot be a key of a record`);
+			selected.push(Object.freeze({
+				key,
+				type: requireType(fields[key], `field "${key}"`)
+			}));
+		}
+		return this.derive({
+			fields: selected,
+			value: false
+		});
+	}
+	get(type) {
+		const { rows } = this.node;
+		return this.deriveValue(type, "get", rows === "many" ? "one" : toValueRows(rows));
+	}
+	pluck(type) {
+		return this.deriveValue(type, "pluck", toValueRows(this.node.rows));
+	}
+	take() {
+		const { rows } = this.node;
+		return this.derive({ rows: rows === "many" ? "one" : rows });
+	}
+	optional() {
+		return this.changeOneRow("optional");
+	}
+	nullable() {
+		const { node } = this;
+		if (node.fields !== void 0 && node.value) throw new Error("nullable applies only to a query of records; use optional after get or pluck");
+		return this.changeOneRow("nullable");
+	}
+	/** Compiles the query into SQL text and parameters, as its `Db` executes it. */
+	toSQL() {
+		return this.db.$compile(this);
+	}
+	/** 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 $query");
+	}
+	/** Creates a query of the same `Db` with the node changes applied. */
+	derive(changes) {
+		return new SqlQuery(Object.freeze({
+			...this.node,
+			...changes
+		}), this.db);
+	}
+	/** Creates the query that returns the value of the only column of each row in rows mode `rows`, decoded by `type` of `method`. */
+	deriveValue(type, method, rows) {
+		const field = Object.freeze({
+			key: "value",
+			type: requireType(type, method)
+		});
+		return this.derive({
+			fields: [field],
+			value: true,
+			rows
+		});
+	}
+	/** Creates the query of one row in rows mode `rows`, rejecting a query of many rows. */
+	changeOneRow(rows) {
+		if (this.node.rows === "many") throw new Error(`${rows} applies only to a query of one row, such as one made by take`);
+		return this.derive({ rows });
+	}
+};
+/** Starts the query of the statement of `sql` bound to `db`, which resolves to the number of the rows of its command tag. */
+function startSqlQuery(sql, db) {
+	return new SqlQuery(Object.freeze({
+		kind: "text",
+		sql,
+		fields: void 0,
+		rows: "many",
+		value: false
+	}), db);
+}
+/** Returns `value` that `what` takes as its type, rejecting a value that is not a type, such as a column. */
+function requireType(value, what) {
+	if (!isType(value)) throw new TypeError(`${what} takes a type, such as t.integer, not a column or another value`);
+	return value;
+}
+// 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 $query, 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 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) {
+	const { table } = source;
+	const values = typeof set === "function" ? set(createSelectionRefs(source, context)) : set;
+	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;
+	}
+	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`);
+	}
+};
+/**
+* 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.
+*/
+function createInsert(query, records, rows, method) {
+	const { node } = query;
+	if (!isTableQuery(node)) throw new Error(`${method} applies only to a query of a table without clauses, such as filters or selected fields; select the fields that it returns after it`);
+	const { columns, values } = toInsertRows(node.from.table, records, method);
+	return new MutationQuery(query.table, Object.freeze({
+		kind: "insert",
+		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.
+*
+* 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`);
+	const predicate = combineFilters(node.filters);
+	if (!node.all && predicate.kind === "boolean" && predicate.value) throw new Error(`${method} requires a filter that restricts the rows, such as of where or find; call all() to ${method} every row`);
+}
+// src/query/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?.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");
+	}
+	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. */
+	derive(changes) {
+		return new SelectQuery(this.table, Object.freeze({
+			...this.node,
+			...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 column values, returning one row like `take`. */
+	takeWhere(values) {
+		const changes = this.addFilter(values);
+		if (changes.rows === "many") changes.rows = "one";
+		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);
+}
+/** Starts a query over a new occurrence of the table. */
+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);
+}
+// 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/expression/sql.ts
+function sql(first, ...values) {
+	if (isTemplateStrings(first)) return createFragment(first, values, void 0);
+	if (!isType(first)) throw new TypeError("sql() accepts a type, not a column");
+	return (strings, ...values) => createFragment(strings, values, first);
+}
+/**
+* Creates a SQL fragment of a quoted name, such as of a table or a column known only at runtime, for the templates of `sql`, of `$query` and `$script` of a `Db`, and of `query` and `script` of a `Database`.
+*
+* Several names make a qualified name, such as `identifier(schema, table)` for `"schema"."table"`.
+* The fragment has no parameters, so a script takes it.
+* The name is not qualified by the PostgreSQL schema of the statement.
+*/
+function identifier(...names) {
+	let text = "";
+	for (const name of names) {
+		if (typeof name !== "string" || name === "") throw new TypeError("identifier() takes names as non-empty strings");
+		text += (text === "" ? "" : ".") + quoteIdentifier(name);
+	}
+	if (text === "") throw new TypeError("identifier() takes at least one name");
+	return toExpression(createNode({
+		kind: "raw",
+		fragments: [text],
+		values: []
+	}));
+}
+function param(type, value) {
+	if (!isType(type) && !isExpression(type)) throw new TypeError("param() accepts a type or an expression, not a column");
+	if (isExpression(type)) {
+		if (isExpression(value)) return value;
+		const valueType = getType(type);
+		return toExpression(toValueNode(value, valueType), valueType);
+	}
+	return toExpression(toCastValueNode(value, type), type);
+}
+function isTemplateStrings(value) {
+	return Array.isArray(value);
+}
+function createFragment(strings, values, type) {
+	return toExpression(toRawSqlNode(strings, values), type);
+}
+/**
+* Creates the node of the SQL of a template, whose interpolations stay structured nodes.
+*
+* An interpolated expression keeps its node, and a query of a table without clauses becomes the name of the table, qualified by the PostgreSQL schema of the statement.
+* Another query of a table becomes a query in an expression, which lowering replaces with its SQL.
+* Other values become query parameters.
+* It rejects the other queries, which a parameter would encode as text.
+*/
+function toRawSqlNode(strings, values) {
+	const nodes = [];
+	for (let index = 0; index < values.length; index++) nodes.push(toInterpolatedNode(values[index]));
+	return createNode({
+		kind: "raw",
+		fragments: [...strings],
+		values: nodes
+	});
+}
+/** Returns the node of a value interpolated into SQL, as `toRawSqlNode` takes it. */
+function toInterpolatedNode(value) {
+	if (value instanceof SelectQuery) {
+		const { node } = value;
+		if (node.conversion !== void 0) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of map or transform");
+		return isTableQuery(node) ? createNode({
+			kind: "tableName",
+			table: value.table,
+			db: value.db
+		}) : createNode({
+			kind: "nestedQuery",
+			query: node,
+			db: value.db
+		});
+	}
+	if (value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery || value instanceof TransformedQuery) throw new TypeError("sql takes a query of a table, such as db.form or a query of its records, not a query of $select, a mutation, a query of SQL text, or a query of map or transform");
+	return toValueNode(value);
+}
+// src/execution/db.ts
+/** Binds `schema` to `database`; see `Database.bind`. */
+function bindSchema(schema, database, options = {}) {
+	const tables = new Set(Object.values(schema.$tables));
+	const relations = schema[schemaRelations];
+	const definitions = collectDefinitions(relations);
+	const { schemaName } = options;
+	const resolveSchemaName = () => typeof schemaName === "function" ? schemaName() : schemaName;
+	function compile(query) {
+		if (query.db !== void 0 && query.db !== db) throw new Error("Cannot run a query bound to another Db");
+		return compileStatement(lowerStatement(query.node, definitions, db), { schemaName: resolveSchemaName() }, tables, db);
+	}
+	const methods = {
+		$schema: schema,
+		$database: database,
+		get $schemaName() {
+			return resolveSchemaName();
+		},
+		$compile(query) {
+			const { text, parameters } = compile(query);
+			return createStatement(text, parameters);
+		},
+		async $execute(query) {
+			const compiled = compile(query);
+			if (compiled.locksRows && !database.isInTransaction()) throw new Error("Cannot lock the rows of a query outside a transaction, where the locks would end with its statement; a test transaction alone does not count");
+			return decodeStatement(compiled, await database.execute(compiled));
+		},
+		$select: (selection) => startRecordQuery(selection, db),
+		$query: (strings, ...values) => startSqlQuery(toRawSqlNode(strings, values), db),
+		async $script(script, ...values) {
+			if (typeof script === "string") return database.script(script);
+			const { text, parameters } = compile(startSqlQuery(toRawSqlNode(script, values), db));
+			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);
+		},
+		$transaction: (callback, options) => database.transaction(callback, options),
+		$ensureTransaction: (callback) => database.ensureTransaction(callback),
+		$isInTransaction: () => database.isInTransaction(),
+		$lock: (key) => database.lock(key)
+	};
+	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;
+}
+// src/execution/transaction/abort.ts
+/**
+* Runs `start` and settles as its promise, or rejects with the reason of `signal` when it aborts first and `abort`, called on the abort, returns `true`.
+*
+* It listens from before `start`, which may abort the signal before it returns, and stops once the promise of `start` settles, such as for the signal that `node:test` aborts after every test.
+* A later rejection of that promise stays handled, and a value it resolves with after the rejection goes to `discard`, which handles its own failures.
+*/
+function settleUnlessAborted(start, signal, abort, discard) {
+	const settled = Promise.withResolvers();
+	let abandoned = false;
+	const onAbort = () => {
+		if (abort()) {
+			abandoned = true;
+			settled.reject(signal.reason);
+		}
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	let running;
+	try {
+		running = start();
+	} catch (error) {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+		return settled.promise;
+	}
+	running.then((value) => {
+		signal.removeEventListener("abort", onAbort);
+		if (abandoned) discard?.(value);
+		else settled.resolve(value);
+	}, (error) => {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+	});
+	return settled.promise;
+}
+/**
+* Acquires a connection for a test transaction, rejecting with the reason of `signal` when it aborts first.
+*
+* A connection acquired after the abort returns to the pool as best-effort cleanup: the test transaction has already rejected, so nothing awaits the release, and its failure is ignored.
+*/
+function acquireUnlessAborted(driver, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return settleUnlessAborted(() => driver.acquire(), signal, () => true, (connection) => {
+		Promise.resolve().then(() => connection.release()).catch(() => {});
+	});
+}
+// src/execution/transaction/settings.ts
+/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
+function getLevelSettings(options) {
+	return options?.searchPath ? [{
+		name: "search_path",
+		value: options.searchPath.map(quoteIdentifier).join(", ")
+	}] : void 0;
+}
+/**
+* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
+*
+* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
+*/
+async function applySettings(level, settings) {
+	if (level.cleanup) return;
+	if (level.parent) {
+		let text = "SELECT";
+		const names = [];
+		for (const { name } of settings) {
+			names.push(name);
+			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
+		}
+		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
+		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
+			name,
+			value: values[index]
+		})));
+		if (level.cleanup) return;
+	}
+	await level.connection.execute(createSettingStatement(settings));
+}
+/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
+function createSettingStatement(settings) {
+	let text = "SELECT";
+	const parameters = [];
+	for (const { name, value } of settings) {
+		parameters.push(name, value);
+		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
+	}
+	return createStatement(text, parameters);
+}
+// src/execution/transaction/level.ts
+/** Statement that starts the transaction of a level without a parent: a transaction of `transaction`, a test transaction, or the first test fixture. */
+const beginStatement = /* @__PURE__ */ createStatement("BEGIN");
+const commitStatement = /* @__PURE__ */ createStatement("COMMIT");
+const rollbackStatement = /* @__PURE__ */ createStatement("ROLLBACK");
+/**
+* Creates the state of a `starting` level on `connection`, nested in `parent` if given.
+*
+* It sends no SQL and does not reserve the level as the `child` of `parent`; the caller does both.
+* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
+*/
+function createLevel(connection, parent, transaction) {
+	return {
+		connection,
+		parent,
+		depth: parent ? parent.depth + 1 : 0,
+		inTransaction: transaction || (parent?.inTransaction ?? false),
+		state: "starting",
+		child: void 0,
+		rollbackOnly: void 0,
+		cleanup: void 0,
+		endedBy: void 0,
+		restore: void 0
+	};
+}
+/**
+* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
+*
+* `transaction` tells whether the level is a transaction of `transaction` rather than a level of the test helpers.
+* A level whose settings fail rolls back to its savepoint first.
+* The failure suppresses the reason of `signal` when the signal aborted before it.
+*/
+async function startNestedLevel(parent, transaction, signal, settings) {
+	const level = createLevel(parent.connection, parent, transaction);
+	parent.child = level;
+	try {
+		await level.connection.execute(createStatement(`SAVEPOINT ${getSavepointName(level)}`));
+	} catch (error) {
+		if (!level.cleanup) {
+			closeStarting(level);
+			throw suppressAbortReason(error, signal);
+		}
+		throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
+	}
+	if (settings) try {
+		await applySettings(level, settings);
+	} catch (error) {
+		throw suppressAbortReason(combineRejections({ error }, await endLevel(level, false)).error, signal);
+	}
+	return level;
+}
+/**
+* Runs `callback` in the context of a started `level` in `storage`, then ends the level.
+*
+* A level that `commits` commits only when the callback resolves with no nested level running and no nested level that failed to end.
+* When `signal` aborts, the level ends at once without waiting for the callback, and its outcome is a rejection with the reason of the signal.
+*/
+async function runLevel(storage, level, callback, commits, signal) {
+	if (level.cleanup) return getEndedOutcome(level.cleanup, createClosedError(level, void 0));
+	let result;
+	let rejection;
+	if (signal?.aborted) endLevel(level, false, "abort");
+	else {
+		level.state = "open";
+		try {
+			result = await (signal ? settleUnlessAborted(() => storage.run(level, callback), signal, () => {
+				endLevel(level, false, "abort");
+				return true;
+			}) : storage.run(level, callback));
+		} catch (error) {
+			rejection = { error };
+		}
+	}
+	if (level.cleanup) return getEndedOutcome(level.cleanup, level.endedBy === "abort" ? signal?.reason : createClosedError(level, rejection));
+	if (!rejection && level.child) rejection = { error: /* @__PURE__ */ new Error("Transaction was rolled back: a nested transaction was still running when its callback finished") };
+	if (!rejection && level.rollbackOnly) rejection = { error: new Error("Transaction was rolled back: a nested transaction failed to end", { cause: level.rollbackOnly.error }) };
+	const cleanup = await endLevel(level, commits && !rejection);
+	return {
+		result,
+		rejection: combineRejections(rejection, cleanup),
+		failure: cleanup.failure
+	};
+}
+/**
+* Ends `level` once, whoever ends it: later calls return the cleanup already started.
+*
+* Statements of the level and of all levels nested in it fail from the start of the cleanup, and the nested levels end before it.
+*/
+function endLevel(level, commit, endedBy) {
+	if (level.cleanup) return level.cleanup;
+	level.endedBy = endedBy;
+	level.state = "closing";
+	level.cleanup = cleanUpLevel(level, commit, level.child && endLevel(level.child, false, "enclosing level"));
+	return level.cleanup;
+}
+async function cleanUpLevel(level, commit, nested) {
+	const nestedCleanup = await nested;
+	const { parent } = level;
+	const cleanup = parent ? await endSavepoint(level, commit && !level.rollbackOnly) : await endTransaction(level.connection, commit);
+	level.state = "closed";
+	if (parent) {
+		if (parent.child === level) parent.child = void 0;
+		parent.rollbackOnly ??= cleanup.rejection;
+	}
+	return {
+		rejection: combineRejections(nestedCleanup?.rejection, cleanup),
+		failure: cleanup.failure
+	};
+}
+/** Ends a transaction with `COMMIT` or `ROLLBACK`. */
+async function endTransaction(connection, commit) {
+	try {
+		const { command } = await connection.execute(commit ? commitStatement : rollbackStatement);
+		if (commit && command !== "COMMIT") return { rejection: { error: /* @__PURE__ */ new Error("Transaction was rolled back: a statement in it failed") } };
+		return {};
+	} catch (error) {
+		return {
+			rejection: { error },
+			failure: { error }
+		};
+	}
+}
+/**
+* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
+*
+* Before a release, it restores the settings that the level changed; a rollback restores them itself.
+*/
+async function endSavepoint(level, commit) {
+	const name = getSavepointName(level);
+	try {
+		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
+		else if (level.restore) await level.connection.execute(level.restore);
+		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
+		return {};
+	} catch (error) {
+		return { rejection: { error } };
+	}
+}
+/** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
+function getSavepointName(level) {
+	return `kern_${level.depth}`;
+}
+/** Closes a nested level whose `SAVEPOINT` failed, freeing its parent for other statements. */
+function closeStarting(level) {
+	level.state = "closed";
+	if (level.parent?.child === level) level.parent.child = void 0;
+}
+/**
+* Creates the error of `operation` on a level that rejects statements and nested levels, or returns `undefined` when it accepts them.
+*
+* A level that can only roll back keeps the failure of its nested level as the cause.
+*/
+function createUnavailableError(level, operation) {
+	if (level.state !== "open") return /* @__PURE__ */ new Error(`Cannot ${operation}: its transaction is already finished`);
+	if (level.child) return /* @__PURE__ */ new Error(`Cannot ${operation}: a nested transaction is running; await it first`);
+	if (level.rollbackOnly) return new Error(`Cannot ${operation}: a nested transaction failed to end, so the transaction can only roll back`, { cause: level.rollbackOnly.error });
+}
+/** Error of a level that another level ended, keeping the rejection of its callback as the cause. */
+function createClosedError(level, rejection) {
+	return new Error(level.endedBy === "preemption" ? "Transaction was rolled back: its test fixture started another level before it finished" : "Transaction was rolled back: its enclosing transaction ended first", rejection && { cause: rejection.error });
+}
+/** Outcome of a level that something other than its callback ended: a rejection with `error`, which a failed cleanup suppresses. */
+async function getEndedOutcome(cleanup, error) {
+	const ended = await cleanup;
+	return {
+		rejection: combineRejections({ error }, ended),
+		failure: ended.failure
+	};
+}
+/** Returns the connection of a transaction to the driver, keeping a failed release as a rejection that suppresses `rejection`. */
+async function releaseConnection(connection, failure, rejection) {
+	try {
+		await connection.release(failure);
+		return rejection;
+	} catch (error) {
+		return suppress(error, rejection, "Releasing the transaction connection failed");
+	}
+}
+/** Error of a failure to start a test transaction, which suppresses the reason of `signal` when the signal aborted before the failure. */
+function suppressAbortReason(error, signal) {
+	return signal?.aborted ? suppress(error, { error: signal.reason }, "Starting the test transaction failed").error : error;
+}
+/** Rejection with the error of a cleanup, which suppresses the `earlier` rejection if there is one. */
+function combineRejections(earlier, cleanup) {
+	return cleanup.rejection ? suppress(cleanup.rejection.error, earlier, "Transaction rollback failed") : earlier;
+}
+/** Rejection with `error`, which suppresses the `earlier` rejection if there is one. */
+function suppress(error, earlier, message) {
+	return { error: earlier ? new SuppressedError(error, earlier.error, message) : error };
+}
+// src/execution/transaction/fixture-stack.ts
+/** Open test fixtures of a transaction coordinator and the queue of the changes of their stack. */
+var TestFixtureStack = class {
+	#driver;
+	/** Async context of the levels of the coordinator, which tells whether a call runs inside a level. */
+	#storage;
+	/** Open test fixtures, the innermost last. */
+	#fixtures = [];
+	/** Changes of the fixture stack, run one after another so that each one sees the stack the previous one left. */
+	#transitions = Promise.resolve();
+	/**
+	* The `close` functions of the test fixtures that are still opening, from the call that starts the opening until the fixture enters the stack or the opening ends otherwise.
+	*
+	* An opening holds the queue of the fixture stack while its seed runs, so a closing of the stack queued behind it would wait for a seed that may never settle.
+	* Closing the stack therefore calls these first: each one tells its opening to stop waiting for the seed.
+	*/
+	#openings = /* @__PURE__ */ new Set();
+	/**
+	* Outermost fixture in the stack whose closing is queued but has not finished.
+	*
+	* Openings that start after that closing is requested nest outside of the fixture once it closes, so a repeated closing of it, or a closing of a fixture nested in it, must not close them.
+	*/
+	#closing;
+	constructor(driver, storage) {
+		this.#driver = driver;
+		this.#storage = storage;
+	}
+	/**
+	* Starts opening a test fixture, see `startTestFixture` of the coordinator, or, given `refusal`, returns a fixture that rejects with it.
+	*
+	* The `close` of a refused fixture resolves once the earlier changes of the stack end.
+	*/
+	start(seed, refusal) {
+		let level;
+		let closeRequested = false;
+		const closing = Promise.withResolvers();
+		let closedRejection;
+		const close = () => {
+			if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close a test fixture inside a transaction"));
+			closeRequested = true;
+			closing.resolve();
+			if (level && this.#fixtures.includes(level)) {
+				const opened = level;
+				if (this.#closing && this.#closing.depth <= opened.depth) return this.#enqueue(() => this.#closeFixture(opened));
+				this.#closing = opened;
+				return this.#closeAfterOpenings(() => this.#enqueue(async () => {
+					try {
+						await this.#closeFixture(opened);
+					} finally {
+						if (this.#closing === opened) this.#closing = void 0;
+					}
+				}));
+			}
+			return this.#enqueue(() => {
+				const rejection = closedRejection;
+				closedRejection = void 0;
+				if (rejection) throw rejection.error;
+			});
+		};
+		if (refusal) return {
+			fixture: Promise.reject(refusal),
+			close
+		};
+		/**
+		* Runs stages 2 and 3 of the fixture and puts it in the stack, returning `undefined` when closing was requested and the fixture rolled back cleanly.
+		*
+		* It rejects with a failure to start the fixture, with the rejection of `seed`, or with a failure to roll back, which suppresses the rejection of `seed`.
+		*/
+		const open = async () => {
+			if (closeRequested) return;
+			const parent = this.#fixtures.at(-1);
+			const started = parent ? await this.#startInFixture(parent) : await this.#beginFixture();
+			started.state = "open";
+			const outcome = closeRequested ? void 0 : await Promise.race([this.#seedFixture(started, seed), closing.promise]);
+			if (outcome && !outcome.rejection && !closeRequested) {
+				this.#fixtures.push(started);
+				level = started;
+				this.#openings.delete(close);
+				const { result } = outcome;
+				return {
+					get data() {
+						if (started.state !== "open") throw new Error("Test fixture is closed");
+						return result;
+					},
+					close,
+					[Symbol.asyncDispose]: close
+				};
+			}
+			const rejection = combineRejections(outcome?.rejection, { rejection: await this.#endFixture(started) });
+			if (rejection) throw rejection.error;
+		};
+		this.#openings.add(close);
+		return {
+			fixture: this.#enqueue(async () => {
+				let opened;
+				try {
+					opened = await open();
+				} catch (error) {
+					if (!closeRequested) throw error;
+					closedRejection = { error };
+				} finally {
+					this.#openings.delete(close);
+				}
+				if (!opened) throw new Error("Test fixture was closed before it opened");
+				return opened;
+			}),
+			close
+		};
+	}
+	/**
+	* Starts the level of a test transaction in the innermost test fixture as a change of the fixture stack, resolving to `undefined` when no fixture is open.
+	*
+	* Aborted while it waits for its turn, it rejects at once and its change starts nothing, so that a test that has already ended never preempts the active level of the fixture.
+	* From its turn on, it settles with its change.
+	*/
+	startTestLevel(signal) {
+		let waiting = true;
+		const start = () => this.#enqueue(() => {
+			if (signal?.aborted) return;
+			waiting = false;
+			const fixture = this.#fixtures.at(-1);
+			return fixture && this.#startInFixture(fixture, signal);
+		});
+		return signal ? settleUnlessAborted(start, signal, () => waiting) : start();
+	}
+	/**
+	* Closes every fixture, including those still opening, rejecting with the failures of all of them.
+	*
+	* Unlike closing a fixture, it closes every opening, including one started after a closing of the stack was requested, since nothing may stay open.
+	*/
+	close() {
+		return this.#closeAfterOpenings(() => this.#enqueue(() => {
+			const root = this.#fixtures[0];
+			return root && this.#closeFixture(root);
+		}));
+	}
+	/**
+	* Closes the fixtures still opening and runs `closeStack`, rejecting with the failures of all of them.
+	*
+	* A seed that never settles holds the queue of the fixture stack, so closing is requested for every opening before `closeStack` queues its change, and the rollback does not wait for the seeds.
+	*/
+	async #closeAfterOpenings(closeStack) {
+		const closings = [];
+		for (const closeOpening of this.#openings) closings.push(closeOpening());
+		closings.push(closeStack());
+		let rejection;
+		for (const closing of await Promise.allSettled(closings)) if (closing.status === "rejected") rejection = suppress(closing.reason, rejection, "Closing a test fixture failed");
+		if (rejection) throw rejection.error;
+	}
+	/**
+	* Runs `seed` in a savepoint of a fixture that is released when it resolves, returning its result or rejection.
+	*
+	* The savepoint has its own context, so late code of `seed` cannot reach the fixture after it ends.
+	*/
+	async #seedFixture(fixture, seed) {
+		try {
+			return await runLevel(this.#storage, await startNestedLevel(fixture, false), seed, true);
+		} catch (error) {
+			return { rejection: { error } };
+		}
+	}
+	/** Closes an opened fixture as a change of the fixture stack. */
+	async #closeFixture(fixture) {
+		const index = this.#fixtures.indexOf(fixture);
+		if (index < 0) return;
+		let rejection;
+		try {
+			rejection = await this.#endFixture(fixture);
+		} finally {
+			this.#fixtures.length = index;
+		}
+		if (rejection) throw rejection.error;
+	}
+	/** Rolls back a fixture and releases the connection of the first one, returning the error to reject with. */
+	async #endFixture(fixture) {
+		const cleanup = await endLevel(fixture, false);
+		return fixture.parent ? cleanup.rejection : releaseConnection(fixture.connection, cleanup.failure, cleanup.rejection);
+	}
+	/** Runs a change of the fixture stack after the earlier ones. */
+	#enqueue(transition) {
+		const result = this.#transitions.then(transition);
+		this.#transitions = result.catch(() => {});
+		return result;
+	}
+	/** Starts the first test fixture: a transaction on a reserved connection. */
+	async #beginFixture() {
+		const connection = await this.#driver.acquire();
+		try {
+			await connection.execute(beginStatement);
+		} catch (error) {
+			throw (await releaseConnection(connection, { error }, { error })).error;
+		}
+		return createLevel(connection, void 0, false);
+	}
+	/**
+	* Starts a nested level of a test fixture, preempting its active one.
+	*
+	* A fixture runs one nested level at a time, so a new one ends the previous one, such as a test that timed out.
+	* A level whose `signal` aborts while it preempts rejects with its reason instead of starting, and a failure to start after the abort suppresses the reason.
+	*/
+	async #startInFixture(fixture, signal) {
+		if (fixture.child) {
+			const cleanup = await endLevel(fixture.child, false, "preemption");
+			if (cleanup.rejection) throw suppressAbortReason(new Error("Cannot start a level of the test fixture: ending its active level failed", { cause: cleanup.rejection.error }), signal);
+		}
+		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
+		if (unavailable) throw suppressAbortReason(unavailable, signal);
+		signal?.throwIfAborted();
+		return startNestedLevel(fixture, false, signal);
+	}
+};
+// src/execution/transaction/coordinator.ts
+/**
+* Routes statements and scripts to the ambient transaction of the current async context or to the pool.
+*
+* This is the only place that decides which connection executes a statement.
+*/
+var TransactionCoordinator = class {
+	driver;
+	test;
+	#storage = new AsyncLocalStorage();
+	#fixtures;
+	/** Closing of the database, set by the first `close`; from then on, operations outside a transaction reject. */
+	#closed;
+	constructor(driver, test = false) {
+		this.driver = driver;
+		this.test = test;
+		this.#fixtures = new TestFixtureStack(driver, this.#storage);
+	}
+	execute(statement) {
+		const target = this.#route("execute a query");
+		return target instanceof Error ? Promise.reject(target) : target.execute(statement);
+	}
+	/** Executes a script of statements without parameters where `execute` executes a statement. */
+	executeScript(text) {
+		const target = this.#route("execute a script");
+		return target instanceof Error ? Promise.reject(target) : target.executeScript(text);
+	}
+	/** Returns the connection of the ambient transaction or the driver of the pool that runs `operation`, or the error that rejects it. */
+	#route(operation) {
+		const level = this.#storage.getStore();
+		if (!level) {
+			if (this.#closed) return createDatabaseClosedError(operation);
+			return this.test ? new Error(describeOutsideTest(operation)) : this.driver;
+		}
+		return createUnavailableError(level, operation) ?? level.connection;
+	}
+	/**
+	* Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
+	*
+	* Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends.
+	* A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
+	*/
+	transaction(callback, options) {
+		const settings = getLevelSettings(options);
+		const parent = this.#storage.getStore();
+		if (parent) return this.#runNested(parent, callback, true, void 0, settings);
+		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a transaction"));
+		return this.test ? Promise.reject(new Error(describeOutsideTest("start a transaction"))) : this.#runRoot(callback, true, void 0, settings);
+	}
+	/**
+	* Runs `callback` in the current transaction, or in a new transaction outside of one.
+	*
+	* Joining starts no savepoint, so a rejection of `callback` does not undo its changes.
+	* It rejects without calling `callback` when the current level accepts no statements, as a nested transaction would.
+	*/
+	async ensureTransaction(callback) {
+		const level = this.#storage.getStore();
+		if (!level?.inTransaction) return this.transaction(callback);
+		const unavailable = createUnavailableError(level, "join the transaction");
+		if (unavailable) throw unavailable;
+		return callback();
+	}
+	/**
+	* Tells whether the current async context runs in a transaction of `transaction`.
+	*
+	* A test transaction and the seed of a test fixture are not transactions, unless they run inside one, so that code under test behaves as in production.
+	*/
+	isInTransaction() {
+		return this.#storage.getStore()?.inTransaction ?? false;
+	}
+	/**
+	* Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
+	*
+	* Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
+	* When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
+	* Once the level ends, the transaction rejects with the reason of the signal.
+	* A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
+	* Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
+	*/
+	testTransaction(callback, { signal } = {}) {
+		if (!this.test) return Promise.reject(/* @__PURE__ */ new Error("testTransaction requires a database created with test: true"));
+		if (signal?.aborted) return Promise.reject(signal.reason);
+		const parent = this.#storage.getStore();
+		if (parent) return this.#runNested(parent, callback, false, signal);
+		if (this.#closed) return Promise.reject(createDatabaseClosedError("start a test transaction"));
+		return this.#fixtures.startTestLevel(signal).then((level) => level ? this.#runStarted(level, callback, false, signal) : this.#runRoot(callback, false, signal));
+	}
+	/**
+	* Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
+	*
+	* Test transactions started outside any transaction run in the innermost fixture.
+	* A fixture whose `seed` rejects rolls back and closes.
+	*/
+	createTestFixture(seed) {
+		return this.startTestFixture(seed).fixture;
+	}
+	/**
+	* Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
+	*
+	* Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
+	* Closing an open fixture also closes the fixtures opening in it.
+	*/
+	startTestFixture(seed) {
+		return this.#fixtures.start(seed, this.#getFixtureRefusal());
+	}
+	/** Returns the error that rejects a test fixture created now, or `undefined` when it can open. */
+	#getFixtureRefusal() {
+		if (!this.test) return /* @__PURE__ */ new Error("createTestFixture requires a database created with test: true");
+		if (this.#storage.getStore()) return /* @__PURE__ */ new Error("Cannot create a test fixture inside a transaction");
+		if (this.#closed) return createDatabaseClosedError("create a test fixture");
+	}
+	/**
+	* Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
+	*
+	* A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
+	* A failed closing of the driver suppresses the failures of closing the fixtures.
+	* From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
+	*/
+	close() {
+		if (this.#storage.getStore()) return Promise.reject(/* @__PURE__ */ new Error("Cannot close the database inside a transaction"));
+		this.#closed ??= this.#close();
+		return this.#closed;
+	}
+	/** Closes the test fixtures and then the driver, see `close`. */
+	async #close() {
+		let rejection;
+		try {
+			await this.#fixtures.close();
+		} catch (error) {
+			rejection = { error };
+		}
+		try {
+			await this.driver.close();
+		} catch (error) {
+			rejection = suppress(error, rejection, "Closing the driver failed");
+		}
+		if (rejection) throw rejection.error;
+	}
+	async #runRoot(callback, commits, signal, settings) {
+		const connection = await (signal ? acquireUnlessAborted(this.driver, signal) : this.driver.acquire());
+		if (signal?.aborted) throw (await releaseConnection(connection, void 0, { error: signal.reason })).error;
+		const level = createLevel(connection, void 0, commits);
+		let outcome;
+		try {
+			await connection.execute(beginStatement);
+		} catch (error) {
+			level.state = "closed";
+			outcome = {
+				rejection: { error: suppressAbortReason(error, signal) },
+				failure: { error }
+			};
+		}
+		if (!outcome && settings) try {
+			await applySettings(level, settings);
+		} catch (error) {
+			outcome = await getEndedOutcome(endLevel(level, false), error);
+		}
+		outcome ??= await runLevel(this.#storage, level, callback, commits, signal);
+		const rejection = await releaseConnection(connection, outcome.failure, outcome.rejection);
+		if (rejection) throw rejection.error;
+		return outcome.result;
+	}
+	async #runNested(parent, callback, commits, signal, settings) {
+		const unavailable = createUnavailableError(parent, "start a nested transaction");
+		if (unavailable) throw unavailable;
+		return this.#runStarted(await startNestedLevel(parent, commits, signal, settings), callback, commits, signal);
+	}
+	/** Runs `callback` in a started level, returning its result or throwing its rejection. */
+	async #runStarted(level, callback, commits, signal) {
+		const { result, rejection } = await runLevel(this.#storage, level, callback, commits, signal);
+		if (rejection) throw rejection.error;
+		return result;
+	}
+};
+/** Error message of an operation outside a test transaction on a coordinator created for tests. */
+function describeOutsideTest(operation) {
+	return `Cannot ${operation} outside a test transaction: the database was created with test: true, so wrap the test in testTransaction`;
+}
+/** Error of `operation` started outside a transaction after closing the database was requested. */
+function createDatabaseClosedError(operation) {
+	return /* @__PURE__ */ new Error(`Cannot ${operation}: the database is closed`);
+}
+// src/execution/database.ts
+/** Creates a database over a driver; its transactions are shared by every schema bound to it. */
+function createDatabase({ driver, test }) {
+	const coordinator = new TransactionCoordinator(driver, test);
+	let tablelessDb;
+	const getTablelessDb = () => tablelessDb ??= bindSchema(defineSchema(), database);
+	const database = {
+		coordinator,
+		bind: (schema, options) => bindSchema(schema, database, options),
+		query: (strings, ...values) => getTablelessDb().$query(strings, ...values),
+		script: (script, ...values) => typeof script === "string" ? coordinator.executeScript(script) : getTablelessDb().$script(script, ...values),
+		execute: (statement) => coordinator.execute(statement),
+		transaction: (callback, options) => coordinator.transaction(callback, options),
+		ensureTransaction: (callback) => coordinator.ensureTransaction(callback),
+		isInTransaction: () => coordinator.isInTransaction(),
+		async lock(key) {
+			if (!coordinator.isInTransaction()) throw new Error("Cannot take an advisory lock outside a transaction, where it would end with its statement; a test transaction alone does not count");
+			await coordinator.execute(createLockStatement(key));
+		},
+		close: () => coordinator.close(),
+		[Symbol.asyncDispose]: () => coordinator.close()
+	};
+	return database;
+}
+/** Creates the statement that takes a transaction-level advisory lock on a 64-bit hash of `key`. */
+function createLockStatement(key) {
+	return createStatement("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [key]);
+}
+export { not as A, countType as C, literal as D, toAggregateType as E, combineNodes as M, and as O, countProjection as S, createCountCall as T, createTableFactory as _, defineSchema as a, RequiredRelationError as b, requireDerived as c, desc as d, orderBy as f, createStatement as g, one as h, sql as i, or as j, isColumnValues as k, addTerms as l, many as m, identifier as n, SelectQuery as o, matchColumn as p, param as r, from as s, createDatabase as t, asc as u, defineTable as v, createAggregateCall as w, ResultDecodeError as x, NotFoundError as y };