better-supabase 0.5.0 → 0.6.0

package/dist/svelte/index.js

@@ -0,0 +1,344 @@
+import { t as clearOnUserChange } from "../user-change-XzvgafU4.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 { getContext, onMount, setContext } from "svelte";
+import { createSubscriber } from "svelte/reactivity";
+//#region src/svelte/index.ts
+/** Reads a store reactively: the caller re-runs when the store changes. */
+function reactive(store) {
+	const subscribe = createSubscriber((update) => store.subscribe(update));
+	return { get current() {
+		subscribe();
+		return store.current();
+	} };
+}
+/**
+* A subscription keyed by `key()`. The returned function goes in each
+* getter: it registers the reader, then restarts the subscription when the
+* key (read in the reader's tracking context) changed. Notifications are
+* queued, since a getter may run inside `$derived`, where writes throw.
+*/
+function followed(key, start) {
+	const run = keyed();
+	let notify;
+	const queued = () => {
+		queueMicrotask(() => notify?.());
+	};
+	const update = () => {
+		const next = key();
+		run.update(next, () => next === null ? void 0 : start(next, queued));
+	};
+	const subscribe = createSubscriber((changed) => {
+		notify = changed;
+		update();
+		return () => {
+			notify = void 0;
+			run.stop();
+		};
+	});
+	return () => {
+		subscribe();
+		if (notify) update();
+	};
+}
+const NO_MEMBERS = [];
+/** Binds a client to Svelte without a component context, e.g. in tests or a module. */
+function createBetterSvelte(client, options = {}) {
+	const { queryClient } = options;
+	const auth = reactive(client.auth);
+	const plainCallers = /* @__PURE__ */ new WeakMap();
+	const callerFor = (supabase) => {
+		if (supabase === void 0) return { get current() {
+			return callerOf(auth.current);
+		} };
+		let caller = plainCallers.get(supabase);
+		if (!caller) {
+			caller = reactive(plainCaller(supabase));
+			plainCallers.set(supabase, caller);
+		}
+		return caller;
+	};
+	return {
+		client,
+		queryClient,
+		db: client.db,
+		queries: client.queries,
+		supabase: client.supabase,
+		auth,
+		broadcast(topic, values, handlers, options) {
+			const supabase = options?.client ?? client.supabase;
+			const forQuery = options?.queryClient ?? queryClient;
+			assertInvalidateClient("broadcast", options, forQuery);
+			const caller = callerFor(options?.client);
+			let status = "closed";
+			const name = () => {
+				const current = values();
+				return current ? topic.topic(current) : null;
+			};
+			const track = followed(() => {
+				const current = name();
+				const who = caller.current;
+				if (current === null || who.status === "loading") return null;
+				return JSON.stringify([current, who.userId]);
+			}, (_key, notify) => {
+				const current = name();
+				if (current === null) return;
+				return startBroadcast({
+					supabase,
+					topic,
+					name: current,
+					latest: () => ({
+						handlers,
+						options
+					}),
+					queryClient: forQuery,
+					onStatus: (next) => {
+						status = next;
+						notify();
+					}
+				});
+			});
+			return { get current() {
+				track();
+				return status;
+			} };
+		},
+		liveQuery(spec, options = {}) {
+			let status = "closed";
+			let joined = null;
+			const track = followed(() => {
+				const current = spec();
+				if (current && !queryClient) throw new Error("better-supabase: liveQuery needs setBetterSupabase(bs, { queryClient })");
+				return liveKey(client, current, auth.current, options);
+			}, (key, notify) => {
+				const current = spec();
+				if (!current || !queryClient) return;
+				const resumed = joined === key;
+				joined = key;
+				return startLiveQuery({
+					client,
+					queryClient,
+					spec: current,
+					auth: client.auth.current(),
+					options,
+					resumed,
+					onStatus: (next) => {
+						status = next;
+						notify();
+					}
+				});
+			});
+			return { get current() {
+				track();
+				return status;
+			} };
+		},
+		liveCount(source, options = {}) {
+			let status = "closed";
+			let state = NO_COUNT;
+			let joined = null;
+			const parsed = () => countSource(source(), options);
+			const key = () => liveKey(client, parsed().spec, auth.current, options);
+			const track = followed(key, (next, notify) => {
+				const { spec, initial, seedAt } = parsed();
+				if (!spec) return;
+				const previous = joined?.key === next ? joined : null;
+				joined = {
+					key: next,
+					at: previous?.at ?? seedAt ?? 0
+				};
+				return startLiveCount({
+					client,
+					spec,
+					key: next,
+					auth: client.auth.current(),
+					options,
+					immediate: initial === void 0 && !previous,
+					since: previous ? previous.at : seedAt,
+					onState: (update) => {
+						state = update(state);
+						if (joined?.key === next) joined = {
+							key: next,
+							at: state.at
+						};
+						notify();
+					},
+					onStatus: (value) => {
+						status = value;
+						notify();
+					}
+				});
+			});
+			const shown = () => {
+				track();
+				return shownCount(state, key(), parsed());
+			};
+			return {
+				get count() {
+					return shown().count;
+				},
+				get status() {
+					track();
+					return status;
+				},
+				get error() {
+					return shown().error;
+				}
+			};
+		},
+		presence(topic, values, options = {}) {
+			const supabase = options.client ?? client.supabase;
+			const caller = callerFor(options.client);
+			let members = NO_MEMBERS;
+			let status = "closed";
+			let join;
+			const name = () => {
+				const current = values();
+				return current ? topic.topic(current) : null;
+			};
+			const follow = followed(() => {
+				const current = name();
+				const who = caller.current;
+				if (current === null || who.status === "loading") return null;
+				return JSON.stringify([current, who.userId]);
+			}, (_key, notify) => {
+				const current = name();
+				if (current === null) return;
+				const joined = joinPresence(supabase, topic, current, {
+					onStatus: (next) => {
+						status = next;
+						notify();
+					},
+					onPresence: (next) => {
+						members = next;
+						notify();
+					}
+				});
+				if (!joined) return;
+				join = joined;
+				joined.sync(options.state?.());
+				return () => {
+					join = void 0;
+					members = NO_MEMBERS;
+					status = "closed";
+					joined.leave();
+					notify();
+				};
+			});
+			const track = () => {
+				follow();
+				join?.sync(options.state?.());
+			};
+			return {
+				get members() {
+					track();
+					return members;
+				},
+				get status() {
+					track();
+					return status;
+				},
+				track: (state) => join?.track(state) ?? notJoined(),
+				untrack: () => join?.untrack() ?? notJoined()
+			};
+		},
+		action(action, options = {}) {
+			const call = action;
+			const runner = createActionRunner(() => ({
+				action: call,
+				options
+			}));
+			const state = reactive(runner);
+			return {
+				run: runner.run,
+				reset: runner.reset,
+				get pending() {
+					return state.current.pending;
+				},
+				get pendingInputs() {
+					return state.current.pendingInputs;
+				},
+				get pendingInput() {
+					return state.current.pendingInput;
+				},
+				get data() {
+					return state.current.data;
+				},
+				get error() {
+					return state.current.error;
+				}
+			};
+		}
+	};
+}
+const CLIENT = Symbol("better-supabase");
+const SESSION = Symbol("better-supabase-session");
+/**
+* Binds the client for the components below, in the root layout. With a
+* `queryClient`, better-supabase queries are reset when the caller changes.
+*
+* ```svelte
+* <script lang="ts">
+*   setBetterSupabase(bs, { queryClient });
+* <\/script>
+* ```
+*/
+function setBetterSupabase(client, options = {}) {
+	const bound = createBetterSvelte(client, options);
+	const { queryClient } = options;
+	if (queryClient) onMount(() => clearOnUserChange(queryClient, client.auth));
+	return setContext(CLIENT, bound);
+}
+/** The client `setBetterSupabase` bound, typed with `getBetterSupabase<typeof bs>()`. */
+function getBetterSupabase() {
+	const bound = getContext(CLIENT);
+	if (!bound) throw new Error("better-supabase: call setBetterSupabase(bs) in a parent component");
+	return bound;
+}
+/** The session state for UI. Call during component setup. */
+function useAuth() {
+	return getBetterSupabase().auth;
+}
+/** Subscribes to a topic while read. Call during component setup. */
+function useBroadcast(topic, values, handlers, options) {
+	return getBetterSupabase().broadcast(topic, values, handlers, options);
+}
+/**
+* Keeps a query fresh while read. Call during component setup.
+*
+* ```svelte
+* <script lang="ts">
+*   const live = useLiveQuery(() => betterSupabase.spec.customers.findMany());
+* <\/script>
+* <span data-status={live.current}></span>
+* ```
+*/
+function useLiveQuery(spec, options) {
+	return getBetterSupabase().liveQuery(spec, options);
+}
+/** A count that stays current while read. Call during component setup. */
+function useLiveCount(source, options) {
+	return getBetterSupabase().liveCount(source, options);
+}
+/** Joins a presence topic while read. Call during component setup. */
+function usePresence(topic, values, options) {
+	return getBetterSupabase().presence(topic, values, options);
+}
+/** Tracks the runs of a server action or form action. */
+function useAction(action, options) {
+	return getBetterSupabase().action(action, options);
+}
+/** Shares a server-verified session (from `+layout.ts` data) with the components below. */
+function setSession(session) {
+	setContext(SESSION, session);
+}
+/** The session from the nearest `setSession()`, typed with `useSession<Claims, Profile>()`. */
+function useSession() {
+	const session = getContext(SESSION);
+	if (!session) throw new Error("better-supabase: useSession() needs setSession(() => data.session) in a parent component");
+	return { get current() {
+		return session();
+	} };
+}
+//#endregion
+export { createBetterSvelte, fieldErrorsOf, getBetterSupabase, setBetterSupabase, setSession, useAction, useAuth, useBroadcast, useLiveCount, useLiveQuery, usePresence, useSession };

package/dist/sveltekit/index.d.ts

@@ -0,0 +1,116 @@
+import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { t as BetterServer } from "../server-CeVeeXwz.js";
+import { a as AuthorizedContext, c as Unwrapped, i as AuthorizeOptions, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-B5tid-q5.js";
+import { t as RefusalRedirects } from "../refusal-D1rgbzNq.js";
+import { n as FrameworkOptions, t as FrameworkLocals } from "../framework-DuVb4Xa8.js";
+import { t as Validated } from "../shared-DDSjEGDR.js";
+import { i as tagFor } from "../tags-Cx-LnIQP.js";
+import { AnyEntry, Contributions } from "@supabase/middleware";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/bridges/sveltekit.d.ts
+/** The part of SvelteKit's `RequestEvent` the bridge reads and writes. */
+interface SvelteKitEvent<Locals extends object> {
+  readonly request: Request;
+  readonly locals: Locals;
+  readonly platform?: {
+    readonly env?: unknown;
+  } | undefined;
+}
+/** SvelteKit's `Handle`, typed structurally so the package does not import `@sveltejs/kit`. */
+type SvelteKitHandle<Locals extends object> = (input: {
+  readonly event: SvelteKitEvent<Locals>;
+  readonly resolve: (event: SvelteKitEvent<Locals>) => Response | Promise<Response>;
+}) => Promise<Response>;
+/**
+ * Runs an entry array as a SvelteKit `handle` hook. Every contributed key
+ * lands on `event.locals`, so loads, actions and endpoints read
+ * `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
+ * the keys in `App.Locals` with `BetterSupabaseContributions`.
+ *
+ * ```ts title="src/hooks.server.ts"
+ * export const handle = toSvelteKit([withBetterSupabase(server)])
+ * ```
+ *
+ * Compose it with other hooks through SvelteKit's `sequence`.
+ */
+export declare function toSvelteKit<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>): SvelteKitHandle<Partial<Contributions<Entries>>>;
+//#endregion
+//#region src/sveltekit/create.d.ts
+/** SvelteKit's `fail()` result, typed structurally. */
+interface SvelteKitFailure<T> {
+  readonly status: number;
+  readonly data: T;
+}
+/**
+ * `error`, `redirect` and `fail` from `@sveltejs/kit`. Pass them so refused
+ * callers get SvelteKit's own errors and redirects, and failed form actions
+ * a `fail()` with the status.
+ */
+interface SvelteKitHelpers {
+  error(status: number, body: {
+    readonly message: string;
+  }): never;
+  redirect(status: 303, location: string): never;
+  fail(status: number, data: Record<string, unknown>): SvelteKitFailure<unknown>;
+}
+interface SvelteKitOptions extends FrameworkOptions {
+  /** `{ error, redirect, fail }` from `@sveltejs/kit`. */
+  readonly kit?: SvelteKitHelpers;
+}
+/** The part of a SvelteKit `RequestEvent` the guards read. */
+interface SvelteKitRequestEvent<Locals extends object = object> {
+  readonly request: Request;
+  readonly locals: Locals;
+}
+/** A load's `depends`, typed structurally. */
+interface SvelteKitDepends {
+  depends(...deps: `${string}:${string}`[]): void;
+}
+/** What `handleError` returns: SvelteKit's `App.Error` with a code. */
+interface SvelteKitAppError {
+  readonly message: string;
+  readonly code?: string;
+}
+interface BetterSvelteKit<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /** The keys on `event.locals`, for `App.Locals`. Type only: `undefined` at runtime. */
+  readonly Locals: FrameworkLocals<M, F, E, C, P>;
+  /**
+   * The `handle` hook: verifies the caller, refreshes the session cookie on
+   * navigations and form posts, and puts `db`, `bs`, `auth`, `tenant` and
+   * the serializable `session` on `event.locals`.
+   */
+  readonly handle: SvelteKitHandle<Partial<FrameworkLocals<M, F, E, C, P>>>;
+  /**
+   * The caller in a `load` or endpoint, or a refusal: a redirect to
+   * `signIn` or `mfa` when configured, else SvelteKit's `error()`.
+   *
+   * ```ts
+   * export const load = async (event) => {
+   *   const { db, tenant } = await bs.require(event, { requireTenant: true });
+   *   return { customers: await db.customers.findMany().orThrow() };
+   * };
+   * ```
+   */
+  require<R extends boolean = false>(event: SvelteKitRequestEvent, options?: BlockRequireOptions<C, P, R>): Promise<FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>>;
+  /**
+   * A form action returning an `ActionResult`: validates the form with
+   * `input`, runs the guard and `authorize`, and on failure answers with
+   * `fail(status, result)` when `kit` is set, so `form.error` is a `DbError`.
+   */
+  action<S extends StandardSchemaV1 | undefined, T, R extends boolean = false>(options: BlockActionOptions<S, C, P, R>, fn: (input: ActionParsed<S>, ctx: FrameworkLocals<M, F, E, C, P> & AuthorizedContext<C, P, R>, event: SvelteKitRequestEvent) => T): (event: SvelteKitRequestEvent) => Promise<ActionResult<Unwrapped<Awaited<T>>> | SvelteKitFailure<ActionResult<never>>>;
+  /**
+   * `handleError` for `hooks.server.ts`: `DbError`s keep their message and
+   * kind as `code`; other errors become a generic message unless
+   * `exposeErrors` is on.
+   */
+  handleError(input: {
+    readonly error: unknown;
+  }): SvelteKitAppError;
+  /** Registers `bs:<table>` dependencies, so `invalidate(tagFor(table))` reruns the load. */
+  depends(load: SvelteKitDepends, ...tables: readonly string[]): void;
+}
+/** SvelteKit integration: a `handle` hook, guarded loads and form actions. */
+export declare function createSvelteKit<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: SvelteKitOptions): BetterSvelteKit<M, F, E, C, P>;
+//#endregion
+export { type ActionResult, type AuthorizeOptions, type AuthorizedContext, type BetterSvelteKit, type BlockActionOptions, type BlockRequireOptions, type FrameworkLocals, type FrameworkOptions, type RefusalRedirects, type SvelteKitAppError, type SvelteKitDepends, type SvelteKitEvent, type SvelteKitFailure, type SvelteKitHandle, type SvelteKitHelpers, type SvelteKitOptions, type SvelteKitRequestEvent, tagFor };

package/dist/sveltekit/index.js

@@ -0,0 +1,106 @@
+import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { r as dbErrorOf } from "../errors-B11Duf73.js";
+import { o as toProblem } from "../problem-BreOl8b8.js";
+import { c as extendServer, n as flushEvents, s as createServer } from "../adapter-Bc1o3zyy.js";
+import { t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { r as tagFor } from "../tags-B99_U9Pp.js";
+import { i as requireCaller, o as runAction } from "../kit-Fm-Fv7q5.js";
+import { n as bufferInPlace, t as around } from "../shared-CBxosKK3.js";
+import { a as platformWaitUntil, i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-CONDyPYx.js";
+import { i as refusalTarget } from "../refusal-CeJWxmkH.js";
+//#region src/bridges/sveltekit.ts
+/**
+* Runs an entry array as a SvelteKit `handle` hook. Every contributed key
+* lands on `event.locals`, so loads, actions and endpoints read
+* `locals.db`; `event.platform.env` (Cloudflare) seeds `getEnv`. Declare
+* the keys in `App.Locals` with `BetterSupabaseContributions`.
+*
+* ```ts title="src/hooks.server.ts"
+* export const handle = toSvelteKit([withBetterSupabase(server)])
+* ```
+*
+* Compose it with other hooks through SvelteKit's `sequence`.
+*/
+function toSvelteKit(entries) {
+	const run = around(entries);
+	return ({ event, resolve }) => {
+		bufferInPlace(event.request);
+		return run(event.request, event.platform?.env, async (contributions) => {
+			Object.assign(event.locals, contributions);
+			return resolve(event);
+		});
+	};
+}
+//#endregion
+//#region src/sveltekit/create.ts
+/** SvelteKit integration: a `handle` hook, guarded loads and form actions. */
+function createSvelteKit(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const run = around([frameworkEntry(server, options, expose)]);
+	const localsFrom = (event) => {
+		const locals = event.locals;
+		if (!locals.bs) throw new TypeError("better-supabase: no context on event.locals; export handle = bs.handle from hooks.server.ts");
+		return locals;
+	};
+	const refuse = (error, request) => {
+		const target = refusalTarget(error, request, options);
+		if (options.kit) {
+			if (target) options.kit.redirect(303, target.pathname + target.search);
+			options.kit.error(error.status, { message: toProblem(error, { expose }).detail ?? error.message });
+		}
+		throw new DbException(error);
+	};
+	const handle = ({ event, resolve }) => {
+		bufferInPlace(event.request);
+		const platform = event.platform;
+		const env = event.platform?.env;
+		return run(event.request, env, async (contributions) => {
+			Object.assign(event.locals, localsOf(contributions));
+			const response = await resolve(event);
+			flushEvents(server, options.waitUntil ?? platformWaitUntil(platform));
+			return response;
+		});
+	};
+	return extendServer(server, {
+		Locals: void 0,
+		handle,
+		require: async (event, requireOptions = {}) => {
+			const locals = localsFrom(event);
+			const caller = await requireCaller(locals.bs.auth, requireOptions, locals.tenant);
+			if ("kind" in caller) return refuse(caller, event.request);
+			return {
+				...locals,
+				...caller
+			};
+		},
+		action(actionOptions, fn) {
+			return async (event) => {
+				const locals = localsFrom(event);
+				const input = await actionInput(event.request);
+				const result = await runAction(locals.bs.auth, actionOptions, input, locals.tenant, (parsed, caller) => fn(parsed, {
+					...locals,
+					...caller
+				}, event));
+				if (!result.ok && options.kit) return options.kit.fail(result.error.status, result);
+				return result;
+			};
+		},
+		handleError({ error }) {
+			const found = dbErrorOf(error);
+			if (found) {
+				const problem = toProblem(found, { expose });
+				return {
+					message: problem.detail ?? problem.title,
+					code: found.kind
+				};
+			}
+			return { message: expose && error instanceof Error ? error.message : "Internal Error" };
+		},
+		depends(load, ...tables) {
+			for (const table of tables) load.depends(`bs:${table}`);
+		}
+	});
+}
+//#endregion
+export { createSvelteKit, tagFor, toSvelteKit };

package/dist/tags-B99_U9Pp.js

@@ -0,0 +1,39 @@
+//#region src/core/tags.ts
+/**
+* `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read
+* scoped to one tenant. Mutations invalidate the table tag, the tag of their
+* tenant (`bs:<table>@*` without one) and the tags of the changed rows.
+*/
+function tagFor(table, id, options = {}) {
+	if (id !== void 0) return `bs:${table}:${String(id)}`;
+	return options.tenant === void 0 ? `bs:${table}` : `bs:${table}@${options.tenant}`;
+}
+/**
+* The tags a mutation invalidates: `bs:<table>` for every table in the
+* target, the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*`
+* when the mutation has no tenant) and `bs:<table>:<id>` per changed row.
+*/
+function cacheTagsOf(target) {
+	const tenant = { tenant: target.tenant ?? "*" };
+	const tags = [];
+	for (const table of target.tables) tags.push(tagFor(table), tagFor(table, void 0, tenant));
+	for (const id of target.ids) tags.push(tagFor(target.table, id));
+	return tags;
+}
+/**
+* A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags
+* from `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or
+* a Redis set of keys per tag. Tag your reads with `tagFor`.
+*
+* ```ts
+* betterSupabase.cache(tagCache((tags) => purgeCdn(tags), 'cdn'))
+* ```
+*/
+function tagCache(invalidate, name = "tags") {
+	return {
+		name,
+		invalidate: (target) => invalidate(cacheTagsOf(target))
+	};
+}
+//#endregion
+export { tagCache as n, tagFor as r, cacheTagsOf as t };

package/dist/tags-Cx-LnIQP.d.ts

@@ -0,0 +1,30 @@
+import { d as CacheTarget, u as CacheAdapter } from "./define-CJJkkr1-.js";
+//#region src/core/tags.d.ts
+interface TagOptions {
+  /** The tenant the read is scoped to; `"*"` is every tenant's reads. */
+  readonly tenant?: string;
+}
+/**
+ * `bs:<table>`, `bs:<table>:<id>`, or `bs:<table>@<tenant>` for a read
+ * scoped to one tenant. Mutations invalidate the table tag, the tag of their
+ * tenant (`bs:<table>@*` without one) and the tags of the changed rows.
+ */
+declare function tagFor(table: string, id?: string | number, options?: TagOptions): string;
+/**
+ * The tags a mutation invalidates: `bs:<table>` for every table in the
+ * target, the tenant's `bs:<table>@<tenant>` (every tenant's `bs:<table>@*`
+ * when the mutation has no tenant) and `bs:<table>:<id>` per changed row.
+ */
+declare function cacheTagsOf(target: CacheTarget): string[];
+/**
+ * A `CacheAdapter` for any tag-based cache: it hands `invalidate` the tags
+ * from `cacheTagsOf`, e.g. a CDN purge by tag, SvelteKit's `invalidate`, or
+ * a Redis set of keys per tag. Tag your reads with `tagFor`.
+ *
+ * ```ts
+ * betterSupabase.cache(tagCache((tags) => purgeCdn(tags), 'cdn'))
+ * ```
+ */
+declare function tagCache(invalidate: (tags: readonly string[]) => void | Promise<void>, name?: string): CacheAdapter;
+//#endregion
+export { tagFor as i, cacheTagsOf as n, tagCache as r, TagOptions as t };