better-supabase 0.8.0 → 0.9.0

package/dist/define-CFQcvM20.js

@@ -1,1949 +0,0 @@
-import { n as deepFreeze, r as isPlainObject, t as cloneValue } from "./clone-dN9XOL1K.js";
-import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError } from "./errors-2M6CKMP4.js";
-import { n as invalidRequest, t as builderFor } from "./build-meLuYGri.js";
-import { t as lookupOf } from "./lookup-BaP5bI27.js";
-import { i as or, n as column, r as not, t as and } from "./types-6cYK9pbJ.js";
-import { c as optionalTemporal, l as provideTemporal, s as nowInstant, u as providedTemporal } from "./temporal-BJGitm-h.js";
-import { i as encodeValue, n as decodeScalar, r as decodeValue } from "./wire-Df3EWkG8.js";
-import { a as ok, c as withErrorMapper, r as err, s as toDbError, t as AsyncResult } from "./result-DEqHCMKP.js";
-import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
-import { t as vectorLiteral } from "./search-CUWCRYKL.js";
-import { t as consoleLogger } from "./logger-glM28NVN.js";
-import { n as isRecord, t as isList } from "./guards-6F2bCtQR.js";
-import { i as orderPlugins } from "./plugin-tfXW1-qO.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-DhU78Ctf.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-DAeWhqPf.js";
-import { a as toBase64Url, t as base64ToText } from "./base64-D2gsioCY.js";
-import { n as validate } from "./standard-DkzZUneg.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 void 0;
-	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) => {
-			items.forEach((item, index) => {
-				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 void 0;
-	const parts = table.primaryKey.map((column) => row[column]);
-	if (parts.some((part) => part === void 0 || part === null)) return void 0;
-	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/events.ts
-/**
-* The `error` event for `error`: a frozen copy, so a handler can't change
-* the `DbError` the caller gets back (invariant 5).
-*/
-function errorEvent(error, table) {
-	const copy = deepFreeze(cloneValue(error));
-	return table === void 0 ? { error: copy } : {
-		table,
-		error: copy
-	};
-}
-/** More handlers than this for one event usually means a missing unsubscribe. */
-const HANDLER_WARNING = 50;
-function isDevelopment() {
-	return typeof process !== "undefined" && process.env["NODE_ENV"] !== "production";
-}
-/**
-* Observers only: a handler that throws is reported to the logger and never
-* changes a result.
-*/
-var EventHub = class {
-	#handlers = /* @__PURE__ */ new Map();
-	#warned = /* @__PURE__ */ new Set();
-	#pending = /* @__PURE__ */ new Set();
-	logger;
-	/** The definition's `now` option; block events take their `time` from it. */
-	now;
-	constructor(logger = consoleLogger, now) {
-		this.logger = logger;
-		this.now = now;
-	}
-	on(name, handler) {
-		let set = this.#handlers.get(name);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.#handlers.set(name, set);
-		}
-		set.add(handler);
-		if (set.size > HANDLER_WARNING && !this.#warned.has(name) && isDevelopment()) {
-			this.#warned.add(name);
-			this.logger.warn(`${set.size} "${name}" handlers are registered; call the function on() returns to remove one you no longer need`);
-		}
-		return () => {
-			set.delete(handler);
-		};
-	}
-	has(name) {
-		return (this.#handlers.get(name)?.size ?? 0) > 0;
-	}
-	/**
-	* Keeps async work a handler started (a sink send) until it settles, so
-	* adapters can hand it to `after()` or `waitUntil`. Its outcome is ignored:
-	* handlers report their own failures.
-	*/
-	track(work) {
-		const settled = Promise.resolve(work).then(() => void 0, () => void 0);
-		this.#pending.add(settled);
-		settled.then(() => this.#pending.delete(settled));
-	}
-	/** Whether tracked work is still running. */
-	get pending() {
-		return this.#pending.size > 0;
-	}
-	/** Resolves once the work tracked so far has settled. Never rejects. */
-	async settled() {
-		await Promise.all(this.#pending);
-	}
-	emit(name, event) {
-		const set = this.#handlers.get(name);
-		if (!set) return;
-		for (const handler of set) try {
-			handler(event);
-		} catch (cause) {
-			this.logger.error(`"${name}" handler threw`, { cause });
-		}
-	}
-};
-//#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++) {
-		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 void 0;
-	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 void 0;
-	return keysFromWhere(op.table, op.where);
-}
-function keysFromWhere(table, where) {
-	if (!where) return void 0;
-	const { byDb } = lookupOf(table);
-	const pinned = /* @__PURE__ */ new Map();
-	const items = [];
-	const flatten = (condition) => {
-		if (condition.kind === "and") condition.items.forEach(flatten);
-		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 void 0;
-	const [first, ...rest] = table.primaryKey;
-	if (first === void 0) return void 0;
-	if (rest.length === 0) return (pinned.get(first) ?? []).map((value) => ({ [first]: value }));
-	if ([...pinned.values()].some((values) => values.length !== 1)) return void 0;
-	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++) {
-			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 selection = (args) => builder.selection(table, args?.["select"], args?.["include"]);
-	const rowCount = (args, name) => {
-		const value = args?.[name];
-		if (value === void 0) return void 0;
-		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 void 0;
-		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 op = {
-					kind: "update",
-					table,
-					set: builder.row(table, patch, "update"),
-					where: and(key, expect),
-					returning: returning(args)
-				};
-				const result = await run(op, args);
-				if (!result.ok) return result;
-				if ((op.returning ? 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 op = {
-					kind: "update",
-					table,
-					set: builder.row(table, args["data"], "update"),
-					where,
-					returning: rows ? returning(args) : void 0,
-					...bound,
-					...countOf(args)
-				};
-				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"];
-		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
-		});
-		const result = await run(op, args);
-		if (!result.ok) return result;
-		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
-		});
-	}
-	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;
-}
-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 void 0;
-	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 void 0;
-	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);
-	}
-	#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);
-		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
-		});
-		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 batch = base.batch?.bind(base);
-			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(...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 [args, options] = rest;
-	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 context = {
-			schema,
-			errorMappers,
-			...limit.signal ? { signal: limit.signal } : {},
-			...tuning.retry === void 0 ? {} : { retry: tuning.retry },
-			...fn ? { function: fn } : {}
-		};
-		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, memoryCache as c, encodeCursor as i, rowKey as l, defineSupabase as n, EventHub as o, decodeCursor as r, cacheTargetOf as s, BetterSupabase as t, rpcCacheTargets as u };