better-supabase 0.3.0 → 0.4.0

package/dist/client/index.d.ts

@@ -1,2 +1,2 @@
-import { a as BrowserOptions, i as BrowserAuth, n as AuthUser, o as createBrowser, r as BetterBrowser, t as AuthSnapshot } from "../index-UJ-LUxtI.js";
-export { AuthSnapshot, AuthUser, BetterBrowser, BrowserAuth, BrowserOptions, createBrowser };
+import { a as ClientOptions, i as ClientAuth, n as AuthUser, o as createClient, r as BetterClient, t as AuthSnapshot } from "../index-RlLXd8dL.js";
+export { AuthSnapshot, AuthUser, BetterClient, ClientAuth, ClientOptions, createClient };

package/dist/client/index.js

@@ -1,8 +1,8 @@
-import { n as decodeJwtPayload } from "../base64-CQeB1eSf.js";
+import { n as decodeJwtPayload } from "../base64-D2gsioCY.js";
 import { EnvValidationError, parseEnv } from "../env/index.js";
-import { t as createQueries } from "../query-BdKLTPlj.js";
+import { t as createQueries } from "../query-BMMSWbI7.js";
 import { createBrowserClient } from "@supabase/ssr";
-import { createClient } from "@supabase/supabase-js";
+import { createClient as createClient$1 } from "@supabase/supabase-js";
 //#region src/client/index.ts
 const LOADING = {
 	status: "loading",
@@ -49,13 +49,13 @@ function contextOf(snapshot) {
 }
 function clientFor(options) {
 	if (options.client) return options.client;
-	if (!options.env) throw new TypeError("createBrowser needs `env` ({ url, publishableKey }) or `client`");
+	if (!options.env) throw new TypeError("createClient needs `env` ({ url, publishableKey }) or `client`");
 	const checked = parseEnv({
 		SUPABASE_URL: options.env.url,
 		SUPABASE_PUBLISHABLE_KEY: options.env.publishableKey
 	});
 	if (!checked.ok) throw new EnvValidationError(checked.issues);
-	if (options.storage === "local") return createClient(checked.env.url, checked.env.publishableKey);
+	if (options.storage === "local") return createClient$1(checked.env.url, checked.env.publishableKey);
 	return createBrowserClient(checked.env.url, checked.env.publishableKey);
 }
 /**
@@ -63,10 +63,10 @@ function clientFor(options) {
 * session, TanStack Query options and an auth store for UI state.
 *
 * ```ts
-* export const browser = createBrowser(sb, { env: { url, publishableKey } });
+* export const bs = createClient(betterSupabase, { env: { url, publishableKey } });
 * ```
 */
-function createBrowser(sb, options = {}) {
+function createClient(betterSupabase, options = {}) {
 	const supabase = clientFor(options);
 	let snapshot = LOADING;
 	let db;
@@ -78,14 +78,14 @@ function createBrowser(sb, options = {}) {
 		db = void 0;
 		for (const listener of listeners) listener();
 	});
-	const browser = {
-		sb,
+	const client = {
+		betterSupabase,
 		supabase,
 		get db() {
-			db ??= sb.connect(supabase, contextOf(snapshot));
+			db ??= betterSupabase.connect(supabase, contextOf(snapshot));
 			return db;
 		},
-		queries: createQueries(sb, () => browser.db),
+		queries: createQueries(betterSupabase, () => client.db),
 		auth: {
 			current: () => snapshot,
 			subscribe: (listener) => {
@@ -96,7 +96,7 @@ function createBrowser(sb, options = {}) {
 			}
 		}
 	};
-	return browser;
+	return client;
 }
 //#endregion
-export { createBrowser };
+export { createClient };

package/dist/{compiler-2zqGzxVZ.d.ts → compiler-DB3aSFOA.d.ts}

@@ -1,5 +1,5 @@
-import { g as Operation } from "./executor-DynmIWhq.js";
-import { i as PostgrestPlan } from "./postgrest-DmBlevh-.js";
+import { g as Operation } from "./executor-B5IoUxLE.js";
+import { i as PostgrestPlan } from "./postgrest-Bc-0Xw62.js";
 //#region src/core/compiler.d.ts
 /**
  * Turns an IR operation into something a backend runs. An `Executor` for a

package/dist/config/index.js

@@ -1,5 +1,5 @@
-import { i as tenantClaimPaths, t as DEFAULT_CLAIMS } from "../claims-CoTobNC-.js";
-import { i as resolveJsonSchema, n as defineConfig, r as resolveConfig, t as CONFIG_SCHEMA_URL } from "../config-Be4GwsqI.js";
-import { n as jsonSchema, t as buildJsonSchema } from "../json-schema--aOXAGfU.js";
-import { n as valibot, t as zod } from "../config-DOsGYSiT.js";
+import { i as tenantClaimPaths, t as DEFAULT_CLAIMS } from "../claims-BAf6c7is.js";
+import { i as resolveJsonSchema, n as defineConfig, r as resolveConfig, t as CONFIG_SCHEMA_URL } from "../config-BpxDfnbg.js";
+import { n as jsonSchema, t as buildJsonSchema } from "../json-schema-DP6V7cbr.js";
+import { n as valibot, t as zod } from "../config-CbvFmGD8.js";
 export { CONFIG_SCHEMA_URL, DEFAULT_CLAIMS, buildJsonSchema, defineConfig, jsonSchema, resolveConfig, resolveJsonSchema, tenantClaimPaths, valibot, zod };

package/dist/{config-Be4GwsqI.js → config-BpxDfnbg.js}

@@ -1,4 +1,4 @@
-import { t as DEFAULT_CLAIMS } from "./claims-CoTobNC-.js";
+import { t as DEFAULT_CLAIMS } from "./claims-BAf6c7is.js";
 //#region src/config/config.ts
 /** The JSON Schema document for a `json[...].schema` entry. */
 function resolveJsonSchema(source) {

package/dist/{config-DOsGYSiT.js → config-CbvFmGD8.js}

@@ -1,4 +1,4 @@
-import { a as parseImport, c as schemaName, d as variantsFor, i as fieldsFor, l as siblingPath, o as propertyKey, r as HEADER, s as rowType, u as tableEntries } from "./json-schema--aOXAGfU.js";
+import { a as parseImport, c as schemaName, d as variantsFor, i as fieldsFor, l as siblingPath, o as propertyKey, r as HEADER, s as rowType, u as tableEntries } from "./json-schema-DP6V7cbr.js";
 //#region src/generators/valibot.ts
 function scalar$1(kind) {
 	switch (kind.kind) {

package/dist/{define-DF341GDj.js → define-Bh0AqTik.js}

@@ -1,15 +1,16 @@
-import { n as dbError, t as DbException } from "./errors-Bl3rkOzo.js";
-import { a as invalidRequest, c as needsDecoding, o as decodeRows, r as IrBuilder, s as encodeValue } from "./simplify-LakqK1vH.js";
+import { n as dbError, t as DbException } from "./errors-L0xK41y_.js";
+import { a as invalidRequest, c as needsDecoding, o as decodeRows, r as builderFor, s as encodeValue } from "./simplify-Cqvfr9dj.js";
+import { t as lookupOf } from "./lookup-BaP5bI27.js";
 import { n as nowInstant } from "./temporal-BwshQk0W.js";
 import { i as or, n as column, r as not, t as and } from "./types-6cYK9pbJ.js";
-import { i as ok, n as err, o as toDbError, s as withErrorMapper, t as AsyncResult } from "./result-DWXatkd6.js";
-import { t as invalidationTargets } from "./tables-Dhha3BXM.js";
+import { i as ok, n as err, o as toDbError, s as withErrorMapper, t as AsyncResult } from "./result-Bj6yt33D.js";
+import { t as invalidationTargets } from "./tables-Cb-3_VWc.js";
 import { t as consoleLogger } from "./logger-glM28NVN.js";
 import { r as orderPlugins } from "./plugin-BqR6wKMB.js";
-import { a as postgrestExecutor, n as StatsRecorder, r as recordStats } from "./stats-D78UQ8Yu.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-D0qBcboM.js";
-import { a as toBase64Url, t as base64ToText } from "./base64-CQeB1eSf.js";
-import { t as validate } from "./standard-FUi3Z3-7.js";
+import { a as postgrestExecutor, n as StatsRecorder, r as recordStats } from "./stats-C_YxA2r1.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-FWK8qQ58.js";
+import { a as toBase64Url, t as base64ToText } from "./base64-D2gsioCY.js";
+import { t as validate } from "./standard-BRyBGTtp.js";
 //#region src/core/batch.ts
 /**
 * Holds operations until each of `readers` has either submitted one or
@@ -95,12 +96,18 @@ function memoryCache() {
 }
 //#endregion
 //#region src/core/events.ts
+/** 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();
 	logger;
 	constructor(logger = consoleLogger) {
 		this.logger = logger;
@@ -112,6 +119,10 @@ var EventHub = class {
 			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);
 		};
@@ -170,11 +181,28 @@ const KNOWN_KEYS = /* @__PURE__ */ new Set([
 	"_min",
 	"_max"
 ]);
+const NO_OPTIONS = Object.freeze({});
 function optionsOf(args) {
-	if (!args) return {};
-	const options = {};
-	for (const [key, value] of Object.entries(args)) if (!KNOWN_KEYS.has(key)) options[key] = value;
-	return options;
+	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"];
@@ -187,8 +215,10 @@ function mutationKind(op) {
 /** 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) {
 		return {
@@ -201,20 +231,27 @@ var OperationRunner = class {
 	}
 	async run(op, options, signal) {
 		const { runtime } = this;
-		const hook = this.hookArgs(op.table, options);
+		const hooks = this.#hooks;
 		let current = op;
-		try {
-			for (const plugin of runtime.plugins) if (plugin.transformQuery) current = plugin.transformQuery(current, hook);
-			if (current.kind !== "select") {
-				let mutation = current;
-				for (const plugin of runtime.plugins) if (plugin.beforeMutation) mutation = await plugin.beforeMutation(mutation, hook);
-				current = mutation;
+		if (hooks.transformQuery.length > 0 || hooks.beforeMutation.length > 0) {
+			const hook = this.hookArgs(op.table, options);
+			try {
+				for (const plugin of hooks.transformQuery) current = plugin.transformQuery(current, hook);
+				if (current.kind !== "select") {
+					let mutation = current;
+					for (const plugin of hooks.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);
+				throw cause;
 			}
-		} catch (cause) {
-			if (cause instanceof DbException) return this.fail(op.table, cause.error);
-			throw cause;
 		}
-		const started = performance.now();
+		const timed = runtime.events.has("query");
+		const started = timed ? performance.now() : 0;
 		const context = signal ? {
 			signal,
 			errorMappers: runtime.errorMappers
@@ -225,7 +262,7 @@ var OperationRunner = class {
 		if (executed.ok && selection && needsDecoding(selection)) try {
 			result = ok({
 				...executed.data,
-				rows: decodeRows(selection, executed.data.rows)
+				rows: decodeRows(selection, executed.data.rows, true)
 			});
 		} catch (cause) {
 			if (cause instanceof DbException) return this.fail(op.table, cause.error);
@@ -240,7 +277,7 @@ var OperationRunner = class {
 				maxRows: runtime.maxRows
 			});
 		}
-		if (runtime.events.has("query")) runtime.events.emit("query", {
+		if (timed) runtime.events.emit("query", {
 			table: op.table.key,
 			operation: current.kind,
 			ok: result.ok,
@@ -254,21 +291,22 @@ var OperationRunner = class {
 	}
 	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 event = {
 			table: op.table,
 			kind: mutationKind(op),
 			rows: data.rows,
 			context: runtime.context
 		};
-		for (const plugin of runtime.plugins) {
-			if (!plugin.afterMutation) continue;
-			try {
-				await plugin.afterMutation(event);
-			} catch (cause) {
-				runtime.events.logger.error(`plugin "${plugin.name}" afterMutation threw`, { cause });
-			}
+		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 });
 		}
-		runtime.events.emit("mutation", {
+		if (listening) runtime.events.emit("mutation", {
 			table: op.table.key,
 			kind: event.kind,
 			rows: event.rows,
@@ -280,7 +318,7 @@ var OperationRunner = class {
 			...error,
 			table: table.key
 		};
-		this.runtime.events.emit("error", {
+		if (this.runtime.events.has("error")) this.runtime.events.emit("error", {
 			table: table.key,
 			error: withTable
 		});
@@ -306,19 +344,22 @@ function createRepository(runner, table) {
 	});
 	const returning = (args) => args?.["returning"] === false ? void 0 : selection(args);
 	const run = (op, args) => runner.run(op, optionsOf(args), signalOf(args));
+	let primaryOrder;
+	/** `primaryKey` holds app names; order terms take database names. */
+	const defaultOrder = () => primaryOrder ??= table.primaryKey.map((name) => ({
+		column: builder.column(table, name),
+		direction: "asc"
+	}));
 	const notFound = () => runner.fail(table, dbError("not_found", `No ${table.key} row matched`));
 	const base = {
-		$table: table.key,
+		$tableName: table.key,
 		$meta: table,
 		findMany(args) {
 			return AsyncResult.from(async () => {
 				const op = selectOp(args);
 				const ordered = op.orderBy.length > 0 || table.primaryKey.length === 0 ? op : {
 					...op,
-					orderBy: table.primaryKey.map((column) => ({
-						column,
-						direction: "asc"
-					}))
+					orderBy: defaultOrder()
 				};
 				const result = await run(ordered, args);
 				return result.ok ? ok(result.data.rows) : result;
@@ -567,7 +608,8 @@ function createRepository(runner, table) {
 		if (typeof args["after"] === "string") {
 			const values = decodeCursor(args["after"]);
 			if (!values || values.length !== orderBy.length) return runner.fail(table, dbError("invalid_request", "Invalid cursor"));
-			after = keysetCondition(orderBy, values, (name) => Object.values(table.columns).find((meta) => meta.db === name)?.nullable ?? true);
+			const { byDb } = lookupOf(table);
+			after = keysetCondition(orderBy, values, (name) => byDb.get(name)?.[1].nullable ?? true);
 		}
 		const op = selectOp(args, {
 			selection: withSort,
@@ -581,7 +623,8 @@ function createRepository(runner, table) {
 		const rows = result.data.rows.slice(0, size);
 		const hasMore = result.data.rows.length > size;
 		const last = rows.at(-1);
-		const nextCursor = hasMore && last ? encodeCursor(orderBy.map((term) => encodeValue(last[aliasOf(withSort, term.column)]))) : null;
+		const aliases = new Map(withSort.columns.map((entry) => [entry.column, entry.alias]));
+		const nextCursor = hasMore && last ? encodeCursor(orderBy.map((term) => encodeValue(last[aliases.get(term.column) ?? term.column]))) : null;
 		return ok({
 			items: added.length > 0 ? rows.map((row) => strip(row, added)) : rows,
 			nextCursor,
@@ -601,14 +644,17 @@ function createRepository(runner, table) {
 	}
 	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 (columns.some((entry) => entry.column === term.column)) continue;
-			const alias = Object.entries(table.columns).find(([, meta]) => meta.db === term.column)?.[0] ?? term.column;
+			if (selected.has(term.column)) continue;
+			const alias = byDb.get(term.column)?.[0] ?? term.column;
 			columns.push({
 				alias,
 				column: term.column
 			});
+			selected.add(term.column);
 			added.push(alias);
 		}
 		return {
@@ -621,12 +667,9 @@ function createRepository(runner, table) {
 	}
 	return base;
 }
-function aliasOf(selection, column) {
-	return selection.columns.find((entry) => entry.column === column)?.alias ?? column;
-}
 function strip(row, keys) {
-	const copy = { ...row };
-	for (const key of keys) delete copy[key];
+	const copy = {};
+	for (const key in row) if (!keys.includes(key) && Object.hasOwn(row, key)) copy[key] = row[key];
 	return copy;
 }
 /**
@@ -644,13 +687,21 @@ function byKey(rows, columns) {
 		const b = String(right);
 		return a < b ? -1 : a > b ? 1 : 0;
 	};
-	return [...rows].sort((left, right) => {
-		for (const column of columns) {
-			const order = compare(left[column], right[column]);
+	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);
 }
 /**
 * The rows after the cursor `values` in `orderBy` order, as an OR of ANDs:
@@ -716,7 +767,7 @@ var BetterSupabase = class BetterSupabase {
 	* A token that fails it resolves to `{ kind: 'invalid', reason: 'claims' }`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).claims(z.object({ tenant_id: z.uuid() }));
+	* const betterSupabase = defineSupabase(schema).claims(z.object({ tenant_id: z.uuid() }));
 	* ```
 	*/
 	claims(schema) {
@@ -734,7 +785,7 @@ var BetterSupabase = class BetterSupabase {
 	* the verified claims, never from `profile`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).userMetadata(z.object({ display_name: z.string() }));
+	* const betterSupabase = defineSupabase(schema).userMetadata(z.object({ display_name: z.string() }));
 	* ```
 	*/
 	userMetadata(schema) {
@@ -749,7 +800,7 @@ var BetterSupabase = class BetterSupabase {
 	* Results themselves keep their `DbError`.
 	*
 	* ```ts
-	* const sb = defineSupabase(schema).mapError((error) => new AppError(error));
+	* const betterSupabase = defineSupabase(schema).mapError((error) => new AppError(error));
 	* ```
 	*/
 	mapError(mapper) {
@@ -760,9 +811,14 @@ var BetterSupabase = class BetterSupabase {
 	}
 	#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: `sb.spec.customers.findMany({ select: ['id'] })`.
+	* as the repository: `betterSupabase.spec.customers.findMany({ select: ['id'] })`.
 	*/
 	get spec() {
 		this.#specs ??= createSpecs(this.meta);
@@ -783,7 +839,7 @@ var BetterSupabase = class BetterSupabase {
 	* invalidate them after it succeeds.
 	*
 	* ```ts
-	* sb.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
+	* betterSupabase.defineRpc('archive_customer', { invalidates: ['customers', 'notes'] });
 	* ```
 	*/
 	defineRpc(name, options) {
@@ -842,10 +898,10 @@ var BetterSupabase = class BetterSupabase {
 		let executor = base;
 		for (const plugin of plugins) if (plugin.wrapExecutor) executor = plugin.wrapExecutor(executor);
 		executor = recordStats(executor, recorder);
-		const errorMappers = [...this.options.errors ?? [], ...plugins.flatMap((plugin) => plugin.mapError ? [plugin.mapError] : [])];
+		const errorMappers = this.#errorMappersFor(plugins);
 		const runner = new OperationRunner({
 			meta: this.meta,
-			builder: new IrBuilder(this.meta),
+			builder: builderFor(this.meta),
 			executor,
 			plugins,
 			context,
@@ -855,7 +911,13 @@ var BetterSupabase = class BetterSupabase {
 			maxRows: this.options.maxRows ?? 1e3,
 			truncatedTables: this.#truncatedTables
 		});
-		const db = {
+		const db = Object.create(this.#tablePrototype());
+		dbStates.set(db, {
+			runner,
+			plugins,
+			repositories: /* @__PURE__ */ new Map()
+		});
+		Object.assign(db, {
 			$client: client,
 			$executor: executor,
 			$context: context,
@@ -923,10 +985,10 @@ var BetterSupabase = class BetterSupabase {
 					hint: `Add "${table.schema}.${table.name}" to vectorSearch in better-supabase.config.ts and run \`better-supabase sql sync\`.`
 				}) : result;
 			})
-		};
+		});
 		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 sb.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({
@@ -974,21 +1036,6 @@ var BetterSupabase = class BetterSupabase {
 			"$many",
 			"$search"
 		]) db[name] = mapThrows(db[name], throwAs);
-		for (const [key, table] of Object.entries(this.meta.tables)) {
-			let repository;
-			Object.defineProperty(db, key, {
-				enumerable: true,
-				get: () => {
-					if (!repository) {
-						repository = this.#repository(runner, key, table, plugins);
-						if (throwAs) {
-							for (const [name, method] of Object.entries(repository)) if (typeof method === "function" && name !== "extend") repository[name] = mapThrows(method, throwAs);
-						}
-					}
-					return repository;
-				}
-			});
-		}
 		return db;
 	}
 	/**
@@ -1015,12 +1062,45 @@ var BetterSupabase = class BetterSupabase {
 						count: entry.count ?? null
 					}));
 				}
-			}, context, [], new StatsRecorder(), new EventHub(this.events.logger)), spec, void 0);
+			}, context, [], new StatsRecorder(), this.#decodeEvents ??= new EventHub(this.events.logger)), 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) {
@@ -1041,6 +1121,7 @@ var BetterSupabase = class BetterSupabase {
 		return repository;
 	}
 };
+const dbStates = /* @__PURE__ */ new WeakMap();
 function mapThrows(method, throwAs) {
 	return function(...args) {
 		const value = method.apply(this, args);
@@ -1048,7 +1129,7 @@ function mapThrows(method, throwAs) {
 	};
 }
 function runSpec(db, spec, signal) {
-	if (!isQuerySpec(spec)) return AsyncResult.err(dbError("invalid_request", "db.$run() expects a QuerySpec from sb.spec"));
+	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)"));
@@ -1081,7 +1162,7 @@ function rpc(executor, errorMappers, name, rest) {
 * Creates the data-layer definition from the generated `schema`.
 *
 * ```ts
-* export const sb = defineSupabase(schema).use(timestamps()).use(softDelete());
+* export const betterSupabase = defineSupabase(schema).use(timestamps()).use(softDelete());
 * ```
 */
 function defineSupabase(schema, options) {