better-supabase 0.14.0 → 0.15.1

package/dist/types-EO2crSX_.d.ts

@@ -0,0 +1,177 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CredentialRef, r as CredentialProvider } from "./provider-CqwEOLCA.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CRpAHrp_.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+//#region src/blocks/ai-keys/types.d.ts
+/**
+ * A tenant's own key for a provider. The key itself stays in the credential
+ * provider.
+ */
+interface AiProviderKey {
+  readonly id: string;
+  readonly organizationId: string;
+  /** The AI Gateway's provider slug, such as `anthropic` or `openai`. */
+  readonly provider: string;
+  /** Tells several keys of one provider apart; `default` unless named. */
+  readonly name: string;
+  readonly credentialRef: CredentialRef;
+  /** The provider's other options, such as a region; never a secret. */
+  readonly settings: Readonly<Record<string, unknown>>;
+  readonly enabled: boolean;
+  readonly createdBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface AiProviderKeyInput {
+  readonly provider: string;
+  /**
+   * Store the key first, for example with `vaultCredentials().set(ref,
+   * apiKey)`.
+   */
+  readonly credentialRef: CredentialRef;
+  readonly name?: string;
+  readonly settings?: Readonly<Record<string, unknown>>;
+  readonly enabled?: boolean;
+}
+/** A key resolved for one request. */
+interface ResolvedProviderKey {
+  readonly provider: string;
+  readonly name: string;
+  readonly token: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly settings: Readonly<Record<string, unknown>>;
+}
+type AiBatchStatus = "pending" | "completed" | "failed" | "cancelled";
+interface AiBatchCounts {
+  readonly total?: number;
+  readonly pending?: number;
+  readonly completed?: number;
+  readonly failed?: number;
+}
+interface AiBatch {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string | undefined;
+  readonly provider: string;
+  /** The SDK's batch reference, such as `{ version, id, provider }`. */
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly status: AiBatchStatus;
+  /** The provider's own status word. */
+  readonly rawStatus: string | undefined;
+  readonly itemCount: number;
+  readonly counts: AiBatchCounts;
+  readonly error: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** The results are in `items`. */
+  readonly resultsSaved: boolean;
+  readonly polls: number;
+  readonly nextPollAt: Temporal.Instant | undefined;
+  readonly expiresAt: Temporal.Instant | undefined;
+  readonly completedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface NewAiBatch {
+  readonly provider: string;
+  readonly reference: Readonly<Record<string, unknown>>;
+  readonly itemCount?: number;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /** Service role only: the user the batch is for. */
+  readonly userId?: string;
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly expiresAt?: Temporal.Instant;
+}
+interface AiBatchPatch {
+  readonly status?: AiBatchStatus;
+  readonly rawStatus?: string;
+  readonly counts?: AiBatchCounts;
+  readonly error?: string | null;
+  readonly expiresAt?: Temporal.Instant;
+  readonly resultsSaved?: boolean;
+  /** `null` stops polling. */
+  readonly nextPollAt?: Temporal.Instant | null;
+}
+type AiBatchItemStatus = "succeeded" | "failed" | "cancelled" | "expired";
+interface AiBatchItem {
+  readonly batchId: string;
+  readonly requestId: string;
+  readonly organizationId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output: unknown;
+  readonly usage: unknown;
+  readonly error: string | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface AiBatchItemInput {
+  readonly requestId: string;
+  readonly status: AiBatchItemStatus;
+  readonly output?: unknown;
+  readonly usage?: unknown;
+  readonly error?: string;
+}
+interface AiKeysOptions extends BlockTemporalOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiKeys>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** Calls as the service role, for resolving keys, polling and the idle stop. */
+  readonly service?: BlockTransport;
+  /** Resolves and revokes the keys' credential refs. */
+  readonly credentials?: CredentialProvider;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface AiKeys {
+  readonly keys: {
+    list(organizationId: string): AsyncResult<readonly AiProviderKey[]>;
+    /**
+     * Adds or replaces a key (`ai.admin`), and revokes the credential it
+     * replaced.
+     */
+    upsert(organizationId: string, key: AiProviderKeyInput): AsyncResult<AiProviderKey>;
+    /** Deletes a key and revokes its credential. `false` when there was none. */
+    remove(keyId: string): AsyncResult<boolean>;
+    /**
+     * Deletes every key of a tenant and revokes each credential (service role):
+     * the step to run when a tenant is deleted. Returns how many.
+     */
+    removeAll(organizationId: string): AsyncResult<number>;
+    /**
+     * The tenant's enabled keys with their tokens, for one request (service
+     * role).
+     */
+    resolve(organizationId: string, options?: {
+      readonly providers?: readonly string[];
+      readonly signal?: AbortSignal;
+    }): AsyncResult<readonly ResolvedProviderKey[]>;
+  };
+  readonly batches: {
+    record(organizationId: string, batch: NewAiBatch): AsyncResult<AiBatch>;
+    get(batchId: string): AsyncResult<AiBatch | undefined>;
+    list(organizationId: string, options?: {
+      readonly status?: AiBatchStatus;
+      readonly limit?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    items(batchId: string, options?: CursorPageOptions<string>): AsyncResult<readonly AiBatchItem[]>;
+    /** Claims batches to poll for `leaseSeconds` (service role). */
+    due(options?: {
+      readonly batch?: number;
+      readonly leaseSeconds?: number;
+    }): AsyncResult<readonly AiBatch[]>;
+    update(batchId: string, patch: AiBatchPatch): AsyncResult<AiBatch>;
+    saveItems(batchId: string, items: readonly AiBatchItemInput[]): AsyncResult<number>;
+  };
+}
+//#endregion
+export { AiBatchItemStatus as a, AiKeys as c, AiProviderKeyInput as d, NewAiBatch as f, AiBatchItemInput as i, AiKeysOptions as l, AiBatchCounts as n, AiBatchPatch as o, ResolvedProviderKey as p, AiBatchItem as r, AiBatchStatus as s, AiBatch as t, AiProviderKey as u };

package/dist/undo-B1jwnVyN.d.ts

@@ -0,0 +1,46 @@
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+//#region src/blocks/undo/undo.d.ts
+/** One call that reverses part of a change. */
+interface UndoCall {
+  readonly fn: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/**
+ * What a block method returns when its change has an inverse. It is plain JSON,
+ * so it can travel from a server action to a toast and back. Applying it runs
+ * the calls in order as the caller, so the same permission checks apply as for
+ * any other write.
+ */
+interface UndoToken {
+  readonly v: 1;
+  readonly calls: readonly UndoCall[];
+}
+/** The functions an undo token may call: the inverses the blocks return. */
+declare const UNDO_FUNCTIONS: readonly string[];
+declare function undoToken(calls: readonly UndoCall[]): UndoToken;
+/** Whether a value is an undo token whose calls are all allowed. */
+declare function isUndoToken(value: unknown, allowed?: readonly string[]): value is UndoToken;
+interface UndoOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** Extra functions a token may call, for an app's own inverses. */
+  readonly allow?: readonly string[];
+  /**
+   * `withBlockHooks` hooks around `apply`, such as a rule on which tokens a
+   * user may apply.
+   */
+  readonly hooks?: BlockHooks<Undo>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface Undo {
+  /** Runs a token's calls in order; stops at the first error. */
+  apply(token: unknown): AsyncResult<number>;
+}
+declare function createUndo(options: UndoOptions): Undo;
+//#endregion
+export { UndoToken as a, undoToken as c, UndoOptions as i, Undo as n, createUndo as o, UndoCall as r, isUndoToken as s, UNDO_FUNCTIONS as t };

package/dist/undo-BjCChCmH.js

@@ -0,0 +1,44 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as ok, t as AsyncResult } from "./result-ntFBW2p2.js";
+import { o as blockCall } from "./block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "./block-hooks-BfxX3682.js";
+//#region src/blocks/undo/undo.ts
+/** The functions an undo token may call: the inverses the blocks return. */
+const UNDO_FUNCTIONS = [
+	"link",
+	"unlink",
+	"revert_audit_entries"
+];
+function undoToken(calls) {
+	return {
+		v: 1,
+		calls
+	};
+}
+/** Whether a value is an undo token whose calls are all allowed. */
+function isUndoToken(value, allowed = UNDO_FUNCTIONS) {
+	return isRecord(value) && value["v"] === 1 && Array.isArray(value["calls"]) && value["calls"].length > 0 && value["calls"].every((call) => isRecord(call) && typeof call["fn"] === "string" && allowed.includes(call["fn"]) && isRecord(call["args"]));
+}
+function createUndo(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const allowed = [...UNDO_FUNCTIONS, ...options.allow ?? []];
+	return withBlockHooks({ apply: (token) => {
+		if (!isUndoToken(token, allowed)) return AsyncResult.err(dbError("validation", "not an undo token this app accepts", { issues: [{
+			message: "not an undo token this app accepts",
+			path: []
+		}] }));
+		return AsyncResult.from(async () => {
+			for (const step of token.calls) {
+				const result = await call(step.fn, step.args, () => void 0);
+				if (!result.ok) return result;
+			}
+			return ok(token.calls.length);
+		});
+	} }, options.hooks, {
+		block: "undo",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { undoToken as i, createUndo as n, isUndoToken as r, UNDO_FUNCTIONS as t };

package/dist/upload-claim-B1ZU8ydB.js

@@ -0,0 +1,33 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-ntFBW2p2.js";
+import { t as fromStorageError } from "./errors-CyxMxzlu.js";
+//#region src/blocks/upload-claim.ts
+function refusal(cause, hints) {
+	const error = fromStorageError(cause, "storage.objects");
+	if (error.kind === "not_found") return dbError("not_found", "The file was not uploaded yet", { hint: hints.notUploaded });
+	if (error.kind === "forbidden") return dbError("forbidden", error.message, {
+		hint: hints.forbidden,
+		...error.code === void 0 ? {} : { code: error.code }
+	});
+	return error;
+}
+/**
+* Claims an object a browser uploaded to a signed upload URL, so a support
+* session records it. Succeeds without a request when the storage has no claim
+* step.
+*/
+function claimUpload(storage, file, hints) {
+	return AsyncResult.from(async () => {
+		if (!storage.claimSignedUpload) return ok(void 0);
+		try {
+			const { error } = await storage.claimSignedUpload(file.bucket, file.path);
+			return error ? err(refusal(error, hints)) : ok(void 0);
+		} catch (cause) {
+			return err(refusal(cause, hints));
+		}
+	});
+}
+/** Whether `storage` has a claim step, so a block needs the file's path first. */
+const claimsUploads = (storage) => storage.claimSignedUpload !== void 0;
+//#endregion
+export { claimsUploads as n, claimUpload as t };

package/dist/usage-Dp45V42p.d.ts

@@ -0,0 +1,232 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-DZeA5KS6.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { i as CursorPageOptions, n as BlockOptions } from "./block-helpers-CRpAHrp_.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+import { g as JobHandler } from "./types-Czq9Xtpa.js";
+import { n as StripeSource } from "./stripe-X22LjuH-.js";
+//#region src/blocks/usage/usage.d.ts
+interface UsageOptions extends BlockOptions {
+  /**
+   * `withBlockHooks` hooks around the client's methods, such as a check before
+   * `consume`.
+   */
+  readonly hooks?: BlockHooks<Usage>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface RecordUsageOptions {
+  /** Default 1. */
+  readonly quantity?: number;
+  /** A retried call with the same key counts once. */
+  readonly idempotencyKey?: string;
+  /**
+   * What used it, such as `feature:summary` or `api:/v1/search`, kept in the
+   * history with `blocks.usage.options.history`.
+   */
+  readonly source?: string;
+  /** More detail for the history entry, such as a document id. */
+  readonly metadata?: Readonly<Record<string, unknown>>;
+  /**
+   * Who used it, for a service transport recording on a user's behalf. Ignored
+   * for other callers, whose own user id is recorded.
+   */
+  readonly actor?: string;
+}
+/** One meter of a batch. */
+interface UsageEntry {
+  readonly meter: string;
+  /** Default 1. */
+  readonly quantity?: number;
+}
+interface UsageBatchRecorded {
+  /** False when the idempotency key was seen before for every meter. */
+  readonly recorded: boolean;
+  /** Today's usage per meter (UTC). */
+  readonly today: Readonly<Record<string, number>>;
+  /** Usage per meter in its quota's current period, as `current()` reports it. */
+  readonly used: Readonly<Record<string, number>>;
+}
+/** One entry of the usage history. */
+interface UsageHistoryEntry {
+  readonly id: number;
+  readonly meter: string;
+  readonly quantity: number;
+  /** The user who used it, or `undefined` for service usage without one. */
+  readonly actor: string | undefined;
+  readonly source: string | undefined;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly recordedAt: Temporal.Instant;
+}
+/** Usage of a meter in its current window per actor and source. */
+interface UsageBreakdownEntry {
+  readonly actor: string | undefined;
+  readonly source: string | undefined;
+  readonly quantity: number;
+}
+interface UsageHistoryOptions extends CursorPageOptions<number> {
+  readonly meter?: string;
+  /** Defaults to 100, at most 1000. */
+  readonly limit?: number;
+  /** Only entries with a lower id, for the next page. */
+  readonly cursor?: number;
+}
+interface UsageRecorded {
+  /** False when the idempotency key was seen before. */
+  readonly recorded: boolean;
+  /** Today's usage of the meter (UTC). */
+  readonly today: number;
+  /** Usage in the quota's current period, as `current()` reports it. */
+  readonly used: number;
+}
+/**
+ * A quota period: a UTC calendar period, or `billing` for the window the app's
+ * `usage_billing_period(tenant)` function returns.
+ */
+type UsagePeriod = "day" | "week" | "month" | "year" | "billing";
+/** One meter of `blocks.usage.options.meters`. */
+interface UsageMeterInfo {
+  readonly unit?: string;
+  readonly category?: string;
+  readonly label?: string;
+  /** `counter` when the catalog gives no kind. */
+  readonly kind?: "counter" | "distinct" | "computed";
+  /** The window a distinct or computed meter measures. */
+  readonly period?: UsagePeriod;
+}
+interface UsageStatus {
+  readonly meter: string;
+  /** Usage in the current period. */
+  readonly used: number;
+  /** `undefined` without a quota and for an unlimited one. */
+  readonly limit: number | undefined;
+  readonly remaining: number | undefined;
+  readonly unlimited: boolean;
+  readonly period: UsagePeriod;
+  /** When the current period started. */
+  readonly startsAt: Temporal.Instant | undefined;
+  readonly resetsAt: Temporal.Instant;
+  /** From the meter catalog, when the module has one. */
+  readonly unit?: string;
+  readonly category?: string;
+  readonly label?: string;
+}
+interface Usage {
+  /** Adds usage without checking the quota (metering only). */
+  record(organizationId: string, meter: string, options?: RecordUsageOptions): AsyncResult<UsageRecorded>;
+  /**
+   * Counts `subject` once in the current period of a `distinct` meter (active
+   * users, say). Repeating a subject changes nothing, and quotas and Stripe
+   * reporting read the meter like a counter.
+   */
+  track(organizationId: string, meter: string, subject: string, options?: {
+    readonly period?: UsagePeriod;
+  }): AsyncResult<UsageRecorded>;
+  /**
+   * Recomputes `computed` meters from their query for every tenant it returns,
+   * or for one meter. Service role only; returns the rows written. The
+   * migration schedules it hourly when pg_cron is installed.
+   */
+  refresh(meter?: string): AsyncResult<number>;
+  /** Adds usage when it fits the quota, or returns `quota_exceeded`. */
+  consume(organizationId: string, meter: string, options?: RecordUsageOptions): AsyncResult<UsageRecorded>;
+  /**
+   * Adds several meters in one transaction, all or none, such as input and
+   * output tokens of one call. The idempotency key covers the batch.
+   */
+  recordMany(organizationId: string, entries: readonly UsageEntry[], options?: Omit<RecordUsageOptions, "quantity">): AsyncResult<UsageBatchRecorded>;
+  /**
+   * Like `recordMany`, but checks each meter's quota first; when one doesn't
+   * fit, nothing is recorded and the result is `quota_exceeded`.
+   */
+  consumeMany(organizationId: string, entries: readonly UsageEntry[], options?: Omit<RecordUsageOptions, "quantity">): AsyncResult<UsageBatchRecorded>;
+  current(organizationId: string, meter: string): AsyncResult<UsageStatus>;
+  overview(organizationId: string): AsyncResult<readonly UsageStatus[]>;
+  /** Units left in the period, or `undefined` without a quota. */
+  remaining(organizationId: string, meter: string): AsyncResult<number | undefined>;
+  /** The meter catalog (`options.meters`), empty without one. */
+  meters(): AsyncResult<Readonly<Record<string, UsageMeterInfo>>>;
+  /**
+   * The tenant's usage entries, newest first, with who and what used each
+   * (`usage.read`). Empty without `blocks.usage.options.history`.
+   */
+  history(organizationId: string, options?: UsageHistoryOptions): AsyncResult<readonly UsageHistoryEntry[]>;
+  /**
+   * The meter's usage in its current quota window per actor and source, largest
+   * first (`usage.read`). Empty without the history option.
+   */
+  breakdown(organizationId: string, meter: string): AsyncResult<readonly UsageBreakdownEntry[]>;
+  /**
+   * Deletes up to `batch` history entries older than `olderThan` (default 400
+   * days, `purge_usage_history`); returns how many.
+   */
+  purgeHistory(options?: PurgeUsageOptions): AsyncResult<number>;
+  /**
+   * Deletes up to `batch` idempotency keys of recorded usage older than
+   * `olderThan` (default 30 days, `purge_usage_events`); returns how many. A
+   * retry with a purged key records again.
+   */
+  purgeEvents(options?: PurgeUsageOptions): AsyncResult<number>;
+  /**
+   * A job handler that runs `purgeHistory` and `purgeEvents`; schedule it
+   * nightly.
+   */
+  purgeJob(options?: {
+    readonly history?: PurgeUsageOptions;
+    readonly events?: PurgeUsageOptions;
+  }): JobHandler<unknown>;
+}
+interface PurgeUsageOptions {
+  /** Seconds, or an interval such as `"90 days"`. */
+  readonly olderThan?: number | string;
+  /** Defaults to 10000. */
+  readonly batch?: number;
+}
+/** Usage metering and quotas over the `usage` module's functions. */
+declare function createUsage(options: UsageOptions): Usage;
+interface ReportUsageOptions {
+  /**
+   * A service-role transport: the reporting functions are granted to
+   * `service_role` only.
+   */
+  readonly transport: BlockTransport;
+  readonly stripe: StripeSource;
+  readonly schema?: string;
+  /** The Stripe meter's `event_name` for a meter; default the meter itself. */
+  readonly eventName?: (meter: string) => string | undefined;
+  /**
+   * The tenant's Stripe customer. Default: `tenant_stripe_customer()` from the
+   * `entitlements` module (`config.entitlements.customer`).
+   */
+  readonly customer?: (organizationId: string) => Promise<string | undefined>;
+  /** Counters per run, default 500. */
+  readonly batch?: number;
+  /**
+   * Send only the usage above the tenant's quota (the allowance its plan
+   * includes) in each quota window, instead of every unit. A meter without a
+   * quota sends everything, and one with an unlimited quota sends nothing.
+   */
+  readonly overage?: boolean;
+}
+interface ReportUsageResult {
+  /**
+   * Meter events sent; usage inside the quota with `overage` is marked without
+   * one.
+   */
+  readonly reported: number;
+  /**
+   * Counters left for a later run: no customer, or no event name. They don't
+   * hold up the other counters of the batch.
+   */
+  readonly skipped: number;
+}
+/**
+ * Sends unreported usage to Stripe as meter events, one per counter and delta.
+ * The event `identifier` is the tenant, meter, day and new total, so a run that
+ * fails after sending and before marking resends the same event, and Stripe
+ * drops the duplicate. Run it from a job or a cron route.
+ */
+declare function reportUsageToStripe(options: ReportUsageOptions): Promise<ReportUsageResult>;
+//#endregion
+export { reportUsageToStripe as _, Usage as a, UsageEntry as c, UsageMeterInfo as d, UsageOptions as f, createUsage as g, UsageStatus as h, ReportUsageResult as i, UsageHistoryEntry as l, UsageRecorded as m, RecordUsageOptions as n, UsageBatchRecorded as o, UsagePeriod as p, ReportUsageOptions as r, UsageBreakdownEntry as s, PurgeUsageOptions as t, UsageHistoryOptions as u };

package/dist/user-change-DgWC6RRC.js

@@ -0,0 +1,135 @@
+//#region src/query/invalidate.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function queryTables(query) {
+	const tables = query.meta?.["bsTables"];
+	if (Array.isArray(tables)) {
+		const list = tables;
+		return list.every(isString) ? list : list.filter(isString);
+	}
+	const [prefix, table] = query.queryKey;
+	return prefix === "bsb" && typeof table === "string" ? [table] : void 0;
+}
+const indexes = /* @__PURE__ */ new WeakMap();
+function indexOf(cache) {
+	const existing = indexes.get(cache);
+	if (existing) return existing;
+	const index = {
+		byTable: /* @__PURE__ */ new Map(),
+		tablesOf: /* @__PURE__ */ new Map()
+	};
+	const remove = (hash) => {
+		for (const table of index.tablesOf.get(hash) ?? []) {
+			const set = index.byTable.get(table);
+			set?.delete(hash);
+			if (set?.size === 0) index.byTable.delete(table);
+		}
+		index.tablesOf.delete(hash);
+	};
+	const add = (hash) => {
+		const query = cache.get(hash);
+		const tables = query ? queryTables(query) : void 0;
+		const known = index.tablesOf.get(hash);
+		if (known !== void 0 && tables !== void 0 && known.length === tables.length && known.every((table, at) => table === tables[at])) return;
+		remove(hash);
+		if (!tables || tables.length === 0) return;
+		index.tablesOf.set(hash, tables);
+		for (const table of tables) {
+			let set = index.byTable.get(table);
+			if (!set) index.byTable.set(table, set = /* @__PURE__ */ new Set());
+			set.add(hash);
+		}
+	};
+	for (const query of cache.getAll()) add(query.queryHash);
+	cache.subscribe((event) => {
+		const hash = event.query.queryHash;
+		if (event.type === "removed") remove(hash);
+		else if (event.type === "added" || event.type === "observerAdded" || event.type === "observerOptionsUpdated" || event.type === "updated" && event.action.type === "fetch") add(hash);
+	});
+	indexes.set(cache, index);
+	return index;
+}
+/**
+* Invalidates every query that read one of `tables` or block instances: tables
+* and instances share the key space `['bsb', name, method, ...args]`, so
+* better-supabase queries match by their `meta.bsTables` and other `['bsb',
+* name, ...]` keys by prefix. `methods` narrows it to the queries of those
+* methods. An index from name to queries finds them, so a write nothing read
+* skips the cache scan.
+*/
+function invalidateTables(client, tables, methods) {
+	if (tables.length === 0) return Promise.resolve();
+	const { byTable } = indexOf(client.getQueryCache());
+	const matched = /* @__PURE__ */ new Set();
+	for (const table of tables) for (const hash of byTable.get(table) ?? []) matched.add(hash);
+	if (matched.size === 0) return Promise.resolve();
+	return client.invalidateQueries({ predicate: (query) => matched.has(query.queryHash) && (methods === void 0 || methods.has(String(query.queryKey[2]))) });
+}
+//#endregion
+//#region src/query/user-change.ts
+/**
+* Claims every refresh changes; the rest says who the caller is and what RLS
+* lets them read.
+*/
+const TIME_CLAIMS = /* @__PURE__ */ new Set([
+	"exp",
+	"iat",
+	"nbf",
+	"jti"
+]);
+/**
+* The user plus every claim except the time claims, so a token refresh keeps
+* the identity and an organization switch, a role change or a second factor (a
+* new `tenant_id`, `role` or `aal`) changes it.
+*/
+function identityKey(snapshot) {
+	if (!snapshot.user) return null;
+	const claims = Object.entries(snapshot.claims ?? {}).filter(([key]) => !TIME_CLAIMS.has(key)).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return JSON.stringify([snapshot.user.id, claims]);
+}
+/**
+* Resets every `['bsb', ...]` query when the caller changes: another user,
+* signing out, or new claims for the same user (an organization switch, a role
+* change). Mounted queries refetch, so no one sees the previous identity's
+* rows. Returns the function that stops listening. `BetterSupabaseProvider`
+* calls it for React; call it yourself with Vue, Solid, Svelte or Angular
+* Query.
+*
+* Queries that fetched while the session was still loading ran as anon, so they
+* are reset when a user arrives. Data already in the cache when loading started
+* (hydrated from the server) stays.
+*
+* ```ts
+* const stop = clearOnUserChange(queryClient, bsb.auth);
+* ```
+*/
+function clearOnUserChange(queryClient, auth) {
+	let identity;
+	let before;
+	const bsQueries = () => queryClient.getQueryCache().findAll({ queryKey: ["bsb"] });
+	const check = () => {
+		const snapshot = auth.current();
+		if (snapshot.status === "loading") {
+			before ??= new Map(bsQueries().map((query) => [query.queryHash, query.state.dataUpdatedAt]));
+			return;
+		}
+		const next = identityKey(snapshot);
+		if (identity !== void 0 && identity !== next) queryClient.resetQueries({ queryKey: ["bsb"] });
+		else if (identity === void 0 && next !== null && before) {
+			const known = before;
+			const fetchedAsAnon = new Set(bsQueries().filter((query) => query.state.dataUpdatedAt > 0 && known.get(query.queryHash) !== query.state.dataUpdatedAt).map((query) => query.queryHash));
+			if (fetchedAsAnon.size > 0) queryClient.resetQueries({
+				queryKey: ["bsb"],
+				predicate: (query) => fetchedAsAnon.has(query.queryHash)
+			});
+		}
+		before = void 0;
+		identity = next;
+	};
+	const stop = auth.subscribe(check);
+	check();
+	return stop;
+}
+//#endregion
+export { identityKey as n, invalidateTables as r, clearOnUserChange as t };