kern-orm 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,3422 @@
+import { A as falseNode, C as equalityOperators, D as createList, E as defineGenericOperator, M as oneNode, N as trueNode, O as createNode, S as Column, T as isEqualityCompatible, _ as toNode, a as stringifyJson, b as defineType, c as textOperators, d as compareNodes, f as createIsNullNode, g as toExpression, h as toBooleanExpression, j as noFilters, k as createSelectNode, l as orderingOperators, m as isExpression, n as text, p as getType, s as encodeBytea, u as compare, v as toValueNode, x as isType } from "./text-4Xs09pIf.mjs";
+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; an object of column values stays unresolved until `where`. */
+function toConditionNode(operand) {
+	return isExpression(operand) ? toNode(operand) : createNode({
+		kind: "values",
+		values: operand
+	});
+}
+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/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 or a value fails to decode; the failure of the value 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 } = plan;
+	if (counted === void 0) return decodeResult(plan, plan.named ? selectColumns(plan, result) : result.rows);
+	const { count } = result;
+	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 {};
+	const records = [];
+	for (let index = 0; index < count; index++) records.push({});
+	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.
+*
+* 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) {
+	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}"${cause instanceof Error ? `: ${cause.message}` : ""}`, path, { cause });
+}
+/**
+* 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 = {};
+		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);
+	}
+}
+/** 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: an array of packed rows for rows `many`, and a packed row or `null` otherwise. */
+function decodeNested(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) {
+	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;
+	}
+	return Object.freeze({
+		kind: "table",
+		name,
+		columns: Object.freeze(columns),
+		keys: defineKeys(name, columns, options)
+	});
+}
+/**
+* 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 = [];
+	#aliases = /* @__PURE__ */ new Set();
+	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}`;
+	}
+};
+// 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 "tableName":
+		case "subquery":
+		case "exists":
+		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 "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,
+			rows: node.rows,
+			value: node.value,
+			counted: void 0,
+			named: false
+		};
+		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
+			};
+		}
+		default: {
+			const { returning } = node;
+			return {
+				text: compileMutation(context, node),
+				parameters: context.parameters,
+				fields: returning ?? noFields,
+				rows: node.rows,
+				value: node.value,
+				counted: returning === void 0 ? "number" : returning.length === 0 ? "records" : void 0,
+				named: 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);
+	}
+	let text = `SELECT${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 (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)}`;
+	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 `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": return `${compileOperand(context, scope, node.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 "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 "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": {
+			const { length } = node.query.projections;
+			if (length !== 1) throw new Error(`A scalar subquery must select one field, not ${length}`);
+			return `(${compileQuery(context, scope, node.query)})`;
+		}
+		case "exists": return `EXISTS (${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)}`;
+			return `${text})`;
+		}
+		default: return node;
+	}
+}
+/** 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/ast/references.ts
+/** Adds to `keys` the key of each column reference to `source` in `node` at any depth, including the queries nested in it. */
+function collectColumnKeys(node, source, keys) {
+	visitNodes(node, true, (child) => {
+		if (child.kind === "column" && child.source === source) keys.add(child.key);
+	});
+}
+/**
+* Tells whether `node` holds, at any depth, a SQL fragment that refers to a column of `source` outside the queries nested in the fragment.
+*
+* PostgreSQL assigns an aggregate whose arguments refer only to the sources of an enclosing query to that query ([PostgreSQL](https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-AGGREGATES)).
+* Lowering does not parse SQL fragments to identify their aggregates, so such a fragment in a nested query, such as `sum` of a column of the parent row, may aggregate the rows of the query of `source`.
+*/
+function holdsFragmentOfSource(node, source) {
+	let found = false;
+	visitNodes(node, true, (child) => {
+		if (found || child.kind !== "raw") return;
+		visitNodes(child, false, (value) => {
+			if (value.kind === "column" && value.source === source) found = true;
+		});
+	});
+	return found;
+}
+/** Calls `visit` for `node` and each expression node in it, also in the queries nested in it when `deep` is set. */
+function visitNodes(node, deep, visit) {
+	visit(node);
+	switch (node.kind) {
+		case "column":
+		case "param":
+		case "boolean":
+		case "tableName":
+		case "values": return;
+		case "cast":
+		case "not":
+		case "isNull":
+			visitNodes(node.operand, deep, visit);
+			return;
+		case "and":
+		case "or":
+			for (const operand of node.operands) visitNodes(operand, deep, visit);
+			return;
+		case "comparison":
+			visitNodes(node.left, deep, visit);
+			visitNodes(node.right, deep, visit);
+			return;
+		case "in":
+			visitNodes(node.operand, deep, visit);
+			for (const item of node.list) visitNodes(item, deep, visit);
+			return;
+		case "raw":
+			for (const value of node.values) visitNodes(value, deep, visit);
+			return;
+		case "subquery":
+		case "exists":
+			if (deep) visitQuery(node.query, visit);
+			return;
+		case "aggregate":
+			for (const argument of node.arguments) visitNodes(argument, deep, visit);
+			for (const order of node.orderBy) visitNodes(order.expression, deep, visit);
+			return;
+	}
+}
+/** Calls `visit` for each expression node in the clauses and the derived sources of `query` at any depth. */
+function visitQuery(query, visit) {
+	const { from, filters } = query;
+	if (from?.kind === "derived") visitQuery(from.query, visit);
+	for (const join of query.joins) {
+		if (join.source.kind === "derived") visitQuery(join.source.query, visit);
+		visitNodes(join.on, true, visit);
+	}
+	for (const projection of query.projections) visitNodes(projection.expression, true, visit);
+	if (filters.relation !== void 0) visitNodes(filters.relation, true, visit);
+	if (filters.scope !== void 0) visitNodes(filters.scope, true, visit);
+	if (filters.user !== void 0) visitNodes(filters.user, true, visit);
+	for (const order of query.orderBy) visitNodes(order.expression, true, visit);
+	if (query.limit !== void 0) visitNodes(query.limit, true, visit);
+	if (query.offset !== void 0) visitNodes(query.offset, true, visit);
+}
+// src/query/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)
+});
+/** 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
+	}
+});
+/** 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: [/* @__PURE__ */ createNode({
+			kind: "raw",
+			fragments: ["*"],
+			values: []
+		})],
+		orderBy: []
+	}),
+	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) {
+	const definition = aggregateDefinitions[method];
+	const args = [argument.expression];
+	if (delimiter !== void 0) args.push(createNode({
+		kind: "param",
+		value: delimiter,
+		type: void 0
+	}));
+	return Object.freeze({
+		key: method,
+		expression: createNode({
+			kind: "aggregate",
+			name: definition.name,
+			distinct: definition.distinct,
+			arguments: args,
+			orderBy: []
+		}),
+		type: definition.type(argument.type),
+		ordered: definition.ordered,
+		fallbacks: noFallbacks
+	});
+}
+/** 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 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, `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)
+		});
+		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/rows.ts
+/** Returns the rows mode of a query of the records of `relation`, as `RelationRows` gives it in types. */
+function getRelationRows(relation) {
+	if (relation.kind === "many") return "many";
+	return relation.required ? "one" : "nullable";
+}
+/** Returns the rows mode after a filter of a query of rows mode `rows`, of values when `value`, whose row is `guaranteed`, as `FilteredStateRows` gives it in types. */
+function toFilteredRows(rows, value, guaranteed) {
+	if (!guaranteed || rows !== "one") return rows;
+	return value ? "optional" : "nullable";
+}
+/** Returns the limit of a query of many rows that becomes a query of one row, given its limit `limit`: one row, or none under a limit of zero. */
+function limitToOne(limit) {
+	return limit?.kind === "param" && limit.value === 0 ? limit : oneNode;
+}
+/** Returns the rows mode after `pluck` of a query of rows mode `rows`, as `ValueRows` gives it in types. */
+function toValueRows(rows) {
+	return rows === "nullable" ? "optional" : rows;
+}
+// src/query/node.ts
+/** Creates a query of all rows of `from`, or of the records of `relation` with `filters` in the rows mode of the relation. */
+function createQueryNode(from, relation, filters = noFilters) {
+	return Object.freeze({
+		kind: "query",
+		from,
+		relation,
+		projections: [],
+		filters,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		rows: relation === void 0 ? "many" : getRelationRows(relation),
+		value: false,
+		guaranteed: relation?.required ?? false,
+		all: false
+	});
+}
+/** Tells whether `node` is a query of a table without clauses, such as a table of a `Db`: no relation, filters, selected fields, order, limit, offset, rows other than `many`, or `all`. */
+function isTableQuery(node) {
+	return node.relation === void 0 && node.projections.length === 0 && node.filters.relation === void 0 && node.filters.scope === void 0 && node.filters.user === void 0 && node.orderBy.length === 0 && node.limit === void 0 && node.offset === void 0 && node.rows === "many" && !node.all;
+}
+/** Tells whether a selected field is the rows of a nested query. */
+function isNestedSelection(node) {
+	return "query" in node;
+}
+// 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/lowering/order.ts
+/**
+* Returns the position of the projection that has the value of the sort expression `expression`: a projection of the same column or of the same expression node, or `-1`.
+*
+* Only the same node or column guarantees one value: PostgreSQL may or may not evaluate equal expressions built apart once, and gives each its own parameters.
+*/
+function findSortProjection(projections, expression) {
+	return projections.findIndex((projection) => {
+		const selected = projection.expression;
+		return expression.kind === "column" && selected.kind === "column" ? selected.source === expression.source && selected.key === expression.key : selected === expression;
+	});
+}
+/** 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 = findSortProjection(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; 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 paginated = query.limit !== void 0 || query.offset !== void 0;
+	const sortKeys = [];
+	const positions = [];
+	if (orderBy.length > 0 && (ordered || paginated)) for (let index = 0; index < orderBy.length; index++) {
+		const { expression, direction, nulls } = orderBy[index];
+		const position = projectSortKey(projections, expression, index);
+		if (ordered) sortKeys.push({
+			key: projections[position].key,
+			direction,
+			nulls
+		});
+		if (paginated) positions.push(Object.freeze({
+			expression: createPositionNode(position),
+			direction,
+			nulls
+		}));
+	}
+	const derivedQuery = Object.freeze({
+		...query,
+		projections,
+		orderBy: positions,
+		offset
+	});
+	const source = Object.freeze(replaces === void 0 ? {
+		kind: "derived",
+		query: derivedQuery,
+		lateral: false
+	} : {
+		kind: "derived",
+		query: derivedQuery,
+		lateral: false,
+		replaces
+	});
+	const order = [];
+	for (const { key, direction, nulls } of sortKeys) order.push(Object.freeze({
+		expression: createNode({
+			kind: "column",
+			source,
+			key
+		}),
+		direction,
+		nulls
+	}));
+	return {
+		source,
+		order
+	};
+}
+/**
+* Returns the position of the projection that sorts by `expression`: the projection of `findSortProjection`, or one added to `projections`.
+*
+* `index` is the position of the expression in the order.
+*/
+function projectSortKey(projections, expression, index) {
+	const position = findSortProjection(projections, expression);
+	if (position !== -1) return position;
+	projections.push(Object.freeze({
+		key: createSortProjectionKey(projections, index),
+		expression,
+		type: text
+	}));
+	return projections.length - 1;
+}
+/** 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.limit === void 0 && query.offset === void 0 && projections.some((projection) => projection.nested === void 0 && !isTableColumn(projection.expression)) ? zeroNode : query.offset);
+	const wide = projections.length > maxFunctionArguments;
+	const values = [];
+	for (const projection of projections) {
+		const value = createRef(source, projection.key);
+		if (projection.nested !== void 0) values.push(value);
+		else values.push(wide ? createList("to_json(", [packScalar(value)], ")") : packScalar(value));
+	}
+	const row = wide ? createList("array_to_json(ARRAY[", values, "])") : createList("json_build_array(", values, ")");
+	let packed = row;
+	if (many) packed = createNode({
+		kind: "raw",
+		fragments: ["coalesce(", ", '[]'::json)"],
+		values: [createNode({
+			kind: "aggregate",
+			name: "json_agg",
+			distinct: false,
+			arguments: [row],
+			orderBy: order
+		})]
+	});
+	const plan = Object.freeze({
+		fields: projections,
+		rows: query.rows,
+		value: query.value,
+		guaranteedBy: query.guaranteedBy
+	});
+	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/lower.ts
+const noJoins = /* @__PURE__ */ Object.freeze([]);
+const noOrder = /* @__PURE__ */ Object.freeze([]);
+function lowerStatement(node, definitions, db) {
+	switch (node.kind) {
+		case "query": return lowerSelect(node, definitions, db, true);
+		case "record": return lowerRecord(node, definitions, db);
+		case "text": return node;
+		default: return lowerMutation(node, definitions, db);
+	}
+}
+/** Lowers a mutation to its statement, 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, definitions, db) {
+	const { returning } = node;
+	const lowered = returning === void 0 ? void 0 : lowerProjections(returning, definitions, db);
+	if (lowered === returning) return node;
+	const { target, rows, value } = node;
+	switch (node.kind) {
+		case "insert": return Object.freeze({
+			kind: "insert",
+			target,
+			columns: node.columns,
+			values: node.values,
+			returning: lowered,
+			rows,
+			value
+		});
+		case "update": return Object.freeze({
+			kind: "update",
+			target,
+			set: node.set,
+			filters: node.filters,
+			returning: lowered,
+			rows,
+			value
+		});
+		case "delete": return Object.freeze({
+			kind: "delete",
+			target,
+			filters: node.filters,
+			returning: lowered,
+			rows,
+			value
+		});
+		default: return node;
+	}
+}
+/** Lowers a query as `lowerQuery` does, or as `lowerStatement` does when `positions` is set. */
+function lowerSelect(node, definitions, db, positions) {
+	const { relation } = node;
+	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`);
+	if (isAggregateQuery(node)) return lowerAggregate(node);
+	const projections = lowerProjections(node.projections, definitions, db);
+	const guaranteedBy = node.guaranteed && relation !== void 0 ? formatRelationName(relation.key, relation.name) : void 0;
+	const page = node.offset !== void 0 && projections !== node.projections ? lowerPage(node, projections, positions, guaranteedBy) : void 0;
+	if (page !== void 0) return page;
+	return Object.freeze({
+		kind: "select",
+		from: node.from,
+		joins: noJoins,
+		projections,
+		filters: node.filters,
+		orderBy: positions && node.orderBy.length > 0 ? sortByPositions(node.orderBy, projections) : node.orderBy,
+		limit: node.limit,
+		offset: node.offset,
+		rows: node.rows,
+		value: node.value,
+		guaranteedBy
+	});
+}
+/**
+* Lowers `node` with `projections` to a statement that evaluates its nested queries over the rows of a derived page.
+* The derived source applies the filters, the order, the limit, and the offset, and replaces the occurrence of the table.
+*
+* It returns `undefined` when a nested query holds a SQL fragment that refers to a column of the table outside the queries nested in the fragment.
+* Such a fragment may hold an aggregate of the query, which the limit and the offset apply after.
+*
+* The source selects the columns of the table that the fields and the nested queries of the query read, under their keys, and the other scalar fields of the query, which it evaluates before the limit and the offset as the query would, such as a window function over all its rows.
+* A column that no field reads stays out of the source, which could not select it beside an aggregate of a SQL fragment, such as `count(*)`.
+* The order of a derived source does not carry into the query that reads it, so the statement sorts the rows of the page again by the sort keys of the source, by positions when `positions` is set.
+*/
+function lowerPage(node, projections, positions, guaranteedBy) {
+	const { from } = node;
+	const columnKeys = /* @__PURE__ */ new Set();
+	const fields = [];
+	const fieldKeys = [];
+	for (let index = 0; index < projections.length; index++) {
+		const { expression } = projections[index];
+		let key;
+		if (isNestedSelection(node.projections[index])) {
+			if (holdsFragmentOfSource(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);
+	const page = deriveOrderedSource({
+		kind: "select",
+		from,
+		joins: noJoins,
+		projections: sourced,
+		filters: node.filters,
+		orderBy: node.orderBy,
+		limit: node.limit,
+		offset: node.offset,
+		rows: "many",
+		value: false,
+		guaranteedBy: void 0
+	}, true, node.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: node.rows,
+		value: node.value,
+		guaranteedBy
+	});
+}
+/** Lowers an aggregate query to a statement of the value of its aggregate over the rows that its filters, limit, and offset choose. */
+function lowerAggregate(node) {
+	const field = node.projections[0];
+	const aggregate = field.expression;
+	let from = node.from;
+	let filters = node.filters;
+	let args = aggregate.arguments;
+	let order = field.ordered ? node.orderBy : noOrder;
+	const counted = aggregate === countProjection.expression;
+	if (node.limit !== void 0 || node.offset !== void 0 || !counted && !refersToSource(args[0], node.from)) {
+		const projections = [];
+		if (!counted) projections.push(Object.freeze({
+			key: "value",
+			expression: args[0],
+			type: field.type
+		}));
+		const rows = deriveOrderedSource({
+			kind: "select",
+			from: node.from,
+			joins: noJoins,
+			projections,
+			filters: node.filters,
+			orderBy: counted ? noOrder : node.orderBy,
+			limit: node.limit,
+			offset: node.offset,
+			rows: "many",
+			value: false,
+			guaranteedBy: void 0
+		}, field.ordered);
+		from = rows.source;
+		filters = noFilters;
+		if (!counted) {
+			const sourceArgs = [createNode({
+				kind: "column",
+				source: from,
+				key: "value"
+			})];
+			for (let index = 1; index < args.length; index++) sourceArgs.push(args[index]);
+			args = sourceArgs;
+		}
+		order = rows.order;
+	}
+	const call = args === aggregate.arguments && order.length === 0 ? aggregate : createNode({
+		kind: "aggregate",
+		name: aggregate.name,
+		distinct: aggregate.distinct,
+		arguments: args,
+		orderBy: order
+	});
+	const { fallbacks } = field;
+	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 "tableName":
+		case "subquery":
+		case "exists": return false;
+		case "cast":
+		case "not":
+		case "isNull": return refersToSource(node.operand, source);
+		case "and":
+		case "or": return node.operands.some((operand) => refersToSource(operand, source));
+		case "comparison": return refersToSource(node.left, source) || refersToSource(node.right, source);
+		case "in": return refersToSource(node.operand, source) || node.list.some((item) => refersToSource(item, source));
+		case "raw": return node.values.some((value) => refersToSource(value, source));
+		case "aggregate": return node.arguments.some((argument) => refersToSource(argument, source));
+		default: return node;
+	}
+}
+/** Lowers a query of `$select` to a statement without a source, which returns one row of its fields. */
+function lowerRecord(node, definitions, db) {
+	return Object.freeze({
+		kind: "select",
+		from: void 0,
+		joins: noJoins,
+		projections: lowerProjections(node.projections, definitions, db),
+		filters: noFilters,
+		orderBy: noOrder,
+		limit: void 0,
+		offset: void 0,
+		rows: "one",
+		value: false,
+		guaranteedBy: void 0
+	});
+}
+/**
+* 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; checks them as `lowerQuery` does.
+*
+* Without nested queries, it returns `selected` itself.
+*/
+function lowerProjections(selected, definitions, db) {
+	let lowered;
+	for (let index = 0; index < selected.length; index++) {
+		const field = selected[index];
+		if (isNestedSelection(field)) {
+			if (field.db !== void 0 && field.db !== db) throw new Error(db === void 0 ? `Selected field "${field.key}" is bound to a Db, so only that Db can compile the query` : `Selected field "${field.key}" is bound to another Db`);
+			lowered ??= selected.slice(0, index);
+			const query = lowerSelect(field.query, definitions, db, false);
+			lowered.push(isAggregateQuery(field.query) ? projectAggregateValue(field.key, query) : projectRows(field.key, query));
+		} else if (lowered !== void 0) lowered.push(field);
+	}
+	return lowered ?? selected;
+}
+/** 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
+	});
+}
+// 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/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 expressions of the columns of `source`, each with the type of its column. */
+function createColumnRefs(source) {
+	return addColumns({}, source);
+}
+/** Creates the references of the callback of `select` over `source`: its columns, and the relations of `context`. */
+function createSelectionRefs(source, context) {
+	return Object.defineProperties(addColumns({}, source), context.relations);
+}
+function addColumns(refs, source) {
+	const { columns } = source.table;
+	for (const key of Object.keys(columns)) refs[key] = toExpression(createNode({
+		kind: "column",
+		source,
+		key
+	}), columns[key].type);
+	return refs;
+}
+// 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)) {
+				const value = node.values[key];
+				const type = findColumn(source.table, key)?.type;
+				const column = createNode({
+					kind: "column",
+					source,
+					key
+				});
+				if (value === null) conditions.push(createIsNullNode(column));
+				else if (type) conditions.push(matchValue(source, column, type, value));
+				else conditions.push(compareNodes("=", column, value, void 0));
+			}
+			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;
+	}
+}
+/** 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` combined with `AND` with the user filters of `filters`. */
+function addUserFilter(filters, filter, source) {
+	const predicate = resolveValues(toConditionNode(typeof filter === "function" ? filter(createColumnRefs(source)) : filter), source);
+	const { user } = filters;
+	return Object.freeze({
+		...filters,
+		user: user ? combineNodes("and", [user, predicate]) : predicate
+	});
+}
+function defineFilter(_table, filter) {
+	return filter;
+}
+// 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 `expression` in ascending order, in the callback of `orderBy`. */
+function asc(expression) {
+	return orderBy(expression, "asc");
+}
+/** Sorts by `expression` in descending order, in the callback of `orderBy`. */
+function desc(expression) {
+	return orderBy(expression, "desc");
+}
+/** Sorts by `expression` in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
+function orderBy(expression, direction) {
+	if (!isExpression(expression)) throw new TypeError("A sort key must be an expression");
+	return new OrderingObject(createOrderNode(toNode(expression), 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 and the selected fields and returns one sort key or an array of them.
+*/
+function addOrder(node, args) {
+	const order = node.orderBy.slice();
+	const first = args[0];
+	if (typeof first === "function") {
+		const terms = first(createColumnRefs(node.from), createSelectedRefs(node));
+		if (Array.isArray(terms)) for (const term of terms) order.push(readTerm(term));
+		else order.push(readTerm(terms));
+		return order;
+	}
+	for (const arg of args) if (typeof arg === "string") order.push(createOrderNode(createColumnNode(node.from, arg), "asc"));
+	else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+		const columns = arg;
+		for (const key of Object.keys(columns)) order.push(createOrderNode(createColumnNode(node.from, key), columns[key]));
+	} else throw new TypeError("orderBy takes column keys and objects of columns with directions, or a callback");
+	return order;
+}
+/** Creates the sort key node of a sort key returned by the callback of `orderBy`. */
+function readTerm(term) {
+	if (term instanceof OrderingObject) return term[orderingNode];
+	if (isExpression(term)) return createOrderNode(toNode(term), "asc");
+	throw new TypeError("The callback of orderBy must return expressions, or sort keys of asc, desc, and orderBy");
+}
+/** Creates the sort key node of `expression` in `direction`, an `OrderDirection` checked at runtime. */
+function createOrderNode(expression, direction) {
+	const placement = typeof direction === "string" && Object.hasOwn(directions, direction) ? directions[direction] : void 0;
+	if (placement === void 0) throw new TypeError(`Unknown sort direction ${JSON.stringify(direction)}`);
+	return Object.freeze({
+		expression,
+		direction: placement.direction,
+		nulls: placement.nulls
+	});
+}
+/** Creates a reference to the column `key` of the table of `source`. */
+function createColumnNode(source, key) {
+	requireColumn(source.table, key);
+	return createNode({
+		kind: "column",
+		source,
+		key
+	});
+}
+/**
+* Creates the references of the callback of `orderBy` to the fields selected by `node`.
+*
+* Each is an expression over the node of its projection, so that a sort key of it is the projection itself.
+*/
+function createSelectedRefs(node) {
+	const { projections } = node;
+	if (node.value) return toSelectedExpression(projections[0]);
+	const refs = {};
+	for (const projection of projections) {
+		const { key } = projection;
+		if (isNestedSelection(projection)) Object.defineProperty(refs, key, {
+			get() {
+				throw new Error(`Field "${key}" holds a nested query and cannot be sorted by`);
+			},
+			enumerable: true
+		});
+		else refs[key] = toSelectedExpression(projection);
+	}
+	return refs;
+}
+/** Creates an expression over the node of a projection of a query, which has a type: only lowering adds projections of nested queries. */
+function toSelectedExpression(projection) {
+	return toExpression(projection.expression, projection.type);
+}
+// 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 "";
+	return isAggregateQuery(node) ? "; call it before count or another aggregate to aggregate the rows of a page" : "; 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")],
+			value: true,
+			rows: toValueRows(this.node.rows)
+		});
+	}
+	pluck(arg) {
+		this.rejectAggregate("pluck");
+		return this.derive({
+			projections: [projectValue(this.node.from, arg, "pluck")],
+			value: true,
+			rows: toValueRows(this.node.rows)
+		});
+	}
+	count(arg) {
+		if (arg !== void 0) return this.aggregateBy("count", arg);
+		this.rejectAggregate("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);
+	}
+	coalesce(fallback) {
+		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)] });
+	}
+	orderBy(...args) {
+		return this.derive({ orderBy: addOrder(this.node, args) });
+	}
+	limit(count) {
+		return this.derive({ limit: createPageCount(this.node, "limit", count) });
+	}
+	offset(count) {
+		return this.derive({ offset: createPageCount(this.node, "offset", count) });
+	}
+	optional() {
+		return this.changeOneRow("optional", "optional");
+	}
+	nullable() {
+		if (this.node.value) throw new Error("nullable applies only to a query of records; use optional after get, pluck, or an aggregate");
+		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 });
+	}
+	use(callback, ...args) {
+		return requireDerived(this, callback(this, ...args), "The callback of use");
+	}
+	toSQL(options) {
+		return compileToSQL(this, options);
+	}
+	/** 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`, an aggregate over the rows of this query, which always returns one row. */
+	deriveAggregate(projection) {
+		return this.derive({
+			projections: [projection],
+			rows: "one",
+			value: true,
+			guaranteed: false
+		});
+	}
+	/** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
+	aggregateBy(method, arg, delimiter) {
+		this.rejectAggregate(method);
+		return this.deriveAggregate(projectAggregate(method, projectValue(this.node.from, arg, method), 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),
+			rows: toFilteredRows(node.rows, node.value, node.guaranteed),
+			guaranteed: false
+		};
+	}
+	/** 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 a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
+	rejectValue(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. */
+	rejectAggregate(method) {
+		if (isAggregateQuery(this.node)) throw new Error(`${method} cannot be used after an aggregate`);
+	}
+};
+/**
+* Returns `result`, which a callback named by `subject` returned for `query`, after checking that it is `query` or a query derived from it.
+*
+* An ancestor of `query` also passes, since only the source occurrence is compared.
+*/
+function requireDerived(query, result, subject) {
+	if (!(result instanceof SelectQuery) || result.node.from !== query.node.from) throw new Error(`${subject} must return the query it receives or one derived from it`);
+	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/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);
+	}
+	/** 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/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 as a 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 columns 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 as a value.
+*/
+function toAssignments(source, set) {
+	const { table } = source;
+	const values = typeof set === "function" ? set(createColumnRefs(source)) : 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 parameter encoded with the type of the column. */
+function resolveValue(table, key, value) {
+	const column = requireColumn(table, key);
+	if (value instanceof SelectQuery || value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError(`Column "${key}" of table "${table.name}" takes a value or an expression, not a query`);
+	return toValueNode(value, column.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.
+* 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) {
+		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");
+	}
+	toSQL(options) {
+		return compileToSQL(this, options);
+	}
+	/** 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 returns an expression, of each changed row. */
+	deriveValue(arg, method) {
+		const { node } = this;
+		return this.derive({
+			returning: [projectValue(node.target, arg, method)],
+			value: true,
+			rows: toValueRows(node.rows)
+		});
+	}
+};
+/**
+* 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),
+		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 an order, a limit, or an offset, 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.orderBy.length > 0 || node.limit !== void 0 || node.offset !== void 0) throw new Error(`${method} cannot sort or limit the rows it changes; choose them with where, find, or findBy instead of take, limit, offset, or orderBy`);
+	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/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 and queries 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 columns and returns an expression.
+*/
+function projectValue(source, arg, method) {
+	if (typeof arg !== "function") return projectColumn(source, arg);
+	const value = arg(createColumnRefs(source));
+	if (!isExpression(value)) throw new TypeError(`The callback of ${method} must return an expression`);
+	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, or an expression.
+*
+* The projection of an aggregate keeps its call, which lowering builds, and adds the fallback after its earlier ones.
+*/
+function coalesceValue(field, fallback) {
+	if (fallback === null || fallback === void 0) throw new TypeError(`coalesce takes a value other than ${String(fallback)}`);
+	const value = toValueNode(fallback, field.type);
+	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, or a query whose rows become its value. */
+function selectValue(key, value) {
+	if (value instanceof SelectQuery) 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 or a query`);
+	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/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 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);
+	}
+};
+/**
+* Starts the query of `$select` of `selection`, an object of expressions and queries 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/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 `select`, 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);
+}
+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);
+	}
+	const node = toValueNode(value, type);
+	return toExpression(node.kind === "param" ? createNode({
+		kind: "cast",
+		operand: node,
+		type
+	}) : node, 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: interpolated expressions keep their nodes, a query of a table without clauses becomes the name of the table, qualified by the PostgreSQL schema of the statement, and other values become query parameters.
+*
+* It rejects 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) {
+		if (!isTableQuery(value.node)) throw new TypeError("sql takes a query of a table without clauses, such as db.form, as the name of the table, not a query with clauses");
+		return createNode({
+			kind: "tableName",
+			table: value.table,
+			db: value.db
+		});
+	}
+	if (value instanceof RecordQuery || value instanceof MutationQuery || value instanceof SqlQuery) throw new TypeError("sql takes a query of a table without clauses, such as db.form, as the name of the table, not another query");
+	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);
+			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 takes no values, since it has no parameters; interpolate only tables and sql fragments without values");
+			return database.script(text);
+		},
+		$transaction: (callback, options) => database.transaction(callback, options)
+	};
+	const contexts = createQueryContexts(Object.keys(schema.$tables), relations);
+	const db = defineEntries(methods, schema.$tables, (key) => bindQuery(startQuery(schema.$tables[key], contexts[key]), db));
+	return db;
+}
+// src/execution/transaction.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();
+	/** Open test fixtures, the innermost last. */
+	#fixtures = [];
+	/** Changes of the fixture stack, run one after another so that each one sees the stack the previous one left. */
+	#transitions = Promise.resolve();
+	/**
+	* The `close` functions of the test fixtures that are still opening, from the call that starts the opening until the fixture enters the stack or the opening ends otherwise.
+	*
+	* An opening holds the queue of the fixture stack while its seed runs, so a closing of the stack queued behind it would wait for a seed that may never settle.
+	* Closing the stack therefore calls these first: each one tells its opening to stop waiting for the seed.
+	*/
+	#openings = /* @__PURE__ */ new Set();
+	/**
+	* Outermost fixture in the stack whose closing is queued but has not finished.
+	*
+	* Openings that start after that closing is requested nest outside of the fixture once it closes, so a repeated closing of it, or a closing of a fixture nested in it, must not close them.
+	*/
+	#closing;
+	/** Closing of the database, set by the first `close`; from then on, operations outside a transaction reject. */
+	#closed;
+	constructor(driver, test = false) {
+		this.driver = driver;
+		this.test = test;
+	}
+	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 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.#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) {
+		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 (!this.test) return {
+			fixture: Promise.reject(/* @__PURE__ */ new Error("createTestFixture requires a database created with test: true")),
+			close
+		};
+		if (this.#storage.getStore()) return {
+			fixture: Promise.reject(/* @__PURE__ */ new Error("Cannot create a test fixture inside a transaction")),
+			close
+		};
+		if (this.#closed) return {
+			fixture: Promise.reject(createDatabaseClosedError("create a test fixture")),
+			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
+		};
+	}
+	/**
+	* 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.#closeAfterOpenings(() => this.#enqueue(() => {
+				const root = this.#fixtures[0];
+				return root && this.#closeFixture(root);
+			}));
+		} catch (error) {
+			rejection = { error };
+		}
+		try {
+			await this.driver.close();
+		} catch (error) {
+			rejection = suppress(error, rejection, "Closing the driver failed");
+		}
+		if (rejection) throw rejection.error;
+	}
+	/**
+	* Closes 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 this.#run(await this.#startNested(fixture), 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 this.#end(fixture, false);
+		return fixture.parent ? cleanup.rejection : releaseConnection(fixture.connection, cleanup.failure, cleanup.rejection);
+	}
+	/**
+	* Starts the level of a test transaction in the innermost test fixture as a change of the fixture stack, resolving to `undefined` when no fixture is open.
+	*
+	* Aborted while it waits for its turn, it rejects at once and its change starts nothing, so that a test that has already ended never preempts the active level of the fixture.
+	* From its turn on, it settles with its change.
+	*/
+	#startTestLevel(signal) {
+		let waiting = true;
+		const start = () => this.#enqueue(() => {
+			if (signal?.aborted) return;
+			waiting = false;
+			const fixture = this.#fixtures.at(-1);
+			return fixture && this.#startInFixture(fixture, signal);
+		});
+		return signal ? settleUnlessAborted(start, signal, () => waiting) : start();
+	}
+	/** Runs a change of the fixture stack after the earlier ones. */
+	#enqueue(transition) {
+		const result = this.#transitions.then(transition);
+		this.#transitions = result.catch(() => {});
+		return result;
+	}
+	/** Starts the first test fixture: a transaction on a reserved connection. */
+	async #beginFixture() {
+		const connection = await this.driver.acquire();
+		try {
+			await connection.execute(beginStatement);
+		} catch (error) {
+			throw (await releaseConnection(connection, { error }, { error })).error;
+		}
+		return createLevel(connection, void 0);
+	}
+	/**
+	* 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 this.#end(fixture.child, false, "preemption");
+			if (cleanup.rejection) throw suppressAbortReason(new Error("Cannot start a level of the test fixture: ending its active level failed", { cause: cleanup.rejection.error }), signal);
+		}
+		const unavailable = createUnavailableError(fixture, "start a level of the test fixture");
+		if (unavailable) throw suppressAbortReason(unavailable, signal);
+		signal?.throwIfAborted();
+		return this.#startNested(fixture, signal);
+	}
+	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);
+		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(this.#end(level, false), error);
+		}
+		outcome ??= await this.#run(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 this.#startNested(parent, signal, settings), callback, commits, signal);
+	}
+	/**
+	* Reserves a nested level of `parent`, sends its `SAVEPOINT`, and applies its `settings`, rejecting when one of them fails.
+	*
+	* A level whose settings fail rolls back to its savepoint first.
+	* The failure suppresses the reason of `signal` when the signal aborted before it.
+	*/
+	async #startNested(parent, signal, settings) {
+		const level = createLevel(parent.connection, parent);
+		parent.child = level;
+		try {
+			await level.connection.execute(createStatement(`SAVEPOINT ${getSavepointName(level)}`));
+		} catch (error) {
+			if (!level.cleanup) {
+				closeStarting(level);
+				throw suppressAbortReason(error, signal);
+			}
+			throw suppressAbortReason(combineRejections({ error }, await level.cleanup).error, signal);
+		}
+		if (settings) try {
+			await applySettings(level, settings);
+		} catch (error) {
+			throw suppressAbortReason(combineRejections({ error }, await this.#end(level, false)).error, signal);
+		}
+		return level;
+	}
+	/** Runs `callback` in a started level, returning its result or throwing its rejection. */
+	async #runStarted(level, callback, commits, signal) {
+		const { result, rejection } = await this.#run(level, callback, commits, signal);
+		if (rejection) throw rejection.error;
+		return result;
+	}
+	/**
+	* Runs `callback` in the context of a started `level`, then ends the level.
+	*
+	* A level that `commits` commits only when the callback resolves with no nested level running and no nested level that failed to end.
+	* When `signal` aborts, the level ends at once without waiting for the callback, and its outcome is a rejection with the reason of the signal.
+	*/
+	async #run(level, callback, commits, signal) {
+		if (level.cleanup) return getEndedOutcome(level.cleanup, createClosedError(level, void 0));
+		let result;
+		let rejection;
+		if (signal?.aborted) this.#end(level, false, "abort");
+		else {
+			level.state = "open";
+			try {
+				result = await (signal ? settleUnlessAborted(() => this.#storage.run(level, callback), signal, () => {
+					this.#end(level, false, "abort");
+					return true;
+				}) : this.#storage.run(level, callback));
+			} catch (error) {
+				rejection = { error };
+			}
+		}
+		if (level.cleanup) return getEndedOutcome(level.cleanup, level.endedBy === "abort" ? signal?.reason : createClosedError(level, rejection));
+		if (!rejection && level.child) rejection = { error: /* @__PURE__ */ new Error("Transaction was rolled back: a nested transaction was still running when its callback finished") };
+		if (!rejection && level.rollbackOnly) rejection = { error: new Error("Transaction was rolled back: a nested transaction failed to end", { cause: level.rollbackOnly.error }) };
+		const cleanup = await this.#end(level, commits && !rejection);
+		return {
+			result,
+			rejection: combineRejections(rejection, cleanup),
+			failure: cleanup.failure
+		};
+	}
+	/**
+	* Ends `level` once, whoever ends it: later calls return the cleanup already started.
+	*
+	* Statements of the level and of all levels nested in it fail from the start of the cleanup, and the nested levels end before it.
+	*/
+	#end(level, commit, endedBy) {
+		if (level.cleanup) return level.cleanup;
+		level.endedBy = endedBy;
+		level.state = "closing";
+		const nested = level.child && this.#end(level.child, false, "enclosing level");
+		level.cleanup = this.#cleanUp(level, commit, nested);
+		return level.cleanup;
+	}
+	async #cleanUp(level, commit, nested) {
+		const nestedCleanup = await nested;
+		const { parent } = level;
+		const cleanup = parent ? await endSavepoint(level, commit && !level.rollbackOnly) : await endTransaction(level.connection, commit);
+		level.state = "closed";
+		if (parent) {
+			if (parent.child === level) parent.child = void 0;
+			parent.rollbackOnly ??= cleanup.rejection;
+		}
+		return {
+			rejection: combineRejections(nestedCleanup?.rejection, cleanup),
+			failure: cleanup.failure
+		};
+	}
+};
+const beginStatement = createStatement("BEGIN");
+const commitStatement = createStatement("COMMIT");
+const rollbackStatement = createStatement("ROLLBACK");
+function createLevel(connection, parent) {
+	return {
+		connection,
+		parent,
+		depth: parent ? parent.depth + 1 : 0,
+		state: "starting",
+		child: void 0,
+		rollbackOnly: void 0,
+		cleanup: void 0,
+		endedBy: void 0,
+		restore: void 0
+	};
+}
+/** Settings of a level of `transaction` with `options`, or `undefined` when it has none. */
+function getLevelSettings(options) {
+	return options?.searchPath ? [{
+		name: "search_path",
+		value: options.searchPath.map(quoteIdentifier).join(", ")
+	}] : void 0;
+}
+/**
+* Applies `settings` to a level whose `BEGIN` or `SAVEPOINT` completed, unless its cleanup has started.
+*
+* A nested level first reads the values they replace, which it restores before its `RELEASE`: PostgreSQL keeps a setting of a released savepoint until the transaction ends, while `ROLLBACK TO` restores it itself.
+*/
+async function applySettings(level, settings) {
+	if (level.cleanup) return;
+	if (level.parent) {
+		let text = "SELECT";
+		const names = [];
+		for (const { name } of settings) {
+			names.push(name);
+			text += `${names.length > 1 ? "," : ""} current_setting($${names.length})`;
+		}
+		const values = (await level.connection.execute(createStatement(text, names))).rows[0];
+		level.restore = createSettingStatement(settings.map(({ name }, index) => ({
+			name,
+			value: values[index]
+		})));
+		if (level.cleanup) return;
+	}
+	await level.connection.execute(createSettingStatement(settings));
+}
+/** Creates the statement that sets `settings` until the transaction ends or rolls back to an earlier savepoint, as `SET LOCAL` does. */
+function createSettingStatement(settings) {
+	let text = "SELECT";
+	const parameters = [];
+	for (const { name, value } of settings) {
+		parameters.push(name, value);
+		text += `${parameters.length > 2 ? "," : ""} set_config($${parameters.length - 1}, $${parameters.length}, true)`;
+	}
+	return createStatement(text, parameters);
+}
+/** Name of the savepoint of a nested level; a level has at most one nested level, so the depth makes it unique. */
+function getSavepointName(level) {
+	return `kern_${level.depth}`;
+}
+/**
+* Creates the error of `operation` on a level that rejects statements and nested levels, or returns `undefined` when it accepts them.
+*
+* A level that can only roll back keeps the failure of its nested level as the cause.
+*/
+function createUnavailableError(level, operation) {
+	if (level.state !== "open") return /* @__PURE__ */ new Error(`Cannot ${operation}: its transaction is already finished`);
+	if (level.child) return /* @__PURE__ */ new Error(`Cannot ${operation}: a nested transaction is running; await it first`);
+	if (level.rollbackOnly) return new Error(`Cannot ${operation}: a nested transaction failed to end, so the transaction can only roll back`, { cause: level.rollbackOnly.error });
+}
+/** Error message of an operation outside a test transaction on a coordinator created for tests. */
+function describeOutsideTest(operation) {
+	return `Cannot ${operation} outside a test transaction: the database was created with test: true, so wrap the test in testTransaction`;
+}
+/** 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`);
+}
+/** Closes a nested level whose `SAVEPOINT` failed, freeing its parent for other statements. */
+function closeStarting(level) {
+	level.state = "closed";
+	if (level.parent?.child === level) level.parent.child = void 0;
+}
+/** Error of a level that another level ended, keeping the rejection of its callback as the cause. */
+function createClosedError(level, rejection) {
+	return new Error(level.endedBy === "preemption" ? "Transaction was rolled back: its test fixture started another level before it finished" : "Transaction was rolled back: its enclosing transaction ended first", rejection && { cause: rejection.error });
+}
+/** Error of a failure to start a test transaction, which suppresses the reason of `signal` when the signal aborted before the failure. */
+function suppressAbortReason(error, signal) {
+	return signal?.aborted ? suppress(error, { error: signal.reason }, "Starting the test transaction failed").error : error;
+}
+/** Outcome of a level that something other than its callback ended: a rejection with `error`, which a failed cleanup suppresses. */
+async function getEndedOutcome(cleanup, error) {
+	const ended = await cleanup;
+	return {
+		rejection: combineRejections({ error }, ended),
+		failure: ended.failure
+	};
+}
+/**
+* Runs `start` and settles as its promise, or rejects with the reason of `signal` when it aborts first and `abort`, called on the abort, returns `true`.
+*
+* It listens from before `start`, which may abort the signal before it returns, and stops once the promise of `start` settles, such as for the signal that `node:test` aborts after every test.
+* A later rejection of that promise stays handled, and a value it resolves with after the rejection goes to `discard`, which handles its own failures.
+*/
+function settleUnlessAborted(start, signal, abort, discard) {
+	const settled = Promise.withResolvers();
+	let abandoned = false;
+	const onAbort = () => {
+		if (abort()) {
+			abandoned = true;
+			settled.reject(signal.reason);
+		}
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	let running;
+	try {
+		running = start();
+	} catch (error) {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+		return settled.promise;
+	}
+	running.then((value) => {
+		signal.removeEventListener("abort", onAbort);
+		if (abandoned) discard?.(value);
+		else settled.resolve(value);
+	}, (error) => {
+		signal.removeEventListener("abort", onAbort);
+		settled.reject(error);
+	});
+	return settled.promise;
+}
+/**
+* Acquires a connection for a test transaction, rejecting with the reason of `signal` when it aborts first.
+*
+* A connection acquired after the abort returns to the pool as best-effort cleanup: the test transaction has already rejected, so nothing awaits the release, and its failure is ignored.
+*/
+function acquireUnlessAborted(driver, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return settleUnlessAborted(() => driver.acquire(), signal, () => true, (connection) => {
+		Promise.resolve().then(() => connection.release()).catch(() => {});
+	});
+}
+/** Returns the connection of a transaction to the driver, keeping a failed release as a rejection that suppresses `rejection`. */
+async function releaseConnection(connection, failure, rejection) {
+	try {
+		await connection.release(failure);
+		return rejection;
+	} catch (error) {
+		return suppress(error, rejection, "Releasing the transaction connection failed");
+	}
+}
+/** Ends a transaction with `COMMIT` or `ROLLBACK`. */
+async function endTransaction(connection, commit) {
+	try {
+		const { command } = await connection.execute(commit ? commitStatement : rollbackStatement);
+		if (commit && command !== "COMMIT") return { rejection: { error: /* @__PURE__ */ new Error("Transaction was rolled back: a statement in it failed") } };
+		return {};
+	} catch (error) {
+		return {
+			rejection: { error },
+			failure: { error }
+		};
+	}
+}
+/**
+* Ends the savepoint of a nested level, releasing it on commit and rolling back to it otherwise.
+*
+* Before a release, it restores the settings that the level changed; a rollback restores them itself.
+*/
+async function endSavepoint(level, commit) {
+	const name = getSavepointName(level);
+	try {
+		if (!commit) await level.connection.execute(createStatement(`ROLLBACK TO SAVEPOINT ${name}`));
+		else if (level.restore) await level.connection.execute(level.restore);
+		await level.connection.execute(createStatement(`RELEASE SAVEPOINT ${name}`));
+		return {};
+	} catch (error) {
+		return { rejection: { error } };
+	}
+}
+/** Rejection with the error of a cleanup, which suppresses the `earlier` rejection if there is one. */
+function combineRejections(earlier, cleanup) {
+	return cleanup.rejection ? suppress(cleanup.rejection.error, earlier, "Transaction rollback failed") : earlier;
+}
+/** Rejection with `error`, which suppresses the `earlier` rejection if there is one. */
+function suppress(error, earlier, message) {
+	return { error: earlier ? new SuppressedError(error, earlier.error, message) : error };
+}
+// src/execution/database.ts
+/** Creates a database over a driver; its transactions are shared by every schema bound to it. */
+function createDatabase({ driver, test }) {
+	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),
+		close: () => coordinator.close(),
+		[Symbol.asyncDispose]: () => coordinator.close()
+	};
+	return database;
+}
+// src/query/helper.ts
+function defineHelper(_table, helper) {
+	return (query, ...args) => requireDerived(query, helper(query, ...args), "The callback of a helper");
+}
+export { NotFoundError, RequiredRelationError, ResultDecodeError, and, asc, compare, createDatabase, createStatement, defineFilter, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, from, many, not, one, or, orderBy, orderingOperators, param, sql, textOperators };