better-supabase 0.7.0 → 0.8.0

package/dist/{define-B-TVjC25.js → define-CFQcvM20.js}

@@ -1,22 +1,22 @@
-import { n as isPlainObject, t as cloneValue } from "./clone-BfgmLU90.js";
+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-B11Duf73.js";
-import { n as invalidRequest, t as builderFor } from "./build-BXIzE6Xv.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-DtZQ4sdE.js";
-import { a as ok, c as withErrorMapper, r as err, s as toDbError, t as AsyncResult } from "./result-DzUbqgdW.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-D_AD9GGu.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-DuKWC9Mj.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 { t as isList } from "./guards-BnzDvFrz.js";
-import { t as vectorLiteral } from "./search-CUWCRYKL.js";
-import { n as validate } from "./standard-BK0cqJ7y.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
@@ -128,14 +128,156 @@ function memoryCache() {
 	};
 }
 //#endregion
-//#region src/core/events.ts
-function deepFreeze(value) {
-	if (Array.isArray(value) || isPlainObject(value)) {
-		for (const item of Object.values(value)) deepFreeze(item);
-		Object.freeze(value);
+//#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);
 	}
-	return value;
+	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).
@@ -161,8 +303,11 @@ var EventHub = class {
 	#warned = /* @__PURE__ */ new Set();
 	#pending = /* @__PURE__ */ new Set();
 	logger;
-	constructor(logger = consoleLogger) {
+	/** 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);
@@ -260,7 +405,7 @@ function logDiagnostics(events) {
 }
 /** 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);
+	const events = new EventHub(options.logger ?? consoleLogger, options.now);
 	if (options.diagnostics === true) logDiagnostics(events);
 	return events;
 }
@@ -431,6 +576,49 @@ function keysetCondition(orderBy, values, nullable) {
 	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) {
@@ -497,28 +685,7 @@ function byKey(rows, columns) {
 	return keyed.map((entry) => entry.row);
 }
 //#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
+//#region src/core/runner.ts
 const KNOWN_KEYS = /* @__PURE__ */ new Set([
 	"select",
 	"include",
@@ -752,6 +919,29 @@ var OperationRunner = class {
 		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();
@@ -1084,32 +1274,10 @@ function createRepository(runner, table) {
 		if (Array.isArray(target)) return target.map((name) => builder.column(table, String(name)));
 		return invalidRequest(`Invalid onConflict on "${table.key}"`, table.key);
 	}
-	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
-		};
-	}
 	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 number = Math.floor(offset / size) + 1;
 		const count = args["count"];
 		const orderBy = builder.orderBy(table, args["orderBy"]);
 		const op = selectOp(args, {
@@ -1121,18 +1289,7 @@ function createRepository(runner, table) {
 		});
 		const result = await run(op, args);
 		if (!result.ok) return result;
-		const rows = result.data.rows;
-		const total = result.data.count;
-		return ok({
-			items: rows.slice(0, size),
-			page: {
-				number,
-				size,
-				total,
-				pages: total === null ? null : Math.max(1, Math.ceil(total / size)),
-				hasMore: rows.length > size
-			}
-		});
+		return ok(offsetEnvelope(result.data.rows, result.data.count, size, offset));
 	}
 	async function cursorPage(args) {
 		const size = Number(args["size"]);
@@ -1209,11 +1366,6 @@ function createRepository(runner, table) {
 	}
 	return base;
 }
-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/rpc-result.ts
 const columnsByFunction = /* @__PURE__ */ new WeakMap();
@@ -1286,28 +1438,20 @@ function decodeRpcResult(meta, fn, data) {
 }
 //#endregion
 //#region src/core/define.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);
+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;
-	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;
+	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
@@ -1490,7 +1634,10 @@ var BetterSupabase = class BetterSupabase {
 			...options.timeout === void 0 ? {} : { timeout: options.timeout },
 			...options.retry === void 0 ? {} : { retry: options.retry }
 		};
-		return this.#db(client, base, context, this.plugins, recorder, tuning);
+		return this.#db({
+			client,
+			storage: options.storage
+		}, base, context, this.plugins, recorder, tuning);
 	}
 	/**
 	* The `postgrestExecutor` options this definition implies
@@ -1517,7 +1664,7 @@ var BetterSupabase = class BetterSupabase {
 		}
 		return context;
 	}
-	#db(client, base, given, plugins, recorder, tuning = {}, events = this.events) {
+	#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);
@@ -1536,91 +1683,17 @@ var BetterSupabase = class BetterSupabase {
 			truncatedTables: this.#truncatedTables,
 			tuning
 		});
-		/**
-		* `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`.
-		*/
-		const scoredSearch = async (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));
-		};
 		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,
@@ -1637,11 +1710,11 @@ var BetterSupabase = class BetterSupabase {
 				if (events.has("error")) events.emit("error", errorEvent(error));
 				return error;
 			}),
-			$with: (extra) => this.#db(client, base, {
+			$with: (extra) => this.#db(source, base, {
 				...given,
 				...extra
 			}, plugins, recorder, tuning),
-			$withoutPlugins: (options) => this.#db(client, base, given, keptPlugins(plugins, options?.keep ?? []), 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(", ")}`);
@@ -1657,46 +1730,7 @@ var BetterSupabase = class BetterSupabase {
 				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) => AsyncResult.from(async () => {
-				const table = Object.hasOwn(this.meta.tables, name) ? this.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(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));
-			})
+			$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));
@@ -1707,7 +1741,7 @@ var BetterSupabase = class BetterSupabase {
 				...base,
 				batch
 			}, specs.length) : void 0;
-			const target = batching ? this.#db(client, batching.executor, given, active, recorder, tuning) : usePlugins ? db : this.#db(client, base, given, NO_PLUGINS, recorder, tuning);
+			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);
@@ -1740,7 +1774,7 @@ var BetterSupabase = class BetterSupabase {
 				...signal ? { signal } : {}
 			});
 			if (!called.ok) return called;
-			return this.#decodeReadSet(client, context, set, bound, called.data);
+			return this.#decodeReadSet(source, context, set, bound, called.data);
 		});
 		const throwAs = this.options.throwAs;
 		if (throwAs) for (const name of [
@@ -1756,11 +1790,11 @@ var BetterSupabase = class BetterSupabase {
 	* by running each spec against those rows, so casing, codecs and
 	* aggregates come out exactly as from `db.$run`.
 	*/
-	async #decodeReadSet(client, context, set, specs, data) {
+	async #decodeReadSet(source, context, set, specs, data) {
 		const payload = data ?? {};
 		let rows = [];
 		let count = null;
-		const decoder = this.#db(client, {
+		const decoder = this.#db(source, {
 			name: "read-set",
 			execute: (op) => {
 				if (op.kind === "select" && op.single) {
@@ -1772,7 +1806,7 @@ var BetterSupabase = class BetterSupabase {
 					count
 				}));
 			}
-		}, context, NO_PLUGINS, new StatsRecorder(), {}, this.#decodeEvents ??= new EventHub(this.events.logger));
+		}, 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];
@@ -1863,7 +1897,7 @@ function runSpec(db, spec, signal) {
 function rpc(meta, executor, errorMappers, defaults, name, rest) {
 	const [args, options] = rest;
 	return AsyncResult.from(async () => {
-		if (!executor.rpc) return err(dbError("invalid_request", `Executor "${executor.name}" does not support rpc()`));
+		if (!executor.rpc) return err(dbError("unsupported", `Executor "${executor.name}" does not support rpc()`));
 		const tuning = {
 			...defaults,
 			...options?.timeout === void 0 ? {} : { timeout: options.timeout },