better-supabase 0.5.0 → 0.6.0

package/dist/{view-BEf0diC5.d.ts → view-DbxLNu8L.d.ts}

@@ -1,30 +1,8 @@
-import { _ as DbError } from "./executor-BunPOO-k.js";
-import { i as InvalidReason, r as AuthState } from "./resolve-C15TJq77.js";
-import { n as AmrEntry, s as Impersonator, t as Aal } from "./mfa-CusDgPaD.js";
+import { b as DbError } from "./result-D7y2fT87.js";
+import { i as InvalidReason, r as AuthState } from "./resolve-KW8nCeL6.js";
+import { n as AmrEntry, s as Impersonator, t as Aal } from "./mfa-Daak8ukG.js";
+import { n as SessionActor, r as SessionDelegation } from "./actor-CQTlc1Hh.js";
 import { JWTClaims, UserClaims } from "@supabase/server";
-//#region src/auth/actor.d.ts
-/** One level of an RFC 8693 `act` chain: who acts, and who acted before it. */
-interface ActClaim {
-  readonly sub: string;
-  readonly act?: ActClaim;
-  readonly [claim: string]: unknown;
-}
-/**
- * The app acting for the user: the outermost `sub` of an RFC 8693 `act`
- * chain (prior actors stay on `chain`), else the OAuth `client_id` of a
- * Supabase OAuth server token.
- */
-interface SessionActor {
-  readonly id: string;
-  readonly kind: "oauth-client";
-  readonly chain?: ActClaim;
-}
-/** What the user delegated to the actor: the token's OAuth `scope`. */
-interface SessionDelegation {
-  readonly scopes: readonly string[];
-  readonly chain?: ActClaim;
-}
-//#endregion
 //#region src/auth/view.d.ts
 /**
  * The verified caller as plain data: no token, no clients. Safe to return
@@ -32,6 +10,12 @@ interface SessionDelegation {
  */
 type AuthSession<C = unknown, P = unknown> = {
   readonly kind: "user";
+  /**
+   * Read from the verified claims (`sub`, `email`, `role`,
+   * `app_metadata`, `user_metadata`), never from the user object in the
+   * cookie, so it is the same with `tokens-only` cookies. Call
+   * `auth.getUser()` when a flow must see a revoked or changed user.
+   */
   readonly user: UserClaims;
   /**
    * The verified JWT payload, including custom access token hook claims,
@@ -50,23 +34,42 @@ type AuthSession<C = unknown, P = unknown> = {
   readonly aal: Aal;
   /**
    * Signed in with `signInAnonymously()` (the `is_anonymous` claim). Guards
-   * refuse these users unless `allow` lists `'anonymous'`.
+   * refuse these users unless `allow` lists `'anonymous'`; `'anon'` means
+   * no session and never admits them.
    */
   readonly anonymous: boolean;
   /** How the user signed in (`password`, `totp`, `sso/saml`, ...). */
   readonly amr: readonly AmrEntry[];
-  /** Set when an admin acts as this user (the `act` claim), for a banner. */
+  /**
+   * Set when an admin acts as this user in a support session or an
+   * impersonated session (`act.kind`), for a banner. Matches `actor`.
+   */
   readonly impersonator?: Impersonator;
   /**
-   * The OAuth client or agent acting for the user (`client_id`, or the
-   * outermost `sub` of the `act` chain), as PermDock's `actorOf` reads it.
+   * Who acts for the user: an OAuth client or agent (`client_id`, or an
+   * `act` chain without `kind`), a support session or an impersonated
+   * session, read from the `act` and `client_id` claims.
    */
   readonly actor?: SessionActor;
-  /** The scopes the user granted `actor`, plus its `act` chain. Set only with `actor`. */
+  /**
+   * The scopes the user granted an `oauth-client` actor, plus its `act`
+   * chain. Never set for a support or impersonated session.
+   */
   readonly delegation?: SessionDelegation;
 } | {
   readonly kind: "service";
   readonly keyName: string;
+} | {
+  readonly kind: "apiKey";
+  readonly keyId: string;
+  readonly name: string;
+  readonly organizationId?: string;
+  readonly userId?: string;
+  readonly scopes: readonly string[];
+  /** Seconds since epoch, when the key was created. */
+  readonly createdAt?: number;
+  /** The user who created the key. */
+  readonly createdBy?: string;
 } | {
   readonly kind: "anon";
   readonly reason: AnonReason;
@@ -81,4 +84,4 @@ type AnonReason = Extract<AuthState, {
 /** Drops the token from an `AuthState`, leaving only serializable fields. */
 declare function toSession<C, P>(auth: AuthState<C, P>): AuthSession<C, P>;
 //#endregion
-export { SessionDelegation as a, SessionActor as i, toSession as n, ActClaim as r, AuthSession as t };
+export { toSession as n, AuthSession as t };

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 };