better-supabase 0.11.0 → 0.13.0

package/dist/view-CfUd5vI9.js

@@ -0,0 +1,108 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { a as invalidActorError, i as delegationOf, n as actorOf } from "./actor-C9pwyCVz.js";
+import { r as impersonatorOf } from "./impersonation-DFfDVJHk.js";
+//#region src/auth/mfa.ts
+/**
+* The session's assurance level from its claims; anything but `aal2` reads as
+* `aal1`.
+*/
+function aalOf(claims) {
+	return claims["aal"] === "aal2" ? "aal2" : "aal1";
+}
+/** The `amr` claim as typed entries, skipping malformed ones. */
+function amrOf(claims) {
+	const amr = claims["amr"];
+	if (!Array.isArray(amr)) return [];
+	return amr.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const { method, timestamp, provider } = entry;
+		if (typeof method !== "string" || typeof timestamp !== "number") return [];
+		return [typeof provider === "string" ? {
+			method,
+			timestamp,
+			provider
+		} : {
+			method,
+			timestamp
+		}];
+	});
+}
+/**
+* `undefined` when a user session meets `required`; otherwise a `forbidden`
+* error with `required` and code `INSUFFICIENT_AAL`, for the client to start an
+* MFA challenge. Non-user sessions pass: `allow` decides about them.
+*/
+function checkAal(auth, required) {
+	if (required === "aal1" || auth.kind !== "user" || !("claims" in auth)) return;
+	if (aalOf(auth.claims) === "aal2") return;
+	return dbError("forbidden", "Verify a second factor to continue", {
+		code: "INSUFFICIENT_AAL",
+		required
+	});
+}
+//#endregion
+//#region src/auth/view.ts
+/** Whether the token belongs to an anonymous user (`signInAnonymously()`). */
+function isAnonymousUser(claims) {
+	return "is_anonymous" in claims && claims.is_anonymous === true;
+}
+/** Drops the token from an `AuthState`, leaving only serializable fields. */
+function toSession(auth) {
+	switch (auth.kind) {
+		case "user": {
+			const outcome = actorOf(auth.claims);
+			if (!outcome.ok) return {
+				kind: "invalid",
+				reason: "actor",
+				error: invalidActorError()
+			};
+			const impersonator = impersonatorOf(auth.claims);
+			const actor = outcome.actor;
+			const client = actor?.kind === "oauth-client" || actor?.kind === "agent" && delegationOf(auth.claims) !== void 0 ? actor : void 0;
+			const scopes = client ? delegationOf(auth.claims)?.scopes : void 0;
+			const delegation = client && (scopes || client.chain) ? {
+				scopes: scopes ?? [],
+				...client.chain ? { chain: client.chain } : {}
+			} : void 0;
+			return {
+				kind: "user",
+				user: auth.user,
+				claims: auth.claims,
+				expiresAt: auth.expiresAt,
+				...auth.profile === void 0 ? {} : { profile: auth.profile },
+				aal: aalOf(auth.claims),
+				anonymous: isAnonymousUser(auth.claims),
+				amr: amrOf(auth.claims),
+				...impersonator ? { impersonator } : {},
+				...actor ? { actor } : {},
+				...delegation ? { delegation } : {}
+			};
+		}
+		case "service": return {
+			kind: "service",
+			keyName: auth.keyName
+		};
+		case "apiKey": return {
+			kind: "apiKey",
+			keyId: auth.keyId,
+			name: auth.name,
+			...auth.organizationId ? { organizationId: auth.organizationId } : {},
+			...auth.userId ? { userId: auth.userId } : {},
+			scopes: auth.scopes,
+			...auth.createdAt ? { createdAt: Math.floor(auth.createdAt.epochMilliseconds / 1e3) } : {},
+			...auth.createdBy ? { createdBy: auth.createdBy } : {}
+		};
+		case "anon": return {
+			kind: "anon",
+			reason: auth.reason
+		};
+		case "invalid": return {
+			kind: "invalid",
+			reason: auth.reason,
+			error: auth.error
+		};
+		default: return auth;
+	}
+}
+//#endregion
+export { checkAal as a, amrOf as i, toSession as n, aalOf as r, isAnonymousUser as t };

package/dist/vue/index.d.ts

@@ -1,17 +1,17 @@
-import { b as DbError } from "../result-BREt7qOh.js";
-import { O as TemplateValues } from "../bucket-BBSNDFNH.js";
-import { at as QuerySpec } from "../define-M_r1d2AT.js";
-import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-1WTkDnPd.js";
-import { t as AuthSnapshot } from "../bind-CTNKpBM6.js";
-import { t as AuthSession } from "../view-Bf7e07rQ.js";
-import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-DmJICh93.js";
-import { t as SupportView } from "../support-view-IRnDLuGN.js";
+import { b as DbError } from "../result-mijqfoJN.js";
+import { J as QuerySpec } from "../define-D0LSXmUP.js";
+import { $ as TemplateValues } from "../bucket-DBay-ICp.js";
+import { g as TopicHandlers, m as Topic, p as SubscriptionStatus, r as PresenceMember, t as EventSchemas } from "../topic-CZvLXFND.js";
+import { t as AuthSnapshot } from "../bind-DcXLU1ul.js";
+import { t as AuthSession } from "../view-CKzCp8FW.js";
+import { a as BroadcastOptions, c as LiveCountHookOptions, d as PresenceHookOptions, f as PresenceTopic, i as ActionState, l as LiveCountSource, m as UseActionOptions, n as ActionInputOf, o as ClaimsOf, p as ProfileOf, r as ActionResultOf, s as ClientLike, t as fieldErrorsOf, u as LiveQueryHookOptions } from "../field-errors-CKEqR38q.js";
+import { t as SupportView } from "../support-view-BOJJSZKv.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 import { App, ComputedRef, MaybeRefOrGetter, Ref } from "vue";
 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. */
+  /** Better-supabase queries are reset when the user signs out or changes. */
   readonly queryClient?: QueryClient;
 }
 export interface BetterSupabasePlugin {
@@ -22,16 +22,21 @@ export interface BetterSupabasePlugin {
  * `queryClient`, resets better-supabase queries when the caller changes.
  *
  * ```ts
- * app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+ * 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. */
+/**
+ * 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.
+ * 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()`. */
@@ -41,7 +46,10 @@ export declare function useSupportSession(): ComputedRef<SupportView | undefined
 export interface BetterComposables<B extends ClientLike> {
   /** Repositories bound to the current session. */
   readonly useDb: () => B["db"];
-  /** TanStack Query option factories: `useQuery(useQueries().customers.findMany())`. */
+  /**
+   * TanStack Query option factories:
+   * `useQuery(useQueries().customers.findMany())`.
+   */
   readonly useQueries: () => B["queries"];
   readonly useSupabase: () => SupabaseClient;
   readonly useAuth: () => Readonly<Ref<AuthSnapshot>>;
@@ -51,16 +59,22 @@ export interface BetterComposables<B extends ClientLike> {
  * Composables typed for your schema.
  *
  * ```ts
- * export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+ * 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.
+ * 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'] });
+ * 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>>;
@@ -69,7 +83,11 @@ export declare function useBroadcast<P extends string, E extends EventSchemas>(t
  * spec touches whenever one of them changes. A `null` spec pauses.
  *
  * ```ts
- * const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+ * const spec = computed(() =>
+ *   betterSupabase.spec.customers.findMany({
+ *     where: { orgId: org.value },
+ *   }),
+ * );
  * useLiveQuery(spec);
  * ```
  */
@@ -87,7 +105,9 @@ export interface LiveCount {
  * seed; `null` pauses. The returned object's fields are reactive.
  *
  * ```ts
- * const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+ * const unread = useLiveCount(() =>
+ *   betterSupabase.spec.messages.count({ where: { read: false } }),
+ * );
  * // {{ unread.count }}
  * ```
  */
@@ -104,11 +124,13 @@ export interface VuePresenceOptions<I> extends Omit<PresenceHookOptions<I>, "sta
   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.
+ * 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 }) });
+ * 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>;
@@ -118,12 +140,14 @@ export interface ActionHandle<I, T> extends ActionState<I, 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.
+ * 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) });
+ * const remove = useAction(removeMember, {
+ *   onError: (e) => toast.error(e.message),
+ * });
  * // <button :disabled="remove.pending" @click="remove.run({ userId })">
  * ```
  */

package/dist/vue/index.js

@@ -1,8 +1,8 @@
-import { t as clearOnUserChange } from "../user-change-XzvgafU4.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-CHR8IBNG.js";
+import { t as clearOnUserChange } from "../user-change-CSR_prhd.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-YASsOslj.js";
 import { t as supportOf } from "../support-view-g4YLBeqX.js";
 import { t as fieldErrorsOf } from "../field-errors-DZVRWRkf.js";
-import { n as onClient, r as useContext, t as CLIENT } from "../context-D6ZMKc2L.js";
+import { n as onClient, r as useContext, t as CLIENT } from "../context-CCz6ZgyI.js";
 import { computed, getCurrentScope, inject, onScopeDispose, provide, readonly, shallowRef, toValue, watch } from "vue";
 //#region src/vue/index.ts
 const SESSION = Symbol("better-supabase-session");
@@ -11,7 +11,9 @@ const SESSION = Symbol("better-supabase-session");
 * `queryClient`, resets better-supabase queries when the caller changes.
 *
 * ```ts
-* app.use(VueQueryPlugin, { queryClient }).use(betterSupabase(bs, { queryClient }));
+* app
+*   .use(VueQueryPlugin, { queryClient })
+*   .use(betterSupabase(bs, { queryClient }));
 * ```
 */
 function betterSupabase(client, options = {}) {
@@ -31,7 +33,10 @@ function betterSupabase(client, options = {}) {
 		});
 	} };
 }
-/** The session state for UI: `loading`, `signed-out` or `signed-in` with the user and claims. */
+/**
+* The session state for UI: `loading`, `signed-out` or `signed-in` with the
+* user and claims.
+*/
 function useAuth() {
 	return useContext().auth;
 }
@@ -39,8 +44,8 @@ function useSupabase() {
 	return useContext().client.supabase;
 }
 /**
-* Shares a server-verified session (from `useAsyncData`, a loader or a
-* prop) with the components below.
+* Shares a server-verified session (from `useAsyncData`, a loader or a prop)
+* with the components below.
 */
 function provideSession(session) {
 	provide(SESSION, session);
@@ -60,7 +65,8 @@ function useSupportSession() {
 * Composables typed for your schema.
 *
 * ```ts
-* export const { useDb, useQueries, useAuth } = createBindings<typeof bs>();
+* export const { useDb, useQueries, useAuth } =
+*   createBindings<typeof bs>();
 * ```
 */
 function createBindings() {
@@ -93,11 +99,16 @@ function supabaseFor(hook, context, client) {
 	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.
+* 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'] });
+* useBroadcast(
+*   customersTopic,
+*   () => ({ organizationId: org.value }),
+*   {},
+*   { invalidate: ["customers"] },
+* );
 * ```
 */
 function useBroadcast(topic, values, handlers, options) {
@@ -142,7 +153,11 @@ function useBroadcast(topic, values, handlers, options) {
 * spec touches whenever one of them changes. A `null` spec pauses.
 *
 * ```ts
-* const spec = computed(() => betterSupabase.spec.customers.findMany({ where: { orgId: org.value } }));
+* const spec = computed(() =>
+*   betterSupabase.spec.customers.findMany({
+*     where: { orgId: org.value },
+*   }),
+* );
 * useLiveQuery(spec);
 * ```
 */
@@ -186,7 +201,9 @@ function useLiveQuery(spec, options = {}) {
 * seed; `null` pauses. The returned object's fields are reactive.
 *
 * ```ts
-* const unread = useLiveCount(() => betterSupabase.spec.messages.count({ where: { read: false } }));
+* const unread = useLiveCount(() =>
+*   betterSupabase.spec.messages.count({ where: { read: false } }),
+* );
 * // {{ unread.count }}
 * ```
 */
@@ -246,11 +263,13 @@ function useLiveCount(source, options = {}) {
 }
 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.
+* 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 }) });
+* const room = usePresence(roomTopic, () => ({ roomId: id.value }), {
+*   state: () => ({ name: name.value }),
+* });
 * ```
 */
 function usePresence(topic, values, options = {}) {
@@ -305,12 +324,14 @@ function usePresence(topic, values, options = {}) {
 	};
 }
 /**
-* 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.
+* 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) });
+* const remove = useAction(removeMember, {
+*   onError: (e) => toast.error(e.message),
+* });
 * // <button :disabled="remove.pending" @click="remove.run({ userId })">
 * ```
 */

package/dist/vue-controller-DCOtUOA_.d.ts

@@ -0,0 +1,11 @@
+import { n as Controller } from "./controller-lWRcKqCl.js";
+import { ShallowRef } from "vue";
+//#region src/blocks/vue-controller.d.ts
+/** A block controller in a Vue component: `state` follows the controller. */
+interface VueController<S, A> {
+  readonly state: Readonly<ShallowRef<S>>;
+  readonly actions: A;
+  readonly controller: Controller<S, A>;
+}
+//#endregion
+export { VueController as t };

package/dist/vue-controller-EzyTjqca.js

@@ -0,0 +1,32 @@
+import { n as onClient, r as useContext } from "./context-CCz6ZgyI.js";
+import { n as withEnv, t as blockEnv } from "./block-env-YfPmSNa1.js";
+import { getCurrentScope, onScopeDispose, shallowRef } from "vue";
+//#region src/blocks/vue-controller.ts
+/**
+* Makes a controller once and keeps `state` current. Its work starts on mount
+* (at once in an effect scope, never during server rendering), and the
+* controller is disposed with the component or scope.
+*/
+function useBlockController(create, options, usesEnv = true) {
+	const controller = create(withEnv(options, usesEnv ? () => blockEnv(useContext().client) : void 0));
+	const state = shallowRef(controller.getSnapshot());
+	let unsubscribe;
+	onClient(() => {
+		const sync = () => {
+			state.value = controller.getSnapshot();
+		};
+		unsubscribe = controller.subscribe(sync);
+		sync();
+	});
+	if (getCurrentScope()) onScopeDispose(() => {
+		unsubscribe?.();
+		controller.dispose();
+	});
+	return {
+		state,
+		actions: controller.actions,
+		controller
+	};
+}
+//#endregion
+export { useBlockController as t };

package/dist/watch-CYeMXFtj.d.ts

@@ -0,0 +1,92 @@
+import { b as DbError, f as Result } from "./result-mijqfoJN.js";
+import { B as TableKey, F as SchemaMeta, a as AnyModels, i as AnyFunctions } from "./types-DmshMaXz.js";
+import { t as BetterSupabase } from "./define-D0LSXmUP.js";
+import { i as ListDefinition } from "./list-query-Dx5cAqG6.js";
+import { c as SqliteCompilerOptions, p as SqlitePlan, t as PowerSyncDatabaseLike } from "./executor-D_viYkhf.js";
+import { t as Compiler } from "./compiler-DCotQWcs.js";
+//#region src/powersync/compiler.d.ts
+declare const sqliteCompiler: Compiler<SqlitePlan>;
+interface CheckSqliteOptions extends SqliteCompilerOptions {
+  /**
+   * Return every error instead of the first, one per distinct message. With a
+   * `fallback` executor, these are the reads that run on the server.
+   */
+  readonly all?: boolean;
+}
+/**
+ * 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. With `all: true`, returns every error, an empty array when the
+ * whole list runs on SQLite.
+ *
+ * ```ts
+ * expect(await checkSqlite(betterSupabase, customerList)).toEqual({
+ *   ok: true,
+ *   data: undefined,
+ * });
+ * expect(
+ *   await checkSqlite(betterSupabase, customerList, { all: true }),
+ * ).toEqual([]);
+ * ```
+ */
+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: CheckSqliteOptions & {
+  readonly all: true;
+}): Promise<readonly DbError[]>;
+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?: CheckSqliteOptions & {
+  readonly all?: false;
+}): 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 that don't wait for a local change, for reads that run on the
+   * executor's server `fallback`: `everyMs` reruns on an interval (skipped
+   * while PowerSync reports it is offline), and `onReconnect` reruns when
+   * PowerSync connects again. `onReconnect` needs `registerListener()`.
+   */
+  readonly refresh?: {
+    readonly everyMs?: number;
+    readonly onReconnect?: 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 { checkSqlite as a, CheckSqliteOptions as i, sqliteTables as n, sqliteCompiler as o, watch as r, WatchOptions as t };

package/dist/watch-Cnd6XDnU.js

@@ -0,0 +1,139 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { r as err, s as toDbError } from "./result-DIT_qp4G.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 refresh = options.refresh ?? {};
+	if (refresh.onReconnect && !db.registerListener) throw new TypeError("better-supabase: watch() refresh.onReconnect needs a PowerSync database with registerListener()");
+	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 }
+	});
+	const timer = refresh.everyMs === void 0 ? void 0 : setInterval(() => {
+		if (db.currentStatus?.connected === false) return;
+		rerun();
+	}, refresh.everyMs);
+	let connected = db.currentStatus?.connected ?? true;
+	const unlisten = refresh.onReconnect && db.registerListener ? db.registerListener({ statusChanged: (status) => {
+		const reconnected = status.connected && !connected;
+		connected = status.connected;
+		if (reconnected) rerun();
+	} }) : void 0;
+	const cleanup = () => {
+		clearInterval(timer);
+		unlisten?.();
+	};
+	controller.signal.addEventListener("abort", cleanup, { once: true });
+	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 };