better-supabase 0.8.0 → 0.9.0

package/dist/list-query-gl808ac1.js

@@ -1,459 +0,0 @@
-//#region src/list/list-query.ts
-/** Facet value meaning "not set": filters with `is null`. */
-const UNSET = "__unset__";
-const RESERVED = /* @__PURE__ */ new Set([
-	"q",
-	"sort",
-	"page",
-	"after",
-	"size"
-]);
-function first(value) {
-	return typeof value === "string" ? value : value?.[0];
-}
-function all(value) {
-	return (typeof value === "string" ? [value] : [...value ?? []]).flatMap((entry) => entry.split(",")).map((entry) => entry.trim()).filter(Boolean);
-}
-const isParamValue = (value) => value === void 0 || typeof value === "string" || Array.isArray(value) && value.every((entry) => typeof entry === "string");
-function isSearchParams(value) {
-	return value instanceof URLSearchParams || !("facets" in value && typeof value.facets === "object") && Object.values(value).every(isParamValue);
-}
-function readRecord(input) {
-	if (!(input instanceof URLSearchParams)) return input;
-	const out = {};
-	for (const [key, value] of input) (out[key] ??= []).push(value);
-	return out;
-}
-function toInt(raw) {
-	if (typeof raw === "number") return raw;
-	if (typeof raw !== "string" || !/^\d+$/.test(raw)) return NaN;
-	return Number(raw);
-}
-/**
-* A reusable list endpoint for one table: search, facets, sorts and
-* pagination, validated from URL params or typed input, with URL parsers,
-* OpenAPI parameters and a JSON Schema derived from the same definition.
-*
-* ```ts
-* export const customerList = defineListQuery(betterSupabase, 'customers', {
-*   search: ['name', 'kvk'],
-*   facets: { status: 'status' },
-*   sorts: { name: { name: 'asc' }, newest: [{ createdAt: 'desc' }, { id: 'asc' }] },
-*   defaultSort: 'newest',
-* });
-* ```
-*/
-function defineListQuery(betterSupabase, table, config) {
-	const meta = betterSupabase.meta.tables[table];
-	if (!meta) throw new TypeError(`defineListQuery: unknown table "${table}"`);
-	const pageSize = config.pageSize ?? 50;
-	const maxPageSize = config.maxPageSize ?? 200;
-	const maxSearch = config.maxSearchLength ?? 200;
-	const facetLimit = config.facetLimit ?? 100;
-	const cursor = config.pagination === "cursor";
-	const sortKeys = Object.keys(config.sorts);
-	const facetEntries = Object.entries(config.facets ?? {});
-	for (const [key, column] of facetEntries) {
-		if (RESERVED.has(key)) throw new TypeError(`defineListQuery: facet key "${key}" is reserved`);
-		if (!meta.columns[column]) throw new TypeError(`defineListQuery: unknown column "${table}.${column}"`);
-	}
-	if (!sortKeys.includes(config.defaultSort)) throw new TypeError(`defineListQuery: defaultSort "${config.defaultSort}" is not in sorts`);
-	const facets = facetEntries.map(([key, column]) => {
-		const columnMeta = meta.columns[column];
-		return {
-			key,
-			column,
-			nullable: columnMeta.nullable,
-			...columnMeta.enum ? { values: columnMeta.enum } : {}
-		};
-	});
-	const defaults = {
-		sort: config.defaultSort,
-		page: 1,
-		size: pageSize,
-		facets: {}
-	};
-	function normalize(raw) {
-		const issues = [];
-		let q;
-		if (raw.q !== void 0 && raw.q !== null) {
-			if (typeof raw.q !== "string") issues.push({
-				message: "Must be text",
-				path: ["q"]
-			});
-			else if (raw.q.trim().length > maxSearch) issues.push({
-				message: `At most ${String(maxSearch)} characters`,
-				path: ["q"]
-			});
-			else if (raw.q.trim()) q = raw.q.trim();
-		}
-		let sort = config.defaultSort;
-		if (raw.sort !== void 0 && raw.sort !== "") {
-			if (typeof raw.sort === "string" && sortKeys.includes(raw.sort)) sort = raw.sort;
-			else issues.push({
-				message: `Must be one of: ${sortKeys.join(", ")}`,
-				path: ["sort"]
-			});
-		}
-		const page = raw.page === void 0 || raw.page === "" ? 1 : toInt(raw.page);
-		if (page === void 0 || !Number.isInteger(page) || page < 1) issues.push({
-			message: "Must be a whole number of at least 1",
-			path: ["page"]
-		});
-		else if (cursor && page !== 1) issues.push({
-			message: "This list pages with `after`, not `page`",
-			path: ["page"]
-		});
-		let after;
-		if (raw.after !== void 0 && raw.after !== "") {
-			if (cursor && typeof raw.after === "string") after = raw.after;
-			else issues.push({
-				message: cursor ? "Must be text" : "This list pages with `page`, not `after`",
-				path: ["after"]
-			});
-		}
-		const size = raw.size === void 0 || raw.size === "" ? pageSize : toInt(raw.size);
-		if (size === void 0 || !Number.isInteger(size) || size < 1 || size > maxPageSize) issues.push({
-			message: `Must be a whole number from 1 to ${String(maxPageSize)}`,
-			path: ["size"]
-		});
-		const facetValues = {};
-		for (const facet of facets) {
-			const values = raw.facets[facet.key];
-			if (!values || values.length === 0) continue;
-			for (const value of values) if (!(value === "__unset__" ? facet.nullable : !facet.values || facet.values.includes(value))) issues.push({
-				message: value === "__unset__" ? "This filter cannot be empty" : `Must be one of: ${(facet.values ?? []).join(", ")}`,
-				path: ["facets", facet.key]
-			});
-			facetValues[facet.key] = [...new Set(values)];
-		}
-		if (issues.length > 0) return {
-			ok: false,
-			issues
-		};
-		return {
-			ok: true,
-			value: {
-				...q ? { q } : {},
-				sort,
-				page: page ?? 1,
-				...after ? { after } : {},
-				size: size ?? pageSize,
-				facets: facetValues
-			}
-		};
-	}
-	function parse(input) {
-		if (input === void 0 || input === null) return {
-			ok: true,
-			value: defaults
-		};
-		if (typeof input !== "object") return {
-			ok: false,
-			issues: [{ message: "Expected an object or URL parameters" }]
-		};
-		if (isSearchParams(input)) {
-			const record = readRecord(input);
-			const facetValues = {};
-			for (const facet of facets) facetValues[facet.key] = all(record[facet.key]);
-			return normalize({
-				q: first(record["q"]),
-				sort: first(record["sort"]),
-				page: first(record["page"]),
-				after: first(record["after"]),
-				size: first(record["size"]),
-				facets: facetValues
-			});
-		}
-		const typed = input;
-		const rawFacets = typed.facets ?? {};
-		for (const [key, value] of Object.entries(rawFacets)) if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) return {
-			ok: false,
-			issues: [{
-				message: "Must be a list of values",
-				path: ["facets", key]
-			}]
-		};
-		return normalize({
-			q: typed.q,
-			sort: typed.sort,
-			page: typed.page,
-			after: typed.after,
-			size: typed.size,
-			facets: rawFacets
-		});
-	}
-	function searchWhere(query) {
-		if (!query.q || !config.search) return void 0;
-		if (Array.isArray(config.search)) {
-			const columns = config.search;
-			if (columns.length === 0) return void 0;
-			return { OR: columns.map((column) => ({ [column]: { contains: query.q } })) };
-		}
-		const fts = config.search;
-		return { [fts.fts]: { search: fts.config ? {
-			query: query.q,
-			config: fts.config
-		} : query.q } };
-	}
-	function facetWhere(facet, values) {
-		if (!values || values.length === 0) return void 0;
-		const unset = values.includes(UNSET);
-		const set = values.filter((value) => value !== UNSET);
-		if (unset && set.length === 0) return { [facet.column]: null };
-		if (!unset) return { [facet.column]: { in: set } };
-		return { OR: [{ [facet.column]: { in: set } }, { [facet.column]: null }] };
-	}
-	function and(parts) {
-		const present = parts.filter((part) => part !== void 0);
-		if (present.length === 0) return void 0;
-		return present.length === 1 ? present[0] : { AND: present };
-	}
-	function where(query) {
-		return and([searchWhere(query), ...facets.map((facet) => facetWhere(facet, query.facets[facet.key]))]);
-	}
-	function args(query) {
-		const filter = where(query);
-		const paging = cursor ? { after: query.after ?? null } : {
-			page: query.page,
-			count: config.count ?? "planned"
-		};
-		return {
-			...filter ? { where: filter } : {},
-			orderBy: config.sorts[query.sort],
-			size: query.size,
-			...paging
-		};
-	}
-	/** Rows per value of one facet, from its grouped aggregate. */
-	function countsOf(facet, groups) {
-		const counts = {};
-		for (const value of facet.values ?? []) counts[value] = 0;
-		for (const group of groups) {
-			const raw = group[facet.column];
-			const key = raw === null || raw === void 0 ? UNSET : String(raw);
-			counts[key] = (counts[key] ?? 0) + Number(group["_count"] ?? 0);
-		}
-		return counts;
-	}
-	const listParser = {
-		parse: (value) => {
-			const values = all(value);
-			return values.length > 0 ? values : null;
-		},
-		serialize: (values) => values.join(",")
-	};
-	const intParser = {
-		parse: (value) => /^\d+$/.test(value) ? Number(value) : null,
-		serialize: String
-	};
-	const parsers = {
-		q: {
-			parse: (value) => value.trim() || null,
-			serialize: (value) => value
-		},
-		sort: {
-			parse: (value) => sortKeys.includes(value) ? value : null,
-			serialize: (value) => value
-		},
-		page: intParser,
-		after: {
-			parse: (value) => value || null,
-			serialize: (value) => value
-		},
-		size: intParser,
-		...Object.fromEntries(facets.map((facet) => [facet.key, listParser]))
-	};
-	const facetSchema = (facet) => ({
-		type: "array",
-		items: {
-			type: "string",
-			...facet.values ? { enum: [...facet.values, ...facet.nullable ? [UNSET] : []] } : {}
-		},
-		uniqueItems: true
-	});
-	const searchDescription = config.search ? Array.isArray(config.search) ? `Case-insensitive search in ${config.search.join(", ")}.` : "Full-text search (web search syntax)." : void 0;
-	const openapi = [
-		...searchDescription ? [{
-			name: "q",
-			in: "query",
-			required: false,
-			description: searchDescription,
-			schema: {
-				type: "string",
-				maxLength: maxSearch
-			}
-		}] : [],
-		{
-			name: "sort",
-			in: "query",
-			required: false,
-			description: `Ordering. Default \`${config.defaultSort}\`.`,
-			schema: {
-				type: "string",
-				enum: sortKeys,
-				default: config.defaultSort
-			}
-		},
-		cursor ? {
-			name: "after",
-			in: "query",
-			required: false,
-			description: "`nextCursor` of the previous page. Leave it out for the first page.",
-			schema: { type: "string" }
-		} : {
-			name: "page",
-			in: "query",
-			required: false,
-			description: "1-based page number.",
-			schema: {
-				type: "integer",
-				minimum: 1,
-				default: 1
-			}
-		},
-		{
-			name: "size",
-			in: "query",
-			required: false,
-			description: "Page size.",
-			schema: {
-				type: "integer",
-				minimum: 1,
-				maximum: maxPageSize,
-				default: pageSize
-			}
-		},
-		...facets.map((facet) => ({
-			name: facet.key,
-			in: "query",
-			required: false,
-			description: `Filter on ${facet.column}. Comma-separated; any value matches.${facet.nullable ? ` \`${UNSET}\` matches empty.` : ""}`,
-			schema: facetSchema(facet),
-			style: "form",
-			explode: false
-		}))
-	];
-	const jsonSchema = {
-		type: "object",
-		additionalProperties: false,
-		properties: {
-			...searchDescription ? { q: {
-				type: "string",
-				maxLength: maxSearch,
-				description: searchDescription
-			} } : {},
-			sort: {
-				type: "string",
-				enum: sortKeys,
-				default: config.defaultSort
-			},
-			...cursor ? { after: { type: "string" } } : { page: {
-				type: "integer",
-				minimum: 1,
-				default: 1
-			} },
-			size: {
-				type: "integer",
-				minimum: 1,
-				maximum: maxPageSize,
-				default: pageSize
-			},
-			...facets.length > 0 ? { facets: {
-				type: "object",
-				additionalProperties: false,
-				properties: Object.fromEntries(facets.map((facet) => [facet.key, facetSchema(facet)]))
-			} } : {}
-		}
-	};
-	return {
-		table,
-		pagination: config.pagination ?? "offset",
-		defaults,
-		facets,
-		parse,
-		schema: { "~standard": {
-			version: 1,
-			vendor: "better-supabase",
-			validate(value) {
-				const result = parse(value);
-				return result.ok ? { value: result.value } : { issues: result.issues };
-			}
-		} },
-		toSearchParams(query) {
-			const params = new URLSearchParams();
-			if (query.q) params.set("q", query.q);
-			if (query.sort && query.sort !== config.defaultSort) params.set("sort", query.sort);
-			if (query.page && query.page !== 1) params.set("page", String(query.page));
-			if (query.after) params.set("after", query.after);
-			if (query.size !== void 0 && query.size > 0 && query.size !== pageSize) params.set("size", String(query.size));
-			for (const facet of facets) {
-				const values = query.facets?.[facet.key];
-				if (values && values.length > 0) params.set(facet.key, values.join(","));
-			}
-			return params;
-		},
-		parsers,
-		nuqs: (createParser) => Object.fromEntries(Object.entries(parsers).map(([key, spec]) => [key, createParser(spec)])),
-		args,
-		run(db, query, extra) {
-			const base = args(query);
-			const { where: extraWhere, count, select: _select, include: _include, ...options } = extra ?? {};
-			const combined = and([extraWhere, base["where"]]);
-			const repository = db[table];
-			const page = repository.paginate({
-				...extra,
-				...base,
-				...cursor ? {} : { count: count ?? base["count"] },
-				...combined ? { where: combined } : {}
-			});
-			if (!config.facetCounts) return page;
-			if (facets.length === 0) return page.map((data) => ({
-				...data,
-				facetCounts: {},
-				facetCountsTruncated: []
-			}));
-			const search = searchWhere(query);
-			const counted = facets.map((facet) => {
-				const filter = and([
-					extraWhere,
-					search,
-					...facets.map((other) => other === facet ? void 0 : facetWhere(other, query.facets[other.key]))
-				]);
-				return repository.aggregate({
-					...options,
-					...filter ? { where: filter } : {},
-					groupBy: [facet.column],
-					_count: true,
-					orderBy: [{ _count: "desc" }, { [facet.column]: "asc" }],
-					limit: facetLimit + 1
-				});
-			});
-			return page.andThen(async (data) => {
-				const results = await Promise.all(counted);
-				const facetCounts = {};
-				const truncated = [];
-				for (const [index, facet] of facets.entries()) {
-					const result = results[index];
-					if (!result.ok) return result;
-					const rows = result.data;
-					if (rows.length > facetLimit) truncated.push(facet.key);
-					facetCounts[facet.key] = countsOf(facet, rows.slice(0, facetLimit));
-				}
-				return {
-					ok: true,
-					data: {
-						...data,
-						facetCounts,
-						facetCountsTruncated: truncated
-					},
-					error: null
-				};
-			});
-		},
-		openapi,
-		jsonSchema
-	};
-}
-//#endregion
-export { defineListQuery as n, UNSET as t };

package/dist/live-CTAZQkwl.js

@@ -1,257 +0,0 @@
-import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
-//#region src/realtime/auth.ts
-/**
-* Hands the client's access token to Realtime before a private join,
-* unless the app set one itself with `realtime.setAuth(token)`. A bare
-* `setAuth()` replaces such a token with the session's, so a client that
-* joins with a token minted for Realtime (a service or agent token) keeps it.
-* realtime-js versions without the manual-token check always refresh.
-*/
-async function refreshRealtimeAuth(client) {
-	if (manualToken(client.realtime)) return;
-	await client.realtime.setAuth();
-}
-/** Whether realtime-js says the token came from `setAuth(token)`. */
-function manualToken(realtime) {
-	if (!("_isManualToken" in realtime)) return false;
-	const check = realtime._isManualToken;
-	return typeof check === "function" && check.call(realtime) === true;
-}
-//#endregion
-//#region src/realtime/live.ts
-/**
-* Topic a `realtime-tables` trigger broadcasts on:
-* `bs:t:<schema>.<table>[:<tenant>]`, or `bs:t:<schema>.<table>:u:<user>`
-* for a `realtime.users` table.
-*/
-function liveTopic(meta, table, tenant, user) {
-	const found = meta.tables[table];
-	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
-	const base = `bs:t:${found.schema}.${found.name}`;
-	if (meta.realtime?.[table]?.user) {
-		if (user === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per user; pass \`user\` to watch it`);
-		return `${base}:u:${user}`;
-	}
-	if (!meta.realtime?.[table]?.tenant) return base;
-	if (tenant === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per tenant; pass \`tenant\` to watch it`);
-	return `${base}:${tenant}`;
-}
-const channels = /* @__PURE__ */ new WeakMap();
-function join(client, topic, listener, onStatus) {
-	let byTopic = channels.get(client);
-	if (!byTopic) {
-		byTopic = /* @__PURE__ */ new Map();
-		channels.set(client, byTopic);
-	}
-	let shared = byTopic.get(topic);
-	if (!shared) {
-		const channel = client.channel(topic, { config: { private: true } });
-		const listeners = /* @__PURE__ */ new Set();
-		const statuses = /* @__PURE__ */ new Set();
-		channel.on("broadcast", { event: "change" }, () => {
-			for (const notify of listeners) notify();
-		});
-		let joined = false;
-		const evict = () => {
-			if (byTopic.get(topic) !== entry) return;
-			byTopic.delete(topic);
-			client.removeChannel(channel);
-		};
-		const ready = (async () => {
-			await refreshRealtimeAuth(client);
-			await new Promise((resolve, reject) => {
-				channel.subscribe((status, error) => {
-					switch (status) {
-						case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
-							if (joined) {
-								for (const notify of listeners) notify();
-								for (const notify of statuses) notify("subscribed");
-							}
-							joined = true;
-							resolve();
-							return;
-						case REALTIME_SUBSCRIBE_STATES.CLOSED:
-							resolve();
-							return;
-						case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
-						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT: {
-							const failure = error ?? /* @__PURE__ */ new Error(`Realtime ${status.toLowerCase()} on ${topic}`);
-							if (joined) for (const notify of statuses) notify("error", failure);
-							reject(failure);
-							if (!joined) evict();
-							return;
-						}
-						default: reject(/* @__PURE__ */ new Error(`Unknown realtime status ${String(status)}`));
-					}
-				});
-			});
-		})();
-		ready.catch(() => void 0);
-		const entry = {
-			channel,
-			listeners,
-			statuses,
-			ready
-		};
-		shared = entry;
-		byTopic.set(topic, entry);
-	}
-	const current = shared;
-	current.listeners.add(listener);
-	if (onStatus) current.statuses.add(onStatus);
-	let left = false;
-	return {
-		ready: current.ready,
-		leave: async () => {
-			if (left) return;
-			left = true;
-			current.listeners.delete(listener);
-			if (onStatus) current.statuses.delete(onStatus);
-			if (current.listeners.size > 0) return;
-			await new Promise((resolve) => {
-				setTimeout(resolve, 0);
-			});
-			if (current.listeners.size > 0 || byTopic.get(topic) !== current) return;
-			byTopic.delete(topic);
-			await client.removeChannel(current.channel);
-		}
-	};
-}
-/**
-* Calls `onChange` when a table the spec reads changes, so you can refetch.
-* Needs the `realtime-tables` SQL module and the tables in
-* `realtime.tables`. Live queries on the same client share one channel per
-* table, so any number of them can run at once.
-*
-* ```ts
-* using live = liveQuery(betterSupabase, supabase, spec, { onChange: () => refetch() });
-* ```
-*/
-function liveQuery(betterSupabase, client, spec, options) {
-	const touched = Array.isArray(spec) ? spec : betterSupabase.tablesOf(spec);
-	const tables = touched.filter((table) => betterSupabase.meta.realtime?.[table]);
-	const unwatched = touched.filter((table) => !betterSupabase.meta.realtime?.[table]);
-	const debounceMs = options.debounceMs ?? 100;
-	const changed = /* @__PURE__ */ new Set();
-	let timer;
-	let closed = false;
-	const flush = () => {
-		timer = void 0;
-		if (closed || changed.size === 0) return;
-		const batch = [...changed];
-		changed.clear();
-		options.onChange(batch);
-	};
-	const onTableChange = (table) => () => {
-		changed.add(table);
-		if (timer !== void 0) clearTimeout(timer);
-		timer = setTimeout(flush, debounceMs);
-	};
-	const failed = /* @__PURE__ */ new Set();
-	const onChannelStatus = (topic) => (status, error) => {
-		if (closed) return;
-		if (status === "error") failed.add(topic);
-		else failed.delete(topic);
-		if (status === "error") options.onStatus?.("error", error);
-		else if (failed.size === 0) options.onStatus?.("subscribed");
-	};
-	const topics = tables.map((table) => ({
-		table,
-		topic: liveTopic(betterSupabase.meta, table, options.tenant, options.user)
-	}));
-	const joinAll = () => topics.map(({ table, topic }) => join(client, topic, onTableChange(table), onChannelStatus(topic)));
-	let memberships = joinAll();
-	let retryTimer;
-	let delay = 1e3;
-	const settle = (attempt) => Promise.all(attempt.map((member) => member.ready)).then(() => {
-		if (!closed && tables.length > 0) options.onStatus?.("subscribed");
-	}, (cause) => {
-		const error = cause instanceof Error ? cause : new Error(String(cause));
-		if (!closed) {
-			options.onStatus?.("error", error);
-			if (options.retry !== false) scheduleRetry(attempt);
-		}
-		throw error;
-	});
-	const scheduleRetry = (attempt) => {
-		retryTimer = setTimeout(() => {
-			retryTimer = void 0;
-			if (closed || attempt !== memberships) return;
-			Promise.all(attempt.map((member) => member.leave()));
-			memberships = joinAll();
-			options.onStatus?.("joining");
-			settle(memberships).then(() => {
-				if (closed) return;
-				for (const table of tables) changed.add(table);
-				flush();
-			}, () => void 0);
-		}, delay);
-		delay = Math.min(delay * 2, 3e4);
-	};
-	options.onStatus?.(tables.length === 0 ? "closed" : "joining");
-	const ready = settle(memberships);
-	ready.catch(() => void 0);
-	const unsubscribe = async () => {
-		if (closed) return;
-		closed = true;
-		if (timer !== void 0) clearTimeout(timer);
-		if (retryTimer !== void 0) clearTimeout(retryTimer);
-		await Promise.all(memberships.map((member) => member.leave()));
-		options.onStatus?.("closed");
-	};
-	return {
-		tables,
-		unwatched,
-		ready,
-		unsubscribe,
-		[Symbol.dispose]: () => void unsubscribe(),
-		[Symbol.asyncDispose]: unsubscribe
-	};
-}
-/**
-* Keeps a count current: runs the `count` spec (a HEAD request) now, after
-* each debounced change to a table it reads, and after the channel rejoins.
-* Responses that arrive out of order are dropped.
-*
-* ```ts
-* using live = liveCount(betterSupabase, supabase, db, betterSupabase.spec.notes.count(), {
-*   onCount: (count) => render(count),
-* });
-* ```
-*/
-function liveCount(betterSupabase, client, db, spec, options) {
-	let latest = 0;
-	let closed = false;
-	const refetch = () => {
-		const call = ++latest;
-		Promise.resolve(db.$run(spec)).then((result) => {
-			if (closed || call !== latest) return;
-			if (result.ok) options.onCount(result.data);
-			else options.onError?.(result.error);
-		});
-	};
-	const live = liveQuery(betterSupabase, client, spec, {
-		onChange: refetch,
-		...options.tenant === void 0 ? {} : { tenant: options.tenant },
-		...options.user === void 0 ? {} : { user: options.user },
-		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs },
-		...options.onStatus ? { onStatus: options.onStatus } : {}
-	});
-	if (options.immediate ?? true) refetch();
-	const since = options.since;
-	if (since !== void 0) live.ready.then(() => {
-		if (!closed && Date.now() - since > 1e3) refetch();
-	}, () => void 0);
-	const unsubscribe = async () => {
-		closed = true;
-		await live.unsubscribe();
-	};
-	return {
-		...live,
-		unsubscribe,
-		[Symbol.dispose]: () => void unsubscribe(),
-		[Symbol.asyncDispose]: unsubscribe
-	};
-}
-//#endregion
-export { refreshRealtimeAuth as i, liveQuery as n, liveTopic as r, liveCount as t };