better-supabase 0.5.1 → 0.6.1

package/dist/vue/index.d.ts

@@ -0,0 +1,141 @@
+import { b as DbError } from "../result-D7y2fT87.js";
+import { it as QuerySpec } from "../define-CJJkkr1-.js";
+import { n as TemplateValues } from "../template-CwO38Do8.js";
+import { t as AuthSnapshot } from "../bind-Bu_ZNa3W.js";
+import { t as AuthSession } from "../view-DbxLNu8L.js";
+import { S as Topic, f as PresenceMember, u as EventSchemas, w as TopicHandlers, x as SubscriptionStatus } from "../index-DunNRdnT.js";
+import { t as SupportView } from "../support-view-33Oi07TT.js";
+import { a as BroadcastOptions, c as LiveCountSource, d as PresenceTopic, f as UseActionOptions, i as ActionState, l as LiveQueryHookOptions, n as ActionInputOf, o as ClientLike, r as ActionResultOf, s as LiveCountHookOptions, t as fieldErrorsOf, u as PresenceHookOptions } from "../field-errors-BFOa7WhB.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { App, ComputedRef, MaybeRefOrGetter, Ref } from "vue";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/vue/index.d.ts
+export interface BetterSupabaseVueOptions {
+  /** better-supabase queries are reset when the user signs out or changes. */
+  readonly queryClient?: QueryClient;
+}
+export interface BetterSupabasePlugin {
+  install(app: App): void;
+}
+/**
+ * The Vue plugin: provides the client to the composables and, with a
+ * `queryClient`, resets better-supabase queries when the caller changes.
+ *
+ * ```ts
+ * app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+ * ```
+ */
+export declare function betterSupabase(client: ClientLike, options?: BetterSupabaseVueOptions): BetterSupabasePlugin;
+/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+export declare function useAuth(): Readonly<Ref<AuthSnapshot>>;
+export declare function useSupabase(): SupabaseClient;
+/**
+ * Shares a server-verified session (from `useAsyncData`, a loader or a
+ * prop) with the components below.
+ */
+export declare function provideSession(session: MaybeRefOrGetter<AuthSession>): void;
+/** The session from the nearest `provideSession()`. */
+export declare function useSession<C = unknown, P = unknown>(): ComputedRef<AuthSession<C, P>>;
+/** The support session the page renders in, or `undefined` for a normal session. */
+export declare function useSupportSession(): ComputedRef<SupportView | undefined>;
+/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
+export type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
+export type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+export interface BetterComposables<B extends ClientLike> {
+  /** Repositories bound to the current session. */
+  readonly useDb: () => B["db"];
+  /** TanStack Query option factories: `useQuery(useQueries().customers.findMany())`. */
+  readonly useQueries: () => B["queries"];
+  readonly useSupabase: () => SupabaseClient;
+  readonly useAuth: () => Readonly<Ref<AuthSnapshot>>;
+  readonly useSession: () => ComputedRef<AuthSession<ClaimsOf<B>, ProfileOf<B>>>;
+}
+/**
+ * Composables typed for your schema.
+ *
+ * ```ts
+ * export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+ * ```
+ */
+export declare function createBindings<B extends ClientLike>(): BetterComposables<B>;
+/**
+ * Subscribes to a topic while the component is mounted. A `null` value
+ * pauses. It resubscribes when the topic values or the signed-in user change.
+ *
+ * ```ts
+ * useBroadcast(customersTopic, () => ({ organizationId: org.value }), {}, { invalidate: ['customers'] });
+ * ```
+ */
+export declare function useBroadcast<P extends string, E extends EventSchemas>(topic: Topic<P, E>, values: MaybeRefOrGetter<TemplateValues<P> | null | undefined>, handlers?: TopicHandlers<E>, options?: BroadcastOptions): Readonly<Ref<SubscriptionStatus>>;
+/**
+ * Keeps a query fresh: invalidates every cached query that read a table the
+ * spec touches whenever one of them changes. A `null` spec pauses.
+ *
+ * ```ts
+ * const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+ * useLiveQuery(spec);
+ * ```
+ */
+export declare function useLiveQuery(spec: MaybeRefOrGetter<QuerySpec | null | undefined>, options?: LiveQueryHookOptions): Readonly<Ref<SubscriptionStatus>>;
+export interface LiveCount {
+  /** `undefined` until the first count arrives. */
+  readonly count: number | undefined;
+  readonly status: SubscriptionStatus;
+  /** The last failed refetch; the previous count stays. */
+  readonly error: DbError | undefined;
+}
+/**
+ * A count that stays current: refetches only the `count` spec after each
+ * debounced change to a table it reads. Takes a spec or a `bs.liveCount()`
+ * seed; `null` pauses. The returned object's fields are reactive.
+ *
+ * ```ts
+ * const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+ * // {{ unread.count }}
+ * ```
+ */
+export declare function useLiveCount(source: MaybeRefOrGetter<LiveCountSource>, options?: LiveCountHookOptions): LiveCount;
+export interface Presence<I, O> {
+  /** Everyone on the topic, this client included, from the last sync. */
+  readonly members: readonly PresenceMember<O>[];
+  readonly status: SubscriptionStatus;
+  /** Shares a state now; the `state` option tracks one for you. */
+  readonly track: (state: I) => Promise<DbError | undefined>;
+  readonly untrack: () => Promise<DbError | undefined>;
+}
+export interface VuePresenceOptions<I> extends Omit<PresenceHookOptions<I>, "state"> {
+  readonly state?: MaybeRefOrGetter<I | null | undefined>;
+}
+/**
+ * Joins a presence topic while mounted and returns who is on it. A `null`
+ * value pauses. The returned object's fields are reactive.
+ *
+ * ```ts
+ * const room = usePresence(roomTopic, () => ({ roomId: id.value }), { state: () => ({ name: name.value }) });
+ * ```
+ */
+export declare function usePresence<P extends string, I, O>(topic: PresenceTopic<P, I, O>, values: MaybeRefOrGetter<TemplateValues<P> | null | undefined>, options?: VuePresenceOptions<I>): Presence<I, O>;
+export interface ActionHandle<I, T> extends ActionState<I, T> {
+  /** Runs the action; resolves with its result. */
+  readonly run: (input: I) => Promise<ActionResultOf<T>>;
+  readonly reset: () => void;
+}
+/**
+ * Calls a server action from an event handler: tracks pending inputs and
+ * the last result, and calls `onSuccess` or `onError`. The returned
+ * object's fields are reactive.
+ *
+ * ```ts
+ * const remove = useAction(removeMember, { onError: (e) => toast.error(e.message) });
+ * // <button :disabled="remove.pending" @click="remove.run({ userId })">
+ * ```
+ */
+export declare function useAction<I, T>(action: (input: I) => Promise<ActionResultOf<T>>, options?: UseActionOptions<ActionInputOf<I>, T>): ActionHandle<ActionInputOf<I>, T>;
+//#endregion
+export { type ActionInputOf, type ActionResultOf, type ActionState, type AuthSession, type AuthSnapshot, type BroadcastOptions, type ClientLike, type LiveCountHookOptions, type LiveCountSource, type LiveQueryHookOptions, type PresenceHookOptions, type PresenceTopic, type SupportView, type UseActionOptions, fieldErrorsOf };

package/dist/vue/index.js

@@ -0,0 +1,362 @@
+import { t as clearOnUserChange } from "../user-change-XzvgafU4.js";
+import { t as supportOf } from "../support-view-g4YLBeqX.js";
+import { t as fieldErrorsOf } from "../field-errors-VF1yb8yI.js";
+import { a as createActionRunner, c as liveKey, d as shownCount, f as startBroadcast, i as countSource, l as notJoined, m as startLiveQuery, n as assertInvalidateClient, o as joinPresence, p as startLiveCount, r as callerOf, s as keyed, t as NO_COUNT, u as plainCaller } from "../client-CI0Z2zWX.js";
+import { computed, getCurrentInstance, getCurrentScope, inject, onMounted, onScopeDispose, provide, readonly, shallowRef, toValue, watch } from "vue";
+//#region src/vue/index.ts
+const CLIENT = Symbol("better-supabase");
+const SESSION = Symbol("better-supabase-session");
+/**
+* The Vue plugin: provides the client to the composables and, with a
+* `queryClient`, resets better-supabase queries when the caller changes.
+*
+* ```ts
+* app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+* ```
+*/
+function betterSupabase(client, options = {}) {
+	return { install(app) {
+		const auth = shallowRef(client.auth.current());
+		const stops = [client.auth.subscribe(() => {
+			auth.value = client.auth.current();
+		})];
+		if (options.queryClient) stops.push(clearOnUserChange(options.queryClient, client.auth));
+		app.onUnmount(() => {
+			for (const stop of stops) stop();
+		});
+		app.provide(CLIENT, {
+			client,
+			queryClient: options.queryClient,
+			auth: readonly(auth)
+		});
+	} };
+}
+function useContext() {
+	const context = inject(CLIENT, null);
+	if (!context) throw new Error("better-supabase: install the plugin with app.use(betterSupabase(bs))");
+	return context;
+}
+/**
+* Runs `start` on mount in a component, at once elsewhere (an effect
+* scope), and never during server rendering.
+*/
+function onClient(start) {
+	if (getCurrentInstance()) onMounted(start);
+	else start();
+}
+/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+function useAuth() {
+	return useContext().auth;
+}
+function useSupabase() {
+	return useContext().client.supabase;
+}
+/**
+* Shares a server-verified session (from `useAsyncData`, a loader or a
+* prop) with the components below.
+*/
+function provideSession(session) {
+	provide(SESSION, session);
+}
+/** The session from the nearest `provideSession()`. */
+function useSession() {
+	const session = inject(SESSION, null);
+	if (session === null) throw new Error("better-supabase: useSession() needs provideSession(session) in a parent component");
+	return computed(() => toValue(session));
+}
+/** The support session the page renders in, or `undefined` for a normal session. */
+function useSupportSession() {
+	const session = useSession();
+	return computed(() => supportOf(session.value));
+}
+/**
+* Composables typed for your schema.
+*
+* ```ts
+* export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+* ```
+*/
+function createBindings() {
+	return {
+		useDb: () => useContext().client.db,
+		useQueries: () => useContext().client.queries,
+		useSupabase,
+		useAuth,
+		useSession
+	};
+}
+/** The caller a subscription runs as: the plugin's auth, or a plain client's. */
+function useCaller(context, client) {
+	if (context && client === void 0) return computed(() => callerOf(context.auth.value));
+	const supabase = client ?? context?.client.supabase;
+	if (!supabase) throw new Error("better-supabase: no supabase client");
+	const store = plainCaller(supabase);
+	const caller = shallowRef(store.current());
+	onClient(() => {
+		const stop = store.subscribe(() => {
+			caller.value = store.current();
+		});
+		onScopeDispose(stop);
+	});
+	return caller;
+}
+function supabaseFor(hook, context, client) {
+	const supabase = client ?? context?.client.supabase;
+	if (!supabase) throw new Error(`better-supabase: ${hook} needs app.use(betterSupabase(bs)) or { client: supabase }`);
+	return supabase;
+}
+/**
+* Subscribes to a topic while the component is mounted. A `null` value
+* pauses. It resubscribes when the topic values or the signed-in user change.
+*
+* ```ts
+* useBroadcast(customersTopic, () => ({ organizationId: org.value }), {}, { invalidate: ['customers'] });
+* ```
+*/
+function useBroadcast(topic, values, handlers, options) {
+	const context = inject(CLIENT, null);
+	const supabase = supabaseFor("useBroadcast", context, options?.client);
+	const queryClient = options?.queryClient ?? context?.queryClient;
+	assertInvalidateClient("useBroadcast", options, queryClient);
+	const caller = useCaller(context, options?.client);
+	const status = shallowRef("closed");
+	const run = keyed();
+	const key = computed(() => {
+		const current = toValue(values);
+		if (!current || caller.value.status === "loading") return null;
+		return JSON.stringify([topic.topic(current), caller.value.userId]);
+	});
+	onClient(() => {
+		watch(key, (next) => {
+			run.update(next, () => {
+				const current = toValue(values);
+				if (!current) return;
+				return startBroadcast({
+					supabase,
+					topic,
+					name: topic.topic(current),
+					latest: () => ({
+						handlers,
+						options
+					}),
+					queryClient,
+					onStatus: (next) => {
+						status.value = next;
+					}
+				});
+			});
+		}, { immediate: true });
+		onScopeDispose(run.stop);
+	});
+	return readonly(status);
+}
+/**
+* Keeps a query fresh: invalidates every cached query that read a table the
+* spec touches whenever one of them changes. A `null` spec pauses.
+*
+* ```ts
+* const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+* useLiveQuery(spec);
+* ```
+*/
+function useLiveQuery(spec, options = {}) {
+	const { client, queryClient, auth } = useContext();
+	const status = shallowRef("closed");
+	const run = keyed();
+	let joined = null;
+	const key = computed(() => {
+		const current = toValue(spec);
+		if (current && !queryClient) throw new Error("better-supabase: useLiveQuery needs betterSupabase(bs, { queryClient })");
+		return liveKey(client, current, auth.value, options);
+	});
+	onClient(() => {
+		watch(key, (next) => {
+			run.update(next, () => {
+				const current = toValue(spec);
+				if (!current || !queryClient || next === null) return;
+				const resumed = joined === next;
+				joined = next;
+				return startLiveQuery({
+					client,
+					queryClient,
+					spec: current,
+					auth: auth.value,
+					options,
+					resumed,
+					onStatus: (value) => {
+						status.value = value;
+					}
+				});
+			});
+		}, { immediate: true });
+		onScopeDispose(run.stop);
+	});
+	return readonly(status);
+}
+/**
+* A count that stays current: refetches only the `count` spec after each
+* debounced change to a table it reads. Takes a spec or a `bs.liveCount()`
+* seed; `null` pauses. The returned object's fields are reactive.
+*
+* ```ts
+* const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+* // {{ unread.count }}
+* ```
+*/
+function useLiveCount(source, options = {}) {
+	const { client, auth } = useContext();
+	const status = shallowRef("closed");
+	const state = shallowRef(NO_COUNT);
+	const run = keyed();
+	let joined = null;
+	const parsed = computed(() => countSource(toValue(source), options));
+	const key = computed(() => liveKey(client, parsed.value.spec, auth.value, options));
+	onClient(() => {
+		watch(key, (next) => {
+			run.update(next, () => {
+				const { spec, initial, seedAt } = parsed.value;
+				if (!spec || next === null) return;
+				const previous = joined?.key === next ? joined : null;
+				joined = {
+					key: next,
+					at: previous?.at ?? seedAt ?? 0
+				};
+				return startLiveCount({
+					client,
+					spec,
+					key: next,
+					auth: auth.value,
+					options,
+					immediate: initial === void 0 && !previous,
+					since: previous ? previous.at : seedAt,
+					onState: (update) => {
+						state.value = update(state.value);
+						if (joined?.key === next) joined = {
+							key: next,
+							at: state.value.at
+						};
+					},
+					onStatus: (value) => {
+						status.value = value;
+					}
+				});
+			});
+		}, { immediate: true });
+		onScopeDispose(run.stop);
+	});
+	const shown = computed(() => shownCount(state.value, key.value, parsed.value));
+	return {
+		get count() {
+			return shown.value.count;
+		},
+		get status() {
+			return status.value;
+		},
+		get error() {
+			return shown.value.error;
+		}
+	};
+}
+const NO_MEMBERS = [];
+/**
+* Joins a presence topic while mounted and returns who is on it. A `null`
+* value pauses. The returned object's fields are reactive.
+*
+* ```ts
+* const room = usePresence(roomTopic, () => ({ roomId: id.value }), { state: () => ({ name: name.value }) });
+* ```
+*/
+function usePresence(topic, values, options = {}) {
+	const context = inject(CLIENT, null);
+	const supabase = supabaseFor("usePresence", context, options.client);
+	const caller = useCaller(context, options.client);
+	const members = shallowRef(NO_MEMBERS);
+	const status = shallowRef("closed");
+	let join;
+	const run = keyed();
+	const key = computed(() => {
+		const current = toValue(values);
+		if (!current || caller.value.status === "loading") return null;
+		return JSON.stringify([topic.topic(current), caller.value.userId]);
+	});
+	onClient(() => {
+		watch(key, (next) => {
+			run.update(next, () => {
+				const current = toValue(values);
+				if (!current) return;
+				const joined = joinPresence(supabase, topic, topic.topic(current), {
+					onStatus: (value) => {
+						status.value = value;
+					},
+					onPresence: (value) => {
+						members.value = value;
+					}
+				});
+				if (!joined) return;
+				join = joined;
+				joined.sync(toValue(options.state));
+				return () => {
+					join = void 0;
+					members.value = NO_MEMBERS;
+					status.value = "closed";
+					joined.leave();
+				};
+			});
+		}, { immediate: true });
+		watch(() => JSON.stringify(toValue(options.state)), () => join?.sync(toValue(options.state)));
+		onScopeDispose(run.stop);
+	});
+	return {
+		get members() {
+			return members.value;
+		},
+		get status() {
+			return status.value;
+		},
+		track: (state) => join?.track(state) ?? notJoined(),
+		untrack: () => join?.untrack() ?? notJoined()
+	};
+}
+/**
+* Calls a server action from an event handler: tracks pending inputs and
+* the last result, and calls `onSuccess` or `onError`. The returned
+* object's fields are reactive.
+*
+* ```ts
+* const remove = useAction(removeMember, { onError: (e) => toast.error(e.message) });
+* // <button :disabled="remove.pending" @click="remove.run({ userId })">
+* ```
+*/
+function useAction(action, options = {}) {
+	const call = action;
+	const runner = createActionRunner(() => ({
+		action: call,
+		options
+	}));
+	const state = shallowRef(runner.current());
+	const stop = runner.subscribe(() => {
+		state.value = runner.current();
+	});
+	if (getCurrentScope()) onScopeDispose(stop);
+	return {
+		run: runner.run,
+		reset: runner.reset,
+		get pending() {
+			return state.value.pending;
+		},
+		get pendingInputs() {
+			return state.value.pendingInputs;
+		},
+		get pendingInput() {
+			return state.value.pendingInput;
+		},
+		get data() {
+			return state.value.data;
+		},
+		get error() {
+			return state.value.error;
+		}
+	};
+}
+//#endregion
+export { betterSupabase, createBindings, fieldErrorsOf, provideSession, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession, useSupabase, useSupportSession };

package/dist/watch-DI34G86j.d.ts

@@ -0,0 +1,60 @@
+import { f as Result } from "./result-D7y2fT87.js";
+import { L as TableKey, P as SchemaMeta, a as AnyModels, i as AnyFunctions } from "./types-6BdhkmZe.js";
+import { t as BetterSupabase } from "./define-CJJkkr1-.js";
+import { i as ListDefinition } from "./list-query-BRt-zDF7.js";
+import { c as SqliteCompilerOptions, p as SqlitePlan, t as PowerSyncDatabaseLike } from "./executor-CaWigTyR.js";
+import { t as Compiler } from "./compiler-DY_wkj4R.js";
+//#region src/powersync/compiler.d.ts
+declare const sqliteCompiler: Compiler<SqlitePlan>;
+/**
+ * Compiles every operation a list definition runs (the page, its count and
+ * the facet counts) for SQLite, without a database. Returns the first
+ * `unsupported` or `invalid_request` error, so a test or a dev build fails
+ * before a native screen does.
+ *
+ * ```ts
+ * expect(await checkSqlite(betterSupabase, customerList)).toEqual({ ok: true, data: undefined });
+ * ```
+ */
+declare function checkSqlite<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>, S extends string, Fa extends string, C extends boolean, P extends "offset" | "cursor">(betterSupabase: BetterSupabase<M, D, F, E>, list: ListDefinition<M, T, E, S, Fa, C, P>, options?: SqliteCompilerOptions): Promise<Result<undefined>>;
+//#endregion
+//#region src/powersync/watch.d.ts
+interface WatchOptions<T> {
+  /** SQLite tables whose changes rerun the query (`sqliteTables()` maps app keys). */
+  readonly tables: readonly string[];
+  /** Called with the first result, then after every change to `tables`. */
+  readonly onResult: (result: Result<T>) => void;
+  readonly signal?: AbortSignal;
+  /** The least time between two runs. Defaults to PowerSync's 30 ms. */
+  readonly throttleMs?: number;
+  /**
+   * Keeps unchanged rows' object identity across runs and skips `onResult`
+   * when a run returns what the last one did. Defaults to true.
+   */
+  readonly structuralSharing?: boolean;
+}
+/**
+ * Reruns a repository call whenever PowerSync reports a change to one of
+ * `tables`: local writes and synced rows alike. The same call works with
+ * lists, aggregates and single rows. Unchanged rows keep their identity
+ * between runs, and a run that changes nothing calls no `onResult`. Returns
+ * a function that stops it.
+ *
+ * ```ts
+ * const stop = watch(powersync, () => customerList.run(db, query), {
+ *   tables: ['customers'],
+ *   onResult: (page) => render(page),
+ * });
+ * ```
+ */
+declare function watch<T>(db: PowerSyncDatabaseLike, query: () => PromiseLike<Result<T>>, options: WatchOptions<T>): () => void;
+/**
+ * The SQLite table names of app table keys (`customerTags` to
+ * `customer_tags`). Pass the executor's `tableName` when it renames tables,
+ * so `watch` listens to the names the queries read.
+ */
+declare function sqliteTables(betterSupabase: {
+  readonly meta: SchemaMeta;
+}, keys: readonly string[], options?: SqliteCompilerOptions): string[];
+//#endregion
+export { sqliteCompiler as a, checkSqlite as i, sqliteTables as n, watch as r, WatchOptions as t };

package/dist/watch-Xuxrvxq-.js

@@ -0,0 +1,122 @@
+import { n as isPlainObject } from "./clone-BfgmLU90.js";
+import { r as err, s as toDbError } from "./result-DzUbqgdW.js";
+//#region src/core/share.ts
+function sameValue(prev, next) {
+	if (Object.is(prev, next)) return true;
+	if (typeof prev !== "object" || typeof next !== "object") return false;
+	if (prev === null || next === null) return false;
+	return Object.getPrototypeOf(prev) === Object.getPrototypeOf(next) && !Array.isArray(prev) && !isPlainObject(prev) && "toJSON" in prev && typeof prev.toJSON === "function" && JSON.stringify(prev) === JSON.stringify(next);
+}
+function idOf(value) {
+	return isPlainObject(value) ? value["id"] : void 0;
+}
+/**
+* `next` with every part that equals `prev` replaced by `prev`'s object, so
+* unchanged rows keep their identity and `memo` skips them. Array items
+* match by their `id` when they have one (a reordered list keeps its rows),
+* else by position. Returns `prev` itself when nothing changed.
+*/
+function shareStructure(prev, next) {
+	if (sameValue(prev, next)) return prev;
+	if (Array.isArray(prev) && Array.isArray(next)) {
+		const before = prev;
+		const after = next;
+		const byId = /* @__PURE__ */ new Map();
+		for (const item of before) {
+			const id = idOf(item);
+			if (id !== void 0) byId.set(id, item);
+		}
+		let same = before.length === after.length;
+		const shared = after.map((item, index) => {
+			const id = idOf(item);
+			const value = shareStructure(id === void 0 ? before[index] : byId.get(id), item);
+			if (value !== before[index]) same = false;
+			return value;
+		});
+		return same ? prev : shared;
+	}
+	if (isPlainObject(prev) && isPlainObject(next)) {
+		const keys = Object.keys(next);
+		let same = keys.length === Object.keys(prev).length;
+		const shared = {};
+		for (const key of keys) {
+			const value = shareStructure(prev[key], next[key]);
+			if (!Object.hasOwn(prev, key) || value !== prev[key]) same = false;
+			shared[key] = value;
+		}
+		return same ? prev : shared;
+	}
+	return next;
+}
+//#endregion
+//#region src/powersync/watch.ts
+/**
+* Reruns a repository call whenever PowerSync reports a change to one of
+* `tables`: local writes and synced rows alike. The same call works with
+* lists, aggregates and single rows. Unchanged rows keep their identity
+* between runs, and a run that changes nothing calls no `onResult`. Returns
+* a function that stops it.
+*
+* ```ts
+* const stop = watch(powersync, () => customerList.run(db, query), {
+*   tables: ['customers'],
+*   onResult: (page) => render(page),
+* });
+* ```
+*/
+function watch(db, query, options) {
+	if (!db.onChange) throw new TypeError("better-supabase: watch() needs a PowerSync database with onChange()");
+	const signal = options.signal;
+	if (signal?.aborted) return () => void 0;
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort();
+	};
+	signal?.addEventListener("abort", stop, { once: true });
+	let latest = 0;
+	let previous;
+	const sharing = options.structuralSharing ?? true;
+	const rerun = async () => {
+		latest += 1;
+		const run = latest;
+		let result;
+		try {
+			result = await query();
+		} catch (cause) {
+			result = err(toDbError(cause));
+		}
+		if (run !== latest || controller.signal.aborted) return;
+		if (sharing) {
+			const shared = shareStructure(previous, result);
+			if (shared === previous) return;
+			result = shared;
+		}
+		previous = result;
+		options.onResult(result);
+	};
+	rerun();
+	const unsubscribe = db.onChange({ onChange: rerun }, {
+		tables: [...options.tables],
+		signal: controller.signal,
+		...options.throttleMs === void 0 ? {} : { throttleMs: options.throttleMs }
+	});
+	return () => {
+		signal?.removeEventListener("abort", stop);
+		stop();
+		unsubscribe();
+	};
+}
+/**
+* The SQLite table names of app table keys (`customerTags` to
+* `customer_tags`). Pass the executor's `tableName` when it renames tables,
+* so `watch` listens to the names the queries read.
+*/
+function sqliteTables(betterSupabase, keys, options = {}) {
+	return keys.map((key) => {
+		const table = betterSupabase.meta.tables[key];
+		if (!table) throw new TypeError(`better-supabase: unknown table "${key}"`);
+		return options.tableName ? options.tableName(table) : table.name;
+	});
+}
+//#endregion
+export { watch as n, sqliteTables as t };