better-supabase 0.12.0 → 0.13.0

package/dist/define-DwZ_LQVO.js

@@ -0,0 +1,2011 @@
+import { r as isPlainObject, t as cloneValue } from "./clone-CkG0-hlI.js";
+import { t as DbException } from "./db-exception-CnWcYPxL.js";
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { n as invalidRequest, t as builderFor } from "./build-UqJeGtsH.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { i as or, n as column, r as not, t as and } from "./types-R6syp1el.js";
+import { c as optionalTemporal, l as provideTemporal, s as nowInstant, u as providedTemporal } from "./temporal-DLZlWbOi.js";
+import { i as encodeValue, n as decodeScalar, r as decodeValue } from "./wire-BJhepFbv.js";
+import { a as ok, c as withErrorMapper, r as err, s as toDbError, t as AsyncResult } from "./result-DIT_qp4G.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
+import { t as vectorLiteral } from "./search-Cn_DGluL.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { n as errorEvent, t as EventHub } from "./events-D6IZ5CE8.js";
+import { n as isRecord, t as isList } from "./guards-6F2bCtQR.js";
+import { i as orderPlugins } from "./plugin-D9bYbYli.js";
+import { t as simplify } from "./simplify-DDO0j0LI.js";
+import { a as postgrestExecutor, c as invalidTuning, l as tuningOf, n as StatsRecorder, o as NO_TUNING, r as recordStats, s as deadline } from "./stats-Bt1RyT-F.js";
+import { d as isQuerySpec, f as specTables, n as checkParams, o as isReadSet, r as containsPlaceholder, t as bindParams, u as createSpecs } from "./read-set-DP6fm21F.js";
+import { a as toBase64Url, t as base64ToText } from "./base64-B9Wlsdj7.js";
+import { n as validate } from "./standard-l10kE0yS.js";
+//#region src/core/batch.ts
+/**
+* A signal that aborts once every reader's signal has, so one reader giving up
+* never cancels the operations of the others. `undefined` when a reader has no
+* signal.
+*/
+function allAborted(signals) {
+	const present = signals.filter((signal) => signal !== void 0);
+	if (present.length < signals.length) return;
+	if (present.length === 1) return present[0];
+	const controller = new AbortController();
+	const check = () => {
+		if (present.every((signal) => signal.aborted)) controller.abort();
+	};
+	for (const signal of present) signal.addEventListener("abort", check, { once: true });
+	check();
+	return controller.signal;
+}
+/**
+* Holds operations until each of `readers` has either submitted one or
+* finished, then runs the held ones through `batch` together. A reader that
+* runs a second operation joins the next batch.
+*/
+function batchingExecutor(base, readers) {
+	let running = readers;
+	const queue = [];
+	const flush = () => {
+		if (queue.length === 0 || queue.length < running) return;
+		const items = queue.splice(0);
+		const { signal: _first, ...shared } = items[0].context;
+		const signal = allAborted(items.map((item) => item.context.signal));
+		const context = signal ? {
+			...shared,
+			signal
+		} : shared;
+		for (const item of items) item.context.signal?.addEventListener("abort", () => {
+			item.resolve(err(dbError("aborted", "The request was aborted")));
+		}, { once: true });
+		base.batch(items.map((item) => item.op), context).then((results) => {
+			for (const [index, item] of items.entries()) item.resolve(results[index] ?? err(toDbError(/* @__PURE__ */ new Error(`Executor "${base.name}" returned too few results`))));
+		}, (cause) => {
+			for (const item of items) item.resolve(err(toDbError(cause)));
+		});
+	};
+	return {
+		executor: {
+			name: base.name,
+			execute: (op, context) => new Promise((resolve) => {
+				queue.push({
+					op,
+					context,
+					resolve
+				});
+				flush();
+			}),
+			...base.rpc ? { rpc: base.rpc.bind(base) } : {}
+		},
+		done: () => {
+			running -= 1;
+			flush();
+		}
+	};
+}
+//#endregion
+//#region src/core/cache.ts
+/** Primary key of a row as a string, or `undefined` when it isn't returned. */
+function rowKey(table, row) {
+	if (table.primaryKey.length === 0) return;
+	const parts = table.primaryKey.map((column) => row[column]);
+	if (parts.some((part) => part === void 0 || part === null)) return;
+	return parts.map(String).join(",");
+}
+function cacheTargetOf(meta, notice) {
+	const table = meta.tables[notice.table];
+	const rows = notice.rows.length > 0 ? notice.rows : notice.keys ?? [];
+	const ids = table ? [...new Set(rows.flatMap((row) => rowKey(table, row) ?? []))] : [];
+	const tenant = notice.tenant ?? notice.context.tenant;
+	return {
+		table: notice.table,
+		tables: notice.kind === "delete" ? invalidationTargets(meta, notice.table) : [notice.table],
+		ids,
+		...tenant === void 0 ? {} : { tenant }
+	};
+}
+/** One target per table an RPC changes; RPCs report no row ids. */
+function rpcCacheTargets(meta, notice) {
+	const tenant = notice.context.tenant;
+	return notice.invalidates.map((table) => ({
+		table,
+		tables: invalidationTargets(meta, table),
+		ids: [],
+		...tenant === void 0 ? {} : { tenant }
+	}));
+}
+/** Records invalidations. For tests and for checking what a mutation touches. */
+function memoryCache() {
+	const invalidated = [];
+	return {
+		name: "memory",
+		invalidated,
+		invalidate: (target) => {
+			invalidated.push(target);
+		},
+		clear: () => {
+			invalidated.length = 0;
+		}
+	};
+}
+//#endregion
+//#region src/core/db-search.ts
+/**
+* `db.$search({ score: true })`: the ranked ids and scores from
+* `search_<table>_scores`, then those rows through the table (RLS and `where`
+* apply), best first, each with `$score`.
+*/
+async function scoredSearch(runner, table, fnArgs, args, hint) {
+	const [key, ...rest] = table.primaryKey;
+	if (key === void 0 || rest.length > 0) return err(dbError("invalid_request", "db.$search({ score: true }) needs a table with a one-column primary key", { table: table.key }));
+	const { builder } = runner.runtime;
+	const scoresTable = {
+		key: `${table.key}$scores`,
+		name: `search_${table.name}_scores`,
+		schema: table.schema,
+		kind: "view",
+		columns: {
+			id: {
+				db: "id",
+				type: "jsonb",
+				nullable: false,
+				hasDefault: false
+			},
+			score: {
+				db: "score",
+				type: "float8",
+				nullable: false,
+				hasDefault: false
+			}
+		},
+		primaryKey: [],
+		uniqueKeys: {},
+		relations: {},
+		flags: {}
+	};
+	const scored = await runner.runInternal({
+		kind: "select",
+		table: scoresTable,
+		selection: builder.selection(scoresTable, ["id", "score"], void 0),
+		where: void 0,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		count: void 0,
+		head: false,
+		single: void 0,
+		source: {
+			schema: table.schema,
+			name: scoresTable.name,
+			args: fnArgs
+		}
+	}, table, args.signal);
+	if (!scored.ok) return err(hint(scored.error));
+	const ranked = scored.data.rows.flatMap((row) => row["score"] === void 0 || row["score"] === null ? [] : [{
+		id: row["id"],
+		score: Number(row["score"])
+	}]);
+	if (ranked.length === 0) return ok([]);
+	const byId = new Map(ranked.map((entry) => [String(entry.id), entry]));
+	const op = {
+		kind: "select",
+		table,
+		selection: builder.selection(table, args.select, args.include),
+		where: builder.where(table, { AND: [...args.where === void 0 ? [] : [args.where], { [key]: { in: ranked.map((entry) => entry.id) } }] }),
+		orderBy: [],
+		limit: ranked.length,
+		offset: void 0,
+		count: void 0,
+		head: false,
+		single: void 0
+	};
+	const result = await runner.run(op, {}, args.signal);
+	if (!result.ok) return result;
+	return ok(result.data.rows.flatMap((row) => {
+		const entry = byId.get(String(row[key]));
+		return entry ? [{
+			...row,
+			$score: entry.score
+		}] : [];
+	}).toSorted((a, b) => b.$score - a.$score));
+}
+/**
+* `db.$search(table, args)`: nearest rows from the table's `search_<table>`
+* function.
+*/
+function searchTable(runner, base, meta, name, args) {
+	return AsyncResult.from(async () => {
+		const table = Object.hasOwn(meta.tables, name) ? meta.tables[name] : void 0;
+		if (!table) return err(dbError("invalid_request", `db.$search(): unknown table "${name}"`));
+		if (!base.functionSources) return err(dbError("invalid_request", `db.$search() reads from a function; the ${base.name} executor doesn't support that`, { table: table.key }));
+		const query = (args.vector === void 0 || args.vector === null) && args.text !== void 0 ? null : vectorLiteral(args.vector ?? []);
+		const k = args.k ?? 10;
+		if (query === void 0 || !Number.isInteger(k) || k < 1) return err(dbError("invalid_input", "db.$search() needs a vector of finite numbers (or text alone on a hybrid entry) and a positive integer k", { table: table.key }));
+		const { builder } = runner.runtime;
+		const fnArgs = {
+			query,
+			k,
+			...args.filter === void 0 ? {} : { filter: args.filter },
+			...args.text === void 0 ? {} : { text_query: args.text }
+		};
+		const hint = (error) => error.code === "PGRST202" || error.code === "42883" ? {
+			...error,
+			hint: `Add "${table.schema}.${table.name}" to vectorSearch in better-supabase.config.ts (with prefilter or hybrid for filter and text) and run \`better-supabase sql sync\`.`
+		} : error;
+		if (args.score) return scoredSearch(runner, table, fnArgs, args, hint);
+		const op = {
+			kind: "select",
+			table,
+			selection: builder.selection(table, args.select, args.include),
+			where: builder.where(table, args.where),
+			orderBy: [],
+			limit: k,
+			offset: void 0,
+			count: void 0,
+			head: false,
+			single: void 0,
+			source: {
+				schema: table.schema,
+				name: `search_${table.name}`,
+				args: fnArgs
+			}
+		};
+		const result = await runner.run(op, {}, args.signal);
+		if (result.ok) return ok(result.data.rows);
+		return err(hint(result.error));
+	});
+}
+//#endregion
+//#region src/core/define-plugins.ts
+function isExecutor(value) {
+	return typeof value === "object" && value !== null && typeof value.execute === "function" && typeof value.name === "string";
+}
+/** No plugins, one shared array so the caches keyed on a plugin list hit. */
+const NO_PLUGINS = Object.freeze([]);
+/**
+* The kept lists per installed list and `keep` names, so each is one stable
+* array.
+*/
+const keptLists = /* @__PURE__ */ new WeakMap();
+/**
+* The installed plugins named in `keep`; a name that isn't installed throws, so
+* a typo can't drop tracing silently.
+*/
+function keptPlugins(plugins, keep) {
+	if (keep.length === 0) return NO_PLUGINS;
+	let byKeep = keptLists.get(plugins);
+	if (!byKeep) {
+		byKeep = /* @__PURE__ */ new Map();
+		keptLists.set(plugins, byKeep);
+	}
+	const key = keep.join("\0");
+	const cached = byKeep.get(key);
+	if (cached) return cached;
+	for (const name of keep) if (!plugins.some((plugin) => plugin.name === name)) throw new TypeError(`better-supabase: $withoutPlugins({ keep }) names "${name}", which is not installed. Installed: ${plugins.map((plugin) => plugin.name).join(", ") || "none"}`);
+	const kept = plugins.filter((plugin) => keep.includes(plugin.name));
+	byKeep.set(key, kept);
+	return kept;
+}
+//#endregion
+//#region src/core/diagnostics.ts
+/**
+* Debug records for the `diagnostics` option, after the Supabase SDK capability
+* `client.observability.diagnostic_logging`
+* (`SPEC_PINS.supabaseSdkCapabilities`). Fields are names, kinds, counts and
+* timings only: never tokens, keys, row values, filters, query strings, headers
+* or database error messages, which can quote the data.
+*/
+function logDiagnostics(events) {
+	const logger = { debug(message, fields) {
+		try {
+			events.logger.debug(message, fields);
+		} catch {}
+	} };
+	events.on("query", (event) => {
+		logger.debug(`${event.operation} ${event.table} ${event.ok ? "ok" : "failed"} in ${String(Math.round(event.durationMs))}ms`, {
+			table: event.table,
+			operation: event.operation,
+			ok: event.ok,
+			durationMs: event.durationMs,
+			rows: event.rows,
+			truncated: event.truncated
+		});
+	});
+	events.on("error", ({ table, error }) => {
+		logger.debug(`${error.kind} error${table ? ` on ${table}` : ""}`, {
+			...table ? { table } : {},
+			kind: error.kind,
+			status: error.status,
+			...error.code ? { code: error.code } : {}
+		});
+	});
+	events.on("refresh", (event) => {
+		logger.debug(`session refresh ${event.ok ? "ok" : "failed"} in ${String(Math.round(event.durationMs))}ms`, {
+			ok: event.ok,
+			shared: event.shared,
+			durationMs: event.durationMs
+		});
+	});
+	events.on("auth", (event) => {
+		logger.debug(`auth from ${event.source}: ${event.ok ? "user" : event.reason ?? "no user"}`, {
+			source: event.source,
+			ok: event.ok,
+			...event.reason ? { reason: event.reason } : {}
+		});
+	});
+}
+/**
+* The event hub of a new definition, with the diagnostic handlers when
+* `diagnostics` is on.
+*/
+function definitionEvents(options) {
+	const events = new EventHub(options.logger ?? consoleLogger, options.now);
+	if (options.diagnostics === true) logDiagnostics(events);
+	return events;
+}
+//#endregion
+//#region src/ir/codec.ts
+/** Whether decoding `selection` changes anything, so plain reads skip the walk. */
+function needsDecoding(selection) {
+	let needs = decodes.get(selection);
+	if (needs === void 0) {
+		needs = computeNeedsDecoding(selection);
+		decodes.set(selection, needs);
+	}
+	return needs;
+}
+const decodes = /* @__PURE__ */ new WeakMap();
+function computeNeedsDecoding(selection) {
+	return selection.aggregate !== void 0 || selection.columns.some((column) => column.codec !== void 0) || selection.includes.some((include) => include.count !== void 0 || include.aggregate !== void 0 || needsDecoding(include.selection));
+}
+/**
+* PostgREST returns `[{ count }]` for a `(count)` embed; SQL returns the
+* number.
+*/
+function countOf$1(value) {
+	if (Array.isArray(value)) {
+		const first = value[0];
+		return Number(first?.count ?? 0);
+	}
+	return Number(value ?? 0);
+}
+function measureOf(measure, value) {
+	if (value === void 0 || value === null) return null;
+	return measure.codec ? decodeScalar(measure.codec, value) : value;
+}
+/** Adds `value` under `row[key][name]`, next to what is already there. */
+function fold(row, folded, key, name, value) {
+	let target = folded.get(key);
+	if (!target) {
+		target = { ...row[key] };
+		folded.set(key, target);
+		row[key] = target;
+	}
+	target[name] = value;
+}
+const droppedKeys = /* @__PURE__ */ new WeakMap();
+/** Wire keys that decoding folds into `_count`, `_sum` and the rest. */
+function droppedOf(selection) {
+	let dropped = droppedKeys.get(selection);
+	if (!dropped) {
+		dropped = /* @__PURE__ */ new Set([...selection.aggregate?.measures.map((measure) => measure.key) ?? [], ...selection.includes.filter((include) => include.count !== void 0 || include.aggregate !== void 0).map((include) => include.alias)]);
+		droppedKeys.set(selection, dropped);
+	}
+	return dropped;
+}
+function decodeRow$1(selection, row) {
+	const dropped = droppedOf(selection);
+	const out = {};
+	for (const key in row) if (!dropped.has(key) && Object.hasOwn(row, key)) out[key] = row[key];
+	const folded = /* @__PURE__ */ new Map();
+	for (const column of selection.columns) {
+		if (!column.codec || !(column.alias in out)) continue;
+		try {
+			out[column.alias] = decodeValue(column.codec, out[column.alias]);
+		} catch (cause) {
+			if (!(cause instanceof DbException) || cause.error.kind !== "invalid_value") throw cause;
+			throw new DbException(dbError("invalid_value", `${column.alias}: ${cause.error.message}`, { column: column.alias }));
+		}
+	}
+	if (selection.aggregate) {
+		if (selection.aggregate.count) out["_count"] = countOf$1(out["_count"]);
+		for (const measure of selection.aggregate.measures) {
+			const value = row[measure.key];
+			fold(out, folded, `_${measure.fn}`, measure.alias, measureOf(measure, value));
+		}
+	}
+	for (const include of selection.includes) {
+		const value = row[include.alias];
+		if (include.count !== void 0) {
+			if (!(include.alias in row)) continue;
+			fold(out, folded, "_count", include.count, countOf$1(value));
+			continue;
+		}
+		if (include.aggregate !== void 0) {
+			if (!(include.alias in row)) continue;
+			const inner = Array.isArray(value) ? value[0] : value;
+			const measures = {};
+			for (const measure of include.selection.aggregate?.measures ?? []) measures[measure.alias] = measureOf(measure, inner?.[measure.key]);
+			fold(out, folded, `_${include.aggregate.fn}`, include.aggregate.name, measures);
+			continue;
+		}
+		if (Array.isArray(value)) out[include.alias] = value.map((item) => decodeRow$1(include.selection, item));
+		else if (value && typeof value === "object") out[include.alias] = decodeRow$1(include.selection, value);
+	}
+	return out;
+}
+/** Applies column codecs to returned rows, including embedded relations. */
+function decodeRows(selection, rows, checked = false) {
+	if (!selection || !checked && !needsDecoding(selection)) return rows;
+	return rows.map((row) => decodeRow$1(selection, row));
+}
+//#endregion
+//#region src/core/cursor.ts
+function isBound(value) {
+	return typeof value === "object" && value !== null && "s" in value && typeof value.s === "string" && "v" in value && Array.isArray(value.v);
+}
+function parse(cursor) {
+	try {
+		return JSON.parse(base64ToText(cursor));
+	} catch {
+		return;
+	}
+}
+/** Opaque, URL-safe keyset cursor. */
+function encodeCursor(values) {
+	return toBase64Url(JSON.stringify(values));
+}
+/** The values of a cursor from `encodeCursor` or from `paginate()`. */
+function decodeCursor(cursor) {
+	const parsed = parse(cursor);
+	if (isList(parsed)) return [...parsed];
+	return isBound(parsed) ? parsed.v : void 0;
+}
+/** A short FNV-1a hash of `text`, enough to tell two sorts apart. */
+function sortKey(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index += 1) {
+		hash ^= text.codePointAt(index) ?? 0;
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+/** A `paginate()` cursor that only continues the sort `key` names. */
+function encodeBoundCursor(values, key) {
+	return toBase64Url(JSON.stringify({
+		s: key,
+		v: values
+	}));
+}
+/**
+* The values of a `paginate()` cursor made for the sort `key`. `sort` means the
+* cursor is valid but continues another sort or table.
+*/
+function decodeBoundCursor(cursor, key) {
+	const parsed = parse(cursor);
+	if (!isBound(parsed)) return { invalid: "cursor" };
+	return parsed.s === key ? { values: parsed.v } : { invalid: "sort" };
+}
+//#endregion
+//#region src/core/keyset.ts
+/**
+* The rows after the cursor `values` in `orderBy` order, as an OR of ANDs: `a >
+* x or (a = x and b > y)`. The SQL compiler sends that shape as the row
+* comparison `(a, b) > (x, y)`. Nulls sort where Postgres puts them: last for
+* `asc`, first for `desc`, unless the term says otherwise.
+*/
+function keysetCondition(orderBy, values, nullable) {
+	const isNull = (name) => column(name, "is", null);
+	const branches = orderBy.flatMap((term, index) => {
+		const value = values[index];
+		const nullsFirst = (term.nulls ?? (term.direction === "desc" ? "first" : "last")) === "first";
+		const after = column(term.column, term.direction === "asc" ? "gt" : "lt", value);
+		const step = value === null ? nullsFirst ? not(isNull(term.column)) : void 0 : nullsFirst || !nullable(term.column) ? after : or(after, isNull(term.column));
+		if (!step) return [];
+		const equal = orderBy.slice(0, index).map((prev, prevIndex) => values[prevIndex] === null ? isNull(prev.column) : column(prev.column, "eq", values[prevIndex]));
+		return [and(...equal, step) ?? step];
+	});
+	if (branches.length === 0) return column(orderBy[0]?.column ?? "", "in", []);
+	const after = or(...branches);
+	const [first] = orderBy;
+	if (orderBy.length < 2 || !first || values[0] === null || nullable(first.column)) return after;
+	const bound = column(first.column, first.direction === "asc" ? "gte" : "lte", values[0]);
+	return and(bound, after) ?? after;
+}
+//#endregion
+//#region src/core/paginate.ts
+/**
+* The page size and row offset of a list call, or the reason its arguments are
+* invalid.
+*/
+function pageWindow(args) {
+	if (args["offset"] !== void 0 || args["limit"] !== void 0) {
+		if (args["page"] !== void 0 || args["size"] !== void 0) return { invalid: "Pass \"offset\" and \"limit\" or \"page\" and \"size\"" };
+		const limit = Number(args["limit"]);
+		if (!Number.isInteger(limit) || limit < 1) return { invalid: "\"limit\" must be a positive integer" };
+		const offset = Number(args["offset"]);
+		if (!Number.isInteger(offset) || offset < 0) return { invalid: "\"offset\" must be a non-negative integer" };
+		return {
+			size: limit,
+			offset
+		};
+	}
+	const size = Number(args["size"]);
+	if (!Number.isInteger(size) || size < 1) return { invalid: "\"size\" must be a positive integer" };
+	const number = args["page"] === void 0 ? 1 : Number(args["page"]);
+	if (!Number.isInteger(number) || number < 1) return { invalid: "\"page\" must be a positive integer" };
+	return {
+		size,
+		offset: (number - 1) * size
+	};
+}
+/**
+* The `{ items, page }` answer of an offset page from the rows read with one
+* extra row.
+*/
+function offsetEnvelope(rows, total, size, offset) {
+	return {
+		items: rows.slice(0, size),
+		page: {
+			number: Math.floor(offset / size) + 1,
+			size,
+			total,
+			pages: total === null ? null : Math.max(1, Math.ceil(total / size)),
+			hasMore: rows.length > size
+		}
+	};
+}
+/** A copy of the row without the given keys. */
+function strip(row, keys) {
+	const copy = {};
+	for (const key in row) if (!keys.includes(key) && Object.hasOwn(row, key)) copy[key] = row[key];
+	return copy;
+}
+//#endregion
+//#region src/core/row-keys.ts
+/** App-cased primary keys of `rows`, or of a `where` that pins the primary key. */
+function keysOf(op, rows) {
+	const { primaryKey } = op.table;
+	if (primaryKey.length === 0) return;
+	const fromRows = rows.flatMap((row) => primaryKey.every((name) => row[name] !== void 0 && row[name] !== null) ? [Object.fromEntries(primaryKey.map((name) => [name, row[name]]))] : []);
+	if (fromRows.length > 0) return fromRows;
+	if (op.kind === "insert") return;
+	return keysFromWhere(op.table, op.where);
+}
+function keysFromWhere(table, where) {
+	if (!where) return;
+	const { byDb } = lookupOf(table);
+	const pinned = /* @__PURE__ */ new Map();
+	const items = [];
+	const flatten = (condition) => {
+		if (condition.kind === "and") for (const item of condition.items) flatten(item);
+		else items.push(condition);
+	};
+	flatten(where);
+	for (const item of items) {
+		if (item.kind !== "column" || item.path) continue;
+		const app = byDb.get(item.column)?.[0];
+		if (app === void 0 || !table.primaryKey.includes(app)) continue;
+		if (item.op === "eq") pinned.set(app, [item.value]);
+		else if (item.op === "in" && Array.isArray(item.value)) pinned.set(app, item.value);
+	}
+	if (pinned.size !== table.primaryKey.length) return;
+	const [first, ...rest] = table.primaryKey;
+	if (first === void 0) return;
+	if (rest.length === 0) return (pinned.get(first) ?? []).map((value) => ({ [first]: value }));
+	if ([...pinned.values()].some((values) => values.length !== 1)) return;
+	return [Object.fromEntries(table.primaryKey.map((name) => [name, pinned.get(name)?.[0]]))];
+}
+/**
+* Rows in conflict-key order, so concurrent upserts lock the same rows in the
+* same order instead of deadlocking.
+*/
+function byKey(rows, columns) {
+	const compare = (left, right) => {
+		if (left === right) return 0;
+		if (left === null || left === void 0) return 1;
+		if (right === null || right === void 0) return -1;
+		if (typeof left === "number" && typeof right === "number") return left - right;
+		if (typeof left === "bigint" && typeof right === "bigint") return left < right ? -1 : 1;
+		const a = String(left);
+		const b = String(right);
+		return a < b ? -1 : a > b ? 1 : 0;
+	};
+	const keyed = rows.map((row) => ({
+		row,
+		key: columns.map((column) => {
+			const value = row[column];
+			return typeof value === "object" && value !== null ? String(value) : value;
+		})
+	}));
+	keyed.sort((left, right) => {
+		for (let index = 0; index < columns.length; index += 1) {
+			const order = compare(left.key[index], right.key[index]);
+			if (order !== 0) return order;
+		}
+		return 0;
+	});
+	return keyed.map((entry) => entry.row);
+}
+//#endregion
+//#region src/core/runner.ts
+const KNOWN_KEYS = /* @__PURE__ */ new Set([
+	"select",
+	"include",
+	"where",
+	"orderBy",
+	"limit",
+	"offset",
+	"signal",
+	"returning",
+	"expect",
+	"onConflict",
+	"ignoreDuplicates",
+	"page",
+	"size",
+	"count",
+	"after",
+	"mode",
+	"data",
+	"groupBy",
+	"_count",
+	"_sum",
+	"_avg",
+	"_min",
+	"_max",
+	"timeout",
+	"retry",
+	"maxAffected",
+	"defaultToNull"
+]);
+const NO_OPTIONS = Object.freeze({});
+function optionsOf(args) {
+	if (!args) return NO_OPTIONS;
+	let options;
+	for (const key in args) if (!KNOWN_KEYS.has(key) && Object.hasOwn(args, key)) (options ??= {})[key] = args[key];
+	return options ?? NO_OPTIONS;
+}
+const hooksByPlugins = /* @__PURE__ */ new WeakMap();
+function hooksOf(plugins) {
+	let hooks = hooksByPlugins.get(plugins);
+	if (!hooks) {
+		hooks = {
+			transformQuery: plugins.filter((plugin) => plugin.transformQuery),
+			beforeMutation: plugins.filter((plugin) => plugin.beforeMutation),
+			afterMutation: plugins.filter((plugin) => plugin.afterMutation)
+		};
+		hooksByPlugins.set(plugins, hooks);
+	}
+	return hooks;
+}
+function isThenable(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function signalOf(args) {
+	const signal = args?.["signal"];
+	return signal instanceof AbortSignal ? signal : void 0;
+}
+function cloneRows(rows) {
+	return rows.map((row) => cloneValue(row));
+}
+function mutationKind(op) {
+	if (op.kind === "insert") return op.onConflict ? "upsert" : "insert";
+	return op.kind;
+}
+/** Runs operations through plugins, the executor and the event hub. */
+var OperationRunner = class {
+	runtime;
+	#hooks;
+	constructor(runtime) {
+		this.runtime = runtime;
+		this.#hooks = hooksOf(runtime.plugins);
+	}
+	hookArgs(table, options, signal) {
+		return {
+			table,
+			schema: this.runtime.meta,
+			context: this.runtime.context,
+			options,
+			now: this.runtime.now,
+			...signal ? { signal } : {}
+		};
+	}
+	async run(op, options, signal, tuning = NO_TUNING) {
+		const { runtime } = this;
+		const hooks = this.#hooks;
+		if ("invalid" in tuning) return this.fail(op.table, dbError("invalid_request", tuning.invalid));
+		const { timeout, retry } = {
+			...runtime.tuning,
+			...tuning
+		};
+		const invalid = invalidTuning({
+			timeout,
+			retry
+		});
+		if (invalid) return this.fail(op.table, dbError("invalid_request", invalid));
+		let current = op;
+		if (hooks.transformQuery.length > 0 || hooks.beforeMutation.length > 0) {
+			const hook = this.hookArgs(op.table, options, signal);
+			let active = "";
+			try {
+				for (const plugin of hooks.transformQuery) {
+					active = `plugin "${plugin.name}" transformQuery`;
+					current = plugin.transformQuery(current, hook);
+				}
+				if (current.kind !== "select") {
+					let mutation = current;
+					for (const plugin of hooks.beforeMutation) {
+						active = `plugin "${plugin.name}" beforeMutation`;
+						const next = plugin.beforeMutation(mutation, hook);
+						mutation = isThenable(next) ? await next : next;
+					}
+					current = mutation;
+				}
+			} catch (cause) {
+				if (cause instanceof DbException) return this.fail(op.table, cause.error);
+				return this.fail(op.table, {
+					...toDbError(cause),
+					details: `${active} threw`
+				});
+			}
+		}
+		if (current.kind === "update" && Object.keys(current.set).length === 0) return this.fail(op.table, dbError("invalid_request", `The update on "${op.table.key}" sets no columns`));
+		const timed = runtime.events.has("query");
+		const started = timed ? performance.now() : 0;
+		const executed = await this.#execute(current, signal, timeout, retry);
+		const selection = current.kind === "select" ? current.selection : current.returning;
+		let result = executed;
+		if (executed.ok && selection && needsDecoding(selection)) try {
+			result = ok({
+				...executed.data,
+				rows: decodeRows(selection, executed.data.rows, true)
+			});
+		} catch (cause) {
+			if (cause instanceof DbException) return this.fail(op.table, cause.error);
+			throw cause;
+		}
+		const rows = result.ok ? result.data.rows.length : 0;
+		const truncated = current.kind === "select" && current.limit === void 0 && current.single === void 0 && !current.head && rows >= runtime.maxRows;
+		if (truncated && !runtime.truncatedTables.has(op.table.key)) {
+			runtime.truncatedTables.add(op.table.key);
+			runtime.events.logger.warn(`a read on ${op.table.key} returned ${rows} rows, the maxRows cap; add a limit or use paginate()`, {
+				table: op.table.key,
+				maxRows: runtime.maxRows
+			});
+		}
+		if (timed) runtime.events.emit("query", {
+			table: op.table.key,
+			operation: current.kind,
+			ok: result.ok,
+			durationMs: performance.now() - started,
+			rows,
+			truncated
+		});
+		if (!result.ok) return this.fail(op.table, result.error);
+		if (current.kind !== "select") await this.afterMutation(current, result.data);
+		return result;
+	}
+	/**
+	* Runs `op` without plugins or decoding, with the connection's timeout and
+	* retry, and fails on `table`: for reads the library makes itself, such as
+	* the scores of `db.$search({ score: true })`.
+	*/
+	async runInternal(op, table, signal) {
+		const { timeout, retry } = this.runtime.tuning ?? NO_TUNING;
+		const invalid = invalidTuning({
+			timeout,
+			retry
+		});
+		if (invalid) return this.fail(table, dbError("invalid_request", invalid));
+		const executed = await this.#execute(op, signal, timeout, retry);
+		return executed.ok ? executed : this.fail(table, {
+			...executed.error,
+			table: table.key
+		});
+	}
+	async #execute(op, signal, timeout, retry) {
+		const limit = deadline(signal, timeout);
+		const context = {
+			errorMappers: this.runtime.errorMappers,
+			...limit.signal ? { signal: limit.signal } : {},
+			...retry === void 0 ? {} : { retry }
+		};
+		let executed;
+		try {
+			executed = await this.runtime.executor.execute(op, context);
+		} finally {
+			limit.clear();
+		}
+		if (!executed.ok && limit.timedOut()) return err(dbError("timeout", `The request timed out after ${timeout} ms`));
+		return executed;
+	}
+	async afterMutation(op, data) {
+		const { runtime } = this;
+		const plugins = this.#hooks.afterMutation;
+		const listening = runtime.events.has("mutation");
+		if (plugins.length === 0 && !listening) return;
+		const kind = mutationKind(op);
+		const rows = cloneRows(data.rows);
+		const keys = keysOf(op, rows);
+		const { tenant } = runtime.context;
+		const event = {
+			table: op.table,
+			kind,
+			intent: op.intent ?? kind,
+			rows,
+			...keys ? { keys } : {},
+			...tenant === void 0 ? {} : { tenant },
+			context: runtime.context
+		};
+		for (const plugin of plugins) try {
+			const pending = plugin.afterMutation(event);
+			if (isThenable(pending)) await pending;
+		} catch (cause) {
+			runtime.events.logger.error(`plugin "${plugin.name}" afterMutation threw`, { cause });
+		}
+		if (listening) runtime.events.emit("mutation", {
+			table: op.table.key,
+			kind: event.kind,
+			...event.intent ? { intent: event.intent } : {},
+			rows: event.rows,
+			...event.keys ? { keys: event.keys } : {},
+			...event.tenant === void 0 ? {} : { tenant: event.tenant },
+			context: event.context
+		});
+	}
+	fail(table, error) {
+		const withTable = error.table ? error : {
+			...error,
+			table: table.key
+		};
+		if (this.runtime.events.has("error")) this.runtime.events.emit("error", errorEvent(withTable, table.key));
+		return err(withTable);
+	}
+};
+//#endregion
+//#region src/core/write-args.ts
+const COUNT_MODES = /* @__PURE__ */ new Set([
+	"exact",
+	"planned",
+	"estimated"
+]);
+function isCountMode(value) {
+	return COUNT_MODES.has(value);
+}
+/** `maxAffected` from a call, or a message when it isn't a non-negative integer. */
+function maxAffectedOf(args) {
+	const value = args["maxAffected"];
+	if (value === void 0) return {};
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 ? { maxAffected: value } : { invalid: `"maxAffected" must be a non-negative integer, got ${String(value)}` };
+}
+/** The `count` mode a mutation asks for, when it names a valid one. */
+function countOf(args) {
+	const count = args?.["count"];
+	return isCountMode(count) ? { count } : {};
+}
+//#endregion
+//#region src/core/repository.ts
+const sensitiveByTable = /* @__PURE__ */ new WeakMap();
+const primaryOrders = /* @__PURE__ */ new WeakMap();
+const existsSelections = /* @__PURE__ */ new WeakMap();
+/** Database names of the table's `config.sensitive` columns. */
+function sensitiveColumnsOf(table) {
+	let sensitive = sensitiveByTable.get(table);
+	if (!sensitive) {
+		sensitive = new Set(lookupOf(table).entries.filter(([, column]) => column.sensitive).map(([, column]) => column.db));
+		sensitiveByTable.set(table, sensitive);
+	}
+	return sensitive;
+}
+/** Creates the runtime repository object for one table. */
+function createRepository(runner, table) {
+	const { builder } = runner.runtime;
+	const sensitiveDb = sensitiveColumnsOf(table);
+	const mutationHooks = runner.runtime.plugins.some((plugin) => plugin.beforeMutation);
+	const selection = (args) => builder.selection(table, args?.["select"], args?.["include"]);
+	const rowCount = (args, name) => {
+		const value = args?.[name];
+		if (value === void 0) return;
+		if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) invalidRequest(`"${name}" must be a non-negative integer, not ${String(value)}`, table.key);
+		return value;
+	};
+	const selectOp = (args, patch = {}) => ({
+		kind: "select",
+		table,
+		selection: selection(args),
+		where: builder.where(table, args?.["where"]),
+		orderBy: builder.orderBy(table, args?.["orderBy"]),
+		limit: rowCount(args, "limit"),
+		offset: rowCount(args, "offset"),
+		count: void 0,
+		head: false,
+		single: void 0,
+		...patch
+	});
+	/**
+	* Writes return every column but the sensitive ones unless they are asked
+	* for.
+	*/
+	const returning = (args) => {
+		if (args?.["returning"] === false) return;
+		const all = selection(args);
+		if (args?.["select"] !== void 0 || args?.["sensitive"] === true) return all;
+		const columns = all.columns.filter((entry) => !sensitiveDb.has(entry.column));
+		return columns.length === all.columns.length ? all : {
+			...all,
+			columns
+		};
+	};
+	const run = (op, args) => runner.run(op, optionsOf(args), signalOf(args), tuningOf(args));
+	/** `primaryKey` holds app names; order terms take database names. */
+	const defaultOrder = () => {
+		let order = primaryOrders.get(table);
+		if (!order) {
+			order = table.primaryKey.map((name) => ({
+				column: builder.column(table, name),
+				direction: "asc",
+				implicit: true
+			}));
+			primaryOrders.set(table, order);
+		}
+		return order;
+	};
+	const notFound = () => runner.fail(table, dbError("not_found", `No ${table.key} row matched`));
+	/**
+	* Arguments the builder rejects fail like any other error: with the table and
+	* an `error` event.
+	*/
+	const guarded = (work) => AsyncResult.from(async () => {
+		try {
+			return await work();
+		} catch (cause) {
+			return runner.fail(table, toDbError(cause));
+		}
+	});
+	const base = {
+		$tableName: table.key,
+		$meta: table,
+		findMany(args) {
+			return guarded(async () => {
+				const op = selectOp(args);
+				const ordered = op.orderBy.length > 0 || table.primaryKey.length === 0 ? op : {
+					...op,
+					orderBy: defaultOrder()
+				};
+				const result = await run(ordered, args);
+				return result.ok ? ok(result.data.rows) : result;
+			});
+		},
+		findFirst(args) {
+			return guarded(async () => {
+				const result = await run(selectOp(args, { limit: 1 }), args);
+				return result.ok ? ok(result.data.rows[0] ?? null) : result;
+			});
+		},
+		findOnly(args) {
+			return guarded(async () => {
+				const result = await run(selectOp(args, {
+					limit: 2,
+					unpaged: true
+				}), args);
+				if (!result.ok) return result;
+				if (result.data.rows.length > 1) return runner.fail(table, dbError("multiple_rows", `More than one ${table.key} row matched; findOnly expects at most one`));
+				return ok(result.data.rows[0] ?? null);
+			});
+		},
+		findUnique(args) {
+			return guarded(async () => {
+				const op = selectOp(args, {
+					where: builder.uniqueKey(table, args["where"]),
+					limit: 1
+				});
+				const result = await run(op, args);
+				return result.ok ? ok(result.data.rows[0] ?? null) : result;
+			});
+		},
+		findById(id, args) {
+			return guarded(async () => {
+				const op = selectOp(args, {
+					where: builder.primaryKey(table, id),
+					limit: 1
+				});
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				const row = result.data.rows[0];
+				return row ? ok(row) : notFound();
+			});
+		},
+		count(args) {
+			return guarded(async () => {
+				const mode = args?.["mode"];
+				const op = selectOp({ where: args?.["where"] }, {
+					selection: {
+						columns: [],
+						includes: []
+					},
+					count: mode === "planned" || mode === "estimated" ? mode : "exact",
+					head: true
+				});
+				const result = await run(op, args);
+				return result.ok ? ok(result.data.count ?? 0) : result;
+			});
+		},
+		aggregate(args) {
+			return guarded(async () => {
+				const aggregation = builder.aggregation(table, args);
+				const orderBy = builder.aggregateOrderBy(table, args["orderBy"], aggregation);
+				const op = selectOp({
+					where: args["where"],
+					limit: args["limit"],
+					offset: args["offset"]
+				}, {
+					selection: aggregation,
+					orderBy
+				});
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				if (args["groupBy"] !== void 0) return ok(result.data.rows);
+				return ok(result.data.rows[0] ?? decodeRows(aggregation, [{}])[0] ?? {});
+			});
+		},
+		exists(args) {
+			return guarded(async () => {
+				const op = selectOp({ where: args?.["where"] }, {
+					selection: existsSelection(),
+					limit: 1
+				});
+				const result = await run(op, args);
+				return result.ok ? ok(result.data.rows.length > 0) : result;
+			});
+		},
+		paginate(args) {
+			return guarded(async () => "after" in args ? cursorPage(args) : offsetPage(args));
+		},
+		create(data, args) {
+			return guarded(async () => {
+				const op = insertOp([data], args, void 0);
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				return ok(args?.["returning"] === false ? null : result.data.rows[0] ?? null);
+			});
+		},
+		createMany(rows, args) {
+			return guarded(async () => {
+				if (rows.length === 0) return ok(args?.["returning"] === false ? { count: 0 } : []);
+				const result = await run(insertOp(rows, args, void 0), args);
+				if (!result.ok) return result;
+				return ok(args?.["returning"] === false ? { count: result.data.count ?? rows.length } : result.data.rows);
+			});
+		},
+		update(id, patch, args) {
+			return guarded(async () => {
+				const key = and(builder.primaryKey(table, id), builder.where(table, args?.["where"]));
+				const expect = args?.["expect"] ? builder.where(table, args["expect"]) : void 0;
+				const set = builder.row(table, patch, "update");
+				const empty = !mutationHooks && Object.keys(set).length === 0;
+				const op = {
+					kind: "update",
+					table,
+					set,
+					where: and(key, expect),
+					returning: returning(args)
+				};
+				const result = empty ? await run(selectOp(args, {
+					where: and(key, expect),
+					selection: op.returning ?? {
+						columns: [],
+						includes: []
+					},
+					limit: 1,
+					orderBy: [],
+					offset: void 0
+				}), args) : await run(op, args);
+				if (!result.ok) return result;
+				if ((op.returning || empty ? result.data.rows.length : result.data.count ?? 0) === 0) {
+					if (!expect) return notFound();
+					const exists = await run(selectOp(void 0, {
+						where: key,
+						selection: {
+							columns: [],
+							includes: []
+						},
+						count: "exact",
+						head: true
+					}), args);
+					if (exists.ok && (exists.data.count ?? 0) > 0) return runner.fail(table, dbError("stale", `The ${table.key} row changed since it was read`));
+					return notFound();
+				}
+				return ok(op.returning ? result.data.rows[0] ?? null : null);
+			});
+		},
+		updateMany(args) {
+			return guarded(async () => {
+				const where = builder.where(table, args["where"]);
+				if (simplify(where) === true && args["allowAll"] !== true) return runner.fail(table, dbError("invalid_request", "updateMany needs a \"where\" that filters rows; pass allowAll: true to update every row"));
+				const rows = args["returning"] === true;
+				const bound = maxAffectedOf(args);
+				if ("invalid" in bound) return runner.fail(table, dbError("invalid_request", bound.invalid));
+				const set = builder.row(table, args["data"], "update");
+				const op = {
+					kind: "update",
+					table,
+					set,
+					where,
+					returning: rows ? returning(args) : void 0,
+					...bound,
+					...countOf(args)
+				};
+				if (!mutationHooks && Object.keys(set).length === 0) {
+					if (!rows) return ok({ count: 0 });
+					const found = await run(selectOp(args, {
+						where,
+						selection: op.returning ?? selection(args)
+					}), args);
+					return found.ok ? ok(found.data.rows) : found;
+				}
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				return ok(rows ? result.data.rows : { count: result.data.count ?? 0 });
+			});
+		},
+		upsert(data, args) {
+			return guarded(async () => {
+				const op = insertOp([data], args, conflictColumns(args?.["onConflict"]));
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				return ok(args?.["returning"] === false ? null : result.data.rows[0] ?? null);
+			});
+		},
+		upsertMany(rows, args) {
+			return guarded(async () => {
+				if (rows.length === 0) return ok(args?.["returning"] === false ? { count: 0 } : []);
+				const op = insertOp(rows, args, conflictColumns(args?.["onConflict"]));
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				return ok(args?.["returning"] === false ? { count: result.data.count ?? rows.length } : result.data.rows);
+			});
+		},
+		delete(id, args) {
+			return guarded(async () => {
+				const op = {
+					kind: "delete",
+					table,
+					where: builder.primaryKey(table, id),
+					returning: builder.selection(table, table.primaryKey, void 0)
+				};
+				const result = await run(op, args);
+				if (!result.ok) return result;
+				return (result.data.count ?? result.data.rows.length) === 0 ? notFound() : ok(void 0);
+			});
+		},
+		deleteMany(args) {
+			return guarded(async () => {
+				const where = builder.where(table, args["where"]);
+				if (!where || simplify(where) === true) return runner.fail(table, dbError("invalid_request", "deleteMany needs a \"where\" that filters rows"));
+				const rows = args["returning"] === true;
+				const bound = maxAffectedOf(args);
+				if ("invalid" in bound) return runner.fail(table, dbError("invalid_request", bound.invalid));
+				const op = {
+					kind: "delete",
+					table,
+					where,
+					returning: rows ? returning(args) : void 0,
+					...bound,
+					...countOf(args)
+				};
+				const result = await runner.run(op, rows ? {
+					...optionsOf(args),
+					returning: true
+				} : optionsOf(args), signalOf(args), tuningOf(args));
+				if (!result.ok) return result;
+				return ok(rows ? result.data.rows : { count: result.data.count ?? 0 });
+			});
+		}
+	};
+	function insertOp(rows, args, conflict) {
+		const built = rows.map((row) => builder.row(table, row));
+		return {
+			kind: "insert",
+			table,
+			rows: conflict && built.length > 1 ? byKey(built, conflict) : built,
+			returning: returning(args),
+			onConflict: conflict ? {
+				columns: conflict,
+				action: args?.["ignoreDuplicates"] === true ? "ignore" : "update"
+			} : void 0,
+			defaultToNull: args?.["defaultToNull"] === true,
+			...countOf(args)
+		};
+	}
+	/**
+	* One column is enough to see a row: the primary key, or the first
+	* non-sensitive column.
+	*/
+	function existsSelection() {
+		let found = existsSelections.get(table);
+		if (!found) {
+			const names = Object.keys(table.columns);
+			const alias = table.primaryKey[0] ?? names.find((name) => !table.columns[name]?.sensitive) ?? names[0];
+			found = {
+				columns: alias === void 0 ? [] : [{
+					alias,
+					column: builder.column(table, alias)
+				}],
+				includes: []
+			};
+			existsSelections.set(table, found);
+		}
+		return found;
+	}
+	function conflictColumns(target) {
+		if (target === void 0 || target === "primaryKey") return table.primaryKey.map((name) => builder.column(table, name));
+		if (typeof target === "string") {
+			const columns = table.uniqueKeys[target];
+			if (!columns) invalidRequest(`Unknown unique key "${target}" on "${table.key}"`, table.key);
+			return columns.map((name) => builder.column(table, name));
+		}
+		if (Array.isArray(target)) return target.map((name) => builder.column(table, String(name)));
+		return invalidRequest(`Invalid onConflict on "${table.key}"`, table.key);
+	}
+	async function offsetPage(args) {
+		const window = pageWindow(args);
+		if ("invalid" in window) return runner.fail(table, dbError("invalid_request", window.invalid));
+		const { size, offset } = window;
+		const count = args["count"] ?? (args["withCount"] === true ? "exact" : void 0);
+		const orderBy = builder.orderBy(table, args["orderBy"]);
+		const op = selectOp(args, {
+			orderBy: orderBy.length > 0 || table.primaryKey.length === 0 ? orderBy : defaultOrder(),
+			limit: size + 1,
+			lookAhead: true,
+			offset,
+			count: count === "exact" || count === "planned" || count === "estimated" ? count : void 0
+		});
+		const result = await run(op, args);
+		if (!result.ok) return result;
+		return ok(offsetEnvelope(result.data.rows, result.data.count, size, offset));
+	}
+	async function cursorPage(args) {
+		const size = Number(args["size"]);
+		if (!Number.isInteger(size) || size < 1) return runner.fail(table, dbError("invalid_request", "\"size\" must be a positive integer"));
+		const requested = builder.orderBy(table, args["orderBy"]);
+		const related = requested.find((term) => term.relation);
+		if (related) return runner.fail(table, dbError("invalid_request", `Cursor pages can't sort by the relation "${related.relation?.name}"; use an offset page`));
+		const orderBy = withTieBreaker(requested);
+		const { selection: withSort, added } = ensureColumns(selection(args), orderBy);
+		const sort = sortKey(`${table.key}|${orderBy.map((term) => `${term.column}.${term.direction}.${term.nulls ?? ""}`).join(",")}`);
+		let after;
+		if (typeof args["after"] === "string") {
+			const decoded = decodeBoundCursor(args["after"], sort);
+			if ("invalid" in decoded && decoded.invalid === "sort") return runner.fail(table, dbError("invalid_request", "The cursor continues another orderBy; pass after: null to start the new order"));
+			const values = "values" in decoded ? decoded.values : void 0;
+			if (!values || values.length !== orderBy.length) return runner.fail(table, dbError("invalid_request", "Invalid cursor"));
+			const { byDb } = lookupOf(table);
+			after = keysetCondition(orderBy, values, (name) => byDb.get(name)?.[1].nullable ?? true);
+		}
+		const op = selectOp(args, {
+			selection: withSort,
+			where: and(builder.where(table, args["where"]), after),
+			orderBy,
+			limit: size + 1,
+			lookAhead: true,
+			offset: void 0,
+			count: args["withCount"] === true && after === void 0 ? "exact" : void 0
+		});
+		const result = await run(op, args);
+		if (!result.ok) return result;
+		let total = result.data.count;
+		if (args["withCount"] === true && after !== void 0) {
+			const counted = await run(selectOp(args, {
+				selection: {
+					columns: [],
+					includes: []
+				},
+				orderBy: [],
+				limit: void 0,
+				offset: void 0,
+				count: "exact",
+				head: true
+			}), args);
+			if (!counted.ok) return counted;
+			total = counted.data.count;
+		}
+		const rows = result.data.rows.slice(0, size);
+		const hasMore = result.data.rows.length > size;
+		const last = rows.at(-1);
+		const aliases = new Map(withSort.columns.map((entry) => [entry.column, entry.alias]));
+		const nextCursor = hasMore && last ? encodeBoundCursor(orderBy.map((term) => encodeValue(last[aliases.get(term.column) ?? term.column])), sort) : null;
+		return ok({
+			items: added.length > 0 ? rows.map((row) => strip(row, added)) : rows,
+			nextCursor,
+			hasMore,
+			...args["withCount"] === true ? { total: total ?? 0 } : {}
+		});
+	}
+	function withTieBreaker(orderBy) {
+		const terms = [...orderBy];
+		for (const name of table.primaryKey) {
+			const column = builder.column(table, name);
+			if (!terms.some((term) => term.column === column)) terms.push({
+				column,
+				direction: terms[0]?.direction ?? "asc"
+			});
+		}
+		return terms;
+	}
+	function ensureColumns(base, orderBy) {
+		const columns = [...base.columns];
+		const selected = new Set(columns.map((entry) => entry.column));
+		const { byDb } = lookupOf(table);
+		const added = [];
+		for (const term of orderBy) {
+			if (selected.has(term.column)) continue;
+			const alias = byDb.get(term.column)?.[0];
+			columns.push(alias === void 0 ? {
+				alias: term.column,
+				column: term.column
+			} : builder.selectColumn(table, alias));
+			selected.add(term.column);
+			added.push(alias ?? term.column);
+		}
+		return {
+			selection: {
+				columns,
+				includes: base.includes
+			},
+			added
+		};
+	}
+	return base;
+}
+//#endregion
+//#region src/core/rpc-result.ts
+const columnsByFunction = /* @__PURE__ */ new WeakMap();
+function columnsOf(meta, fn) {
+	const cached = columnsByFunction.get(fn);
+	if (cached !== void 0) return cached;
+	let columns = null;
+	const { result } = fn;
+	if (result && "table" in result) {
+		const table = meta.tables[result.table];
+		if (table) {
+			columns = /* @__PURE__ */ new Map();
+			for (const [db, [app, column]] of lookupOf(table).byDb) if (app !== db || column.codec) columns.set(db, [app, column.codec]);
+		}
+	} else if (result) columns = new Map(result.columns.map((column) => [column.db, [column.name ?? column.db, column.codec]]));
+	columnsByFunction.set(fn, columns);
+	return columns;
+}
+const selectByFunction = /* @__PURE__ */ new WeakMap();
+/**
+* The columns `$rpc` selects for a function whose result has a codec column,
+* with that column cast to text as repository reads do. Undefined when no
+* result column has a codec, so the call selects everything.
+*/
+function rpcSelect(meta, fn) {
+	if (!fn) return;
+	let select = selectByFunction.get(fn);
+	if (select === void 0) {
+		const { result } = fn;
+		const table = result && "table" in result ? meta.tables[result.table] : void 0;
+		const columns = table ? [...lookupOf(table).byDb].map(([db, [, column]]) => [db, column.codec]) : result && "columns" in result ? result.columns.map((column) => [column.db, column.codec]) : [];
+		select = columns.some(([, codec]) => codec) ? columns.map(([column, codec]) => codec ? {
+			column,
+			cast: "text"
+		} : { column }) : null;
+		selectByFunction.set(fn, select);
+	}
+	return select ?? void 0;
+}
+function decodeRow(columns, row) {
+	if (!isPlainObject(row)) return row;
+	const out = {};
+	for (const key in row) {
+		if (!Object.hasOwn(row, key)) continue;
+		const column = columns.get(key);
+		if (!column) {
+			out[key] = row[key];
+			continue;
+		}
+		const [app, codec] = column;
+		out[app] = codec ? decodeValue(codec, row[key]) : row[key];
+	}
+	return out;
+}
+const overloadMeta = /* @__PURE__ */ new WeakMap();
+/**
+* The signature `$rpc` calls: PostgREST picks an overload by the argument
+* names, so a call matches the overload that has every name it passes and every
+* argument without a default. Undefined when the function is in another schema
+* or when no overload, or more than one, matches.
+*/
+function rpcFunction(meta, name, schema, args) {
+	const fn = meta.functions[name];
+	if (!fn || fn.schema !== schema) return;
+	if (!fn.overloads) return fn;
+	const keys = Object.keys(args).filter((key) => args[key] !== void 0);
+	const matches = fn.overloads.filter((overload) => keys.every((key) => overload.args.some((arg) => arg.name === key)) && overload.args.every((arg) => arg.optional === true || keys.includes(arg.name)));
+	const [match] = matches;
+	if (!match || matches.length > 1) return;
+	let resolved = overloadMeta.get(match);
+	if (!resolved) {
+		resolved = {
+			...match,
+			name: fn.name,
+			schema: fn.schema
+		};
+		overloadMeta.set(match, resolved);
+	}
+	return resolved;
+}
+/**
+* The `$rpc` result in app form: rows of a table or a `returns table (...)`
+* record get the configured casing and codecs, like repository reads. Scalars,
+* json and calls without a known signature come back unchanged.
+*/
+function decodeRpcResult(meta, fn, data) {
+	if (!fn) return data;
+	const columns = columnsOf(meta, fn);
+	if (!columns || columns.size === 0) return data;
+	return Array.isArray(data) ? data.map((row) => decodeRow(columns, row)) : decodeRow(columns, data);
+}
+//#endregion
+//#region src/core/define.ts
+const isStorageApi = (value) => isRecord(value) && typeof value["from"] === "function";
+/**
+* A supabase-js client builds a new storage client on each read of `storage`,
+* so it is read once per connection.
+*/
+const clientStorage = /* @__PURE__ */ new WeakMap();
+function storageOf(source) {
+	if (source.storage) return source.storage;
+	const cached = clientStorage.get(source);
+	if (cached) return cached;
+	const client = source.client;
+	const storage = isRecord(client) ? client["storage"] : void 0;
+	if (isStorageApi(storage)) {
+		clientStorage.set(source, storage);
+		return storage;
+	}
+	throw new TypeError("better-supabase: db.$storage needs a client with storage, or connect(executor, context, { storage })");
+}
+/**
+* The isomorphic definition of your data layer: schema plus plugins. Holds no
+* secrets and no connection; `connect()` binds it to a client per request.
+*/
+var BetterSupabase = class BetterSupabase {
+	schema;
+	plugins;
+	events;
+	options;
+	constructor(schema, plugins = [], options = {}, events = definitionEvents(options)) {
+		const names = /* @__PURE__ */ new Set();
+		for (const plugin of plugins) {
+			if (plugin.apiVersion !== 1) throw new TypeError(`better-supabase: plugin "${plugin.name}" targets plugin API v${String(plugin.apiVersion)}; this version supports v1`);
+			if (names.has(plugin.name)) throw new TypeError(`better-supabase: plugin "${plugin.name}" is already installed`);
+			names.add(plugin.name);
+		}
+		this.schema = schema;
+		this.plugins = orderPlugins(plugins);
+		this.options = options;
+		this.events = events;
+		const { temporal } = options;
+		if (temporal !== void 0) {
+			const previous = providedTemporal();
+			if (previous !== void 0 && previous !== temporal) events.logger.warn("defineSupabase got a different `temporal` namespace than the one already provided; decoded rows, jobs and webhooks in this process now use the newer one. Pass the same namespace to every definition.");
+			provideTemporal(temporal);
+		}
+	}
+	get meta() {
+		return this.schema.meta;
+	}
+	/** The `now` option, else this definition's own `Temporal` clock. */
+	#now() {
+		const { now, temporal } = this.options;
+		if (now) return now;
+		return temporal ? () => temporal.Now.instant() : nowInstant;
+	}
+	/**
+	* The `Temporal` this definition uses: the `temporal` option, else the
+	* global.
+	*/
+	get temporal() {
+		return this.options.temporal ?? optionalTemporal();
+	}
+	/** The schema set by `claims()`; its output types `session.claims`. */
+	get claimsSchema() {
+		return this.options.claims;
+	}
+	/** The schema set by `userMetadata()`; its output types `session.profile`. */
+	get userMetadataSchema() {
+		return this.options.userMetadata;
+	}
+	/**
+	* Returns a new instance whose servers validate verified JWT claims (custom
+	* access token hook output) with `schema`, and whose sessions are typed by
+	* it. A token that fails it resolves to `{ kind: 'invalid', reason: 'claims'
+	* }`.
+	*
+	* ```ts
+	* const betterSupabase = defineSupabase(schema).claims(
+	*   z.object({ tenant_id: z.uuid() }),
+	* );
+	* ```
+	*/
+	claims(schema) {
+		return new BetterSupabase(this.schema, this.plugins, {
+			...this.options,
+			claims: schema
+		}, this.events);
+	}
+	/**
+	* Returns a new instance whose sessions parse `user_metadata` with `schema`
+	* into a typed `session.profile`. Users can change their metadata with
+	* `auth.updateUser()`, so a failure only leaves `profile` undefined (with one
+	* warning), and no authorization code reads it. It is for display only:
+	* roles, memberships, the tenant and entitlements come from the verified
+	* claims, never from `profile`.
+	*
+	* ```ts
+	* const betterSupabase = defineSupabase(schema).userMetadata(
+	*   z.object({ display_name: z.string() }),
+	* );
+	* ```
+	*/
+	userMetadata(schema) {
+		return new BetterSupabase(this.schema, this.plugins, {
+			...this.options,
+			userMetadata: schema
+		}, this.events);
+	}
+	/**
+	* Returns a new instance whose `.orThrow()` throws `mapper(error)` instead of
+	* a `DbException`, and whose results `toBetterResult` maps the same way.
+	* Results themselves keep their `DbError`.
+	*
+	* ```ts
+	* const betterSupabase = defineSupabase(schema).mapError(
+	*   (error) => new AppError(error),
+	* );
+	* ```
+	*/
+	mapError(mapper) {
+		return new BetterSupabase(this.schema, this.plugins, {
+			...this.options,
+			throwAs: mapper
+		}, this.events);
+	}
+	/**
+	* Returns a new instance whose `db.$buckets` has one client per bucket,
+	* connected to `db.$storage` so Storage runs as the same caller.
+	*
+	* ```ts
+	* const betterSupabase = defineSupabase(schema).buckets({ logos, avatars });
+	* betterSupabase.connect(client).$buckets.logos.signedUrl({ ... });
+	* ```
+	*/
+	buckets(registered) {
+		return new BetterSupabase(this.schema, this.plugins, {
+			...this.options,
+			buckets: registered
+		}, this.events);
+	}
+	#specs;
+	#truncatedTables = /* @__PURE__ */ new Set();
+	/** A hub without listeners, for decoding read-set results. */
+	#decodeEvents;
+	/** One getter per table, shared by every db this instance connects. */
+	#tables;
+	#errorMappers = /* @__PURE__ */ new WeakMap();
+	/**
+	* Builds serializable `QuerySpec`s with the same arguments and result types
+	* as the repository: `betterSupabase.spec.customers.findMany({ select: ['id']
+	* })`.
+	*/
+	get spec() {
+		this.#specs ??= createSpecs(this.meta);
+		return this.#specs;
+	}
+	/**
+	* App keys of every table a spec reads; mutations of any of them make it
+	* stale.
+	*/
+	tablesOf(spec) {
+		return specTables(this.meta, spec);
+	}
+	/** Returns a new instance with the plugin appended. */
+	use(plugin) {
+		return new BetterSupabase(this.schema, [...this.plugins, plugin], this.options, this.events);
+	}
+	/**
+	* Declares the tables an RPC writes, so cache adapters and live queries
+	* invalidate them after it succeeds.
+	*
+	* ```ts
+	* betterSupabase.defineRpc("archive_customer", {
+	*   invalidates: ["customers", "notes"],
+	* });
+	* ```
+	*/
+	defineRpc(name, options) {
+		for (const table of options.invalidates) if (!this.meta.tables[table]) throw new TypeError(`better-supabase: defineRpc("${name}") invalidates unknown table "${table}"`);
+		return new BetterSupabase(this.schema, this.plugins, {
+			...this.options,
+			rpc: {
+				...this.options.rpc,
+				[name]: options
+			}
+		}, this.events);
+	}
+	/** Observes queries, mutations, errors, auth and refreshes. */
+	on(name, handler) {
+		return this.events.on(name, handler);
+	}
+	/**
+	* Invalidates `adapter` after every mutation in this runtime. Returns a
+	* function that detaches it. Adapter failures are logged, never thrown.
+	*/
+	cache(adapter) {
+		const report = (cause, table) => {
+			this.events.logger.error(`cache adapter "${adapter.name}" failed`, {
+				cause,
+				table
+			});
+		};
+		const invalidate = (target) => {
+			try {
+				const pending = adapter.invalidate(target);
+				if (pending) pending.catch((cause) => {
+					report(cause, target.table);
+				});
+			} catch (cause) {
+				report(cause, target.table);
+			}
+		};
+		const offMutation = this.on("mutation", (notice) => {
+			invalidate(cacheTargetOf(this.meta, notice));
+		});
+		const offRpc = this.on("rpc", (notice) => {
+			for (const target of rpcCacheTargets(this.meta, notice)) invalidate(target);
+		});
+		return () => {
+			offMutation();
+			offRpc();
+		};
+	}
+	connect(source, context = {}, options = {}) {
+		const client = isExecutor(source) ? void 0 : source;
+		const base = options.executor ?? (isExecutor(source) ? source : postgrestExecutor(source, this.executorOptions()));
+		const recorder = new StatsRecorder(options.stats);
+		const tuning = {
+			...options.timeout === void 0 ? {} : { timeout: options.timeout },
+			...options.retry === void 0 ? {} : { retry: options.retry }
+		};
+		return this.#db({
+			client,
+			storage: options.storage
+		}, base, context, this.plugins, recorder, tuning);
+	}
+	/**
+	* The `postgrestExecutor` options this definition implies (`urlLengthLimit`,
+	* `postgrestVersion`), for adapters that build their own executor and should
+	* chunk reads the same way.
+	*/
+	executorOptions() {
+		const { urlLengthLimit, postgrestVersion } = this.options;
+		return {
+			...urlLengthLimit === void 0 ? {} : { urlLengthLimit },
+			...postgrestVersion === void 0 ? {} : { postgrestVersion }
+		};
+	}
+	/** The caller's context with every plugin's `context` hook applied. */
+	#derive(given, plugins) {
+		let context = given;
+		for (const plugin of plugins) {
+			if (!plugin.context) continue;
+			try {
+				context = plugin.context(context, { schema: this.meta });
+			} catch (cause) {
+				this.events.logger.error(`plugin "${plugin.name}" context threw`, { cause });
+			}
+		}
+		return context;
+	}
+	#db(source, base, given, plugins, recorder, tuning = {}, events = this.events) {
+		const context = this.#derive(given, plugins);
+		let executor = base;
+		for (const plugin of plugins) if (plugin.wrapExecutor) executor = plugin.wrapExecutor(executor);
+		const wrapped = executor;
+		executor = recordStats(executor, recorder);
+		const errorMappers = this.#errorMappersFor(plugins);
+		const runner = new OperationRunner({
+			meta: this.meta,
+			builder: builderFor(this.meta),
+			executor,
+			plugins,
+			context,
+			events,
+			errorMappers,
+			now: this.#now(),
+			maxRows: this.options.maxRows ?? 1e3,
+			truncatedTables: this.#truncatedTables,
+			tuning
+		});
+		const db = Object.create(this.#tablePrototype());
+		dbStates.set(db, {
+			runner,
+			plugins,
+			repositories: /* @__PURE__ */ new Map()
+		});
+		const { client } = source;
+		Object.defineProperty(db, "$storage", {
+			get: () => storageOf(source),
+			configurable: true
+		});
+		const { buckets } = this.options;
+		if (buckets) {
+			let connected;
+			Object.defineProperty(db, "$buckets", {
+				get: () => {
+					connected ??= Object.fromEntries(Object.entries(buckets).map(([name, bucket]) => [name, bucket.connect(storageOf(source))]));
+					return connected;
+				},
+				configurable: true
+			});
+		}
+		Object.assign(db, {
+			$client: client,
+			$executor: executor,
+			$context: context,
+			$rpc: (name, ...rest) => rpc(this.schema.meta, executor, errorMappers, tuning, name, rest).map((data) => {
+				const registered = this.options.rpc?.[name];
+				if (registered) this.events.emit("rpc", {
+					name,
+					invalidates: registered.invalidates,
+					context
+				});
+				return data;
+			}).mapError((error) => {
+				if (events.has("error")) events.emit("error", errorEvent(error));
+				return error;
+			}),
+			$with: (extra) => this.#db(source, base, {
+				...given,
+				...extra
+			}, plugins, recorder, tuning),
+			$withoutPlugins: (options) => this.#db(source, base, given, keptPlugins(plugins, options?.keep ?? []), recorder, tuning),
+			$stats: () => recorder.snapshot(),
+			$table: (name) => {
+				if (!Object.hasOwn(this.meta.tables, name)) throw new TypeError(`better-supabase: unknown table "${name}". Known: ${Object.keys(this.meta.tables).join(", ")}`);
+				return db[name];
+			},
+			$run: (spec, options) => runSpec(db, spec, options?.signal),
+			$many: (target, ...rest) => {
+				if (isReadSet(target)) {
+					const [values, options] = rest;
+					return readSet(target, values, options?.signal);
+				}
+				const [options] = rest;
+				if (!Array.isArray(target)) return AsyncResult.err(dbError("invalid_request", "db.$many() expects an array of specs or a read set"));
+				return many(target, options?.signal, true);
+			},
+			$search: (name, args) => searchTable(runner, base, this.meta, name, args)
+		});
+		const many = (specs, signal, usePlugins) => AsyncResult.from(async () => {
+			const invalid = specs.findIndex((spec) => !isQuerySpec(spec));
+			if (invalid !== -1) return err(dbError("invalid_request", `db.$many() entry ${invalid} is not a QuerySpec from betterSupabase.spec`));
+			const active = usePlugins ? plugins : [];
+			const batchSource = usePlugins ? wrapped : base;
+			const batch = batchSource.batch?.bind(batchSource);
+			const batching = batch && specs.length > 1 ? batchingExecutor({
+				...base,
+				batch
+			}, specs.length) : void 0;
+			const target = batching ? this.#db(source, batching.executor, given, active, recorder, tuning) : usePlugins ? db : this.#db(source, base, given, NO_PLUGINS, recorder, tuning);
+			const results = await Promise.all(specs.map(async (spec) => {
+				try {
+					return await runSpec(target, spec, signal);
+				} finally {
+					batching?.done();
+				}
+			}));
+			const data = [];
+			for (const result of results) {
+				if (!result.ok) return result;
+				data.push(result.data);
+			}
+			return ok(data);
+		});
+		const readSet = (set, values, signal) => AsyncResult.from(async () => {
+			const problems = checkParams(set, values);
+			if (problems.length > 0) return err(dbError("invalid_request", `db.$many(${set.name}): ${problems.join(", ")}`));
+			const keys = Object.keys(set.specs);
+			const { specs: bound, noCaller } = bindParams(set, values, context);
+			if (base.batch || !executor.rpc) {
+				if (noCaller) return err(noCaller);
+				const result = await many(keys.map((key) => bound[key]), signal, false);
+				if (!result.ok) return result;
+				return ok(Object.fromEntries(keys.map((key, i) => [key, result.data[i]])));
+			}
+			const called = await executor.rpc(set.functionName, { p: values ?? {} }, {
+				schema: "public",
+				get: true,
+				errorMappers,
+				...signal ? { signal } : {}
+			});
+			if (!called.ok) return called;
+			return this.#decodeReadSet(source, context, set, bound, called.data);
+		});
+		const throwAs = this.options.throwAs;
+		if (throwAs) for (const name of [
+			"$rpc",
+			"$run",
+			"$many",
+			"$search"
+		]) db[name] = mapThrows(db[name], throwAs);
+		return db;
+	}
+	/**
+	* Decodes what a read-set function returned (`{ [key]: { rows, count } }`) by
+	* running each spec against those rows, so casing, codecs and aggregates come
+	* out exactly as from `db.$run`.
+	*/
+	async #decodeReadSet(source, context, set, specs, data) {
+		const payload = data ?? {};
+		let rows = [];
+		let count = null;
+		const decoder = this.#db(source, {
+			name: "read-set",
+			execute: (op) => {
+				if (op.kind === "select" && op.single) {
+					if (rows.length > 1) return Promise.resolve(err(dbError("multiple_rows", `Expected one ${op.table.key} row`)));
+					if (rows.length === 0 && op.single === "one") return Promise.resolve(err(dbError("not_found", `No ${op.table.key} row matched`)));
+				}
+				return Promise.resolve(ok({
+					rows,
+					count
+				}));
+			}
+		}, context, NO_PLUGINS, new StatsRecorder(), {}, this.#decodeEvents ??= new EventHub(this.events.logger, this.events.now));
+		const out = {};
+		for (const [key, spec] of Object.entries(specs)) {
+			const entry = payload[key];
+			if (!entry) return err(dbError("unexpected", `${set.functionName}() returned no "${key}". Run \`better-supabase gen\` and migrate.`));
+			rows = entry.rows ?? [];
+			count = entry.count ?? null;
+			const result = await runSpec(decoder, spec, void 0);
+			if (!result.ok) return result;
+			out[key] = result.data;
+		}
+		return ok(out);
+	}
+	#errorMappersFor(plugins) {
+		let mappers = this.#errorMappers.get(plugins);
+		if (!mappers) {
+			mappers = [...this.options.errors ?? [], ...plugins.flatMap((plugin) => plugin.mapError ? [plugin.mapError] : [])];
+			this.#errorMappers.set(plugins, mappers);
+		}
+		return mappers;
+	}
+	#tablePrototype() {
+		if (this.#tables) return this.#tables;
+		const tables = {};
+		const throwAs = this.options.throwAs;
+		const build = (state, key) => {
+			let repository = state.repositories.get(key);
+			if (repository) return repository;
+			const table = this.meta.tables[key];
+			repository = this.#repository(state.runner, key, table, state.plugins);
+			if (throwAs) {
+				for (const [name, method] of Object.entries(repository)) if (typeof method === "function" && name !== "extend") repository[name] = mapThrows(method, throwAs);
+			}
+			state.repositories.set(key, repository);
+			return repository;
+		};
+		for (const key of Object.keys(this.meta.tables)) Object.defineProperty(tables, key, {
+			enumerable: true,
+			get() {
+				const state = dbStates.get(this);
+				return state ? build(state, key) : void 0;
+			}
+		});
+		this.#tables = tables;
+		return tables;
+	}
+	#repository(runner, key, table, plugins) {
+		const repository = createRepository(runner, table);
+		for (const plugin of plugins) {
+			const methods = plugin.repository?.({
+				table,
+				base: repository
+			});
+			if (!methods) continue;
+			for (const [name, method] of Object.entries(methods)) {
+				if (name in repository) throw new TypeError(`better-supabase: plugin "${plugin.name}" redefines "${key}.${name}"`);
+				repository[name] = method;
+			}
+		}
+		repository["extend"] = (build) => ({
+			...repository,
+			...build(repository)
+		});
+		return repository;
+	}
+};
+const dbStates = /* @__PURE__ */ new WeakMap();
+function mapThrows(method, throwAs) {
+	return function mapped(...args) {
+		const value = method.apply(this, args);
+		return value instanceof AsyncResult ? withErrorMapper(value, throwAs) : value;
+	};
+}
+function runSpec(db, spec, signal) {
+	if (!isQuerySpec(spec)) return AsyncResult.err(dbError("invalid_request", "db.$run() expects a QuerySpec from betterSupabase.spec"));
+	const method = db[spec.table]?.[spec.method];
+	if (!method) return AsyncResult.err(dbError("invalid_request", `Unknown table "${spec.table}" in QuerySpec`));
+	if (containsPlaceholder(spec.args)) return AsyncResult.err(dbError("invalid_request", "This spec comes from a read set and still holds placeholders; run it with db.$many(readSet, params)"));
+	const args = [...spec.args];
+	if (signal) {
+		const index = spec.method === "findById" ? 1 : 0;
+		args[index] = {
+			...args[index],
+			signal
+		};
+	}
+	return method(...args);
+}
+function rpc(meta, executor, errorMappers, defaults, name, rest) {
+	const [given, options] = rest;
+	const args = given === void 0 ? void 0 : Object.fromEntries(Object.entries(given).filter(([, value]) => value !== void 0));
+	return AsyncResult.from(async () => {
+		if (!executor.rpc) return err(dbError("unsupported", `Executor "${executor.name}" does not support rpc()`));
+		const tuning = {
+			...defaults,
+			...options?.timeout === void 0 ? {} : { timeout: options.timeout },
+			...options?.retry === void 0 ? {} : { retry: options.retry }
+		};
+		const invalid = invalidTuning(tuning);
+		if (invalid) return err(dbError("invalid_request", invalid));
+		const limit = deadline(options?.signal, tuning.timeout);
+		const schema = options?.schema ?? "public";
+		const fn = rpcFunction(meta, name, schema, args ?? {});
+		const select = options?.raw === true ? void 0 : rpcSelect(meta, fn);
+		const context = {
+			schema,
+			errorMappers,
+			...limit.signal ? { signal: limit.signal } : {},
+			...tuning.retry === void 0 ? {} : { retry: tuning.retry },
+			...fn ? { function: fn } : {},
+			...select ? { select } : {}
+		};
+		let result;
+		try {
+			result = await executor.rpc(name, args ?? {}, context);
+		} finally {
+			limit.clear();
+		}
+		if (!result.ok && limit.timedOut()) return err(dbError("timeout", `The request timed out after ${tuning.timeout} ms`));
+		if (!result.ok) return result;
+		let data = result.data;
+		if (options?.raw !== true) try {
+			data = decodeRpcResult(meta, fn, data);
+		} catch (cause) {
+			if (cause instanceof DbException) return err(cause.error);
+			throw cause;
+		}
+		if (!options?.returns) return ok(data);
+		const checked = await validate(options.returns, data, `${name}() result`);
+		return checked.ok ? ok(checked.data) : checked;
+	});
+}
+/**
+* Creates the data-layer definition from the generated `schema`.
+*
+* ```ts
+* export const betterSupabase = defineSupabase(schema)
+*   .use(timestamps())
+*   .use(softDelete());
+* ```
+*/
+function defineSupabase(schema, options) {
+	return new BetterSupabase(schema, [], options);
+}
+//#endregion
+export { decodeRows as a, rowKey as c, encodeCursor as i, rpcCacheTargets as l, defineSupabase as n, cacheTargetOf as o, decodeCursor as r, memoryCache as s, BetterSupabase as t };