better-supabase 0.5.1 → 0.6.0

package/dist/cli/sql-CVx-1O8G.js

@@ -1,373 +0,0 @@
-import { r as defineCliCommand } from "./command-CK14fP91.js";
-import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
-import { i as plain, r as painter } from "./style-C0NFdJRL.js";
-import { f as readSupabaseToml, p as schemaPaths, u as migrationCommand } from "./config-CPVpXP5I.js";
-import { t as fileDiff } from "./diff-SjkO5rNr.js";
-import { a as entitlementsMode, l as permdockSource, n as accessPermdockMode, o as kitKeyProblems, t as compiledReadSets, u as readPermdock } from "./read-sets-VQcPgxU9.js";
-import { dirname, join, relative, resolve, sep } from "node:path";
-import { existsSync } from "node:fs";
-import { readFile, readdir } from "node:fs/promises";
-import { SQL_MODULES, contractSignature, customContracts, kitFilePaths, kitFileVersion, kitLayout, kitPermissionKeys, moduleBody, renderKit, resolveModules, sameKitFile, upgradePlan } from "better-supabase/sql";
-//#region src/cli/commands/sql.ts
-const SQL_ARGS = {
-	action: {
-		type: "positional",
-		required: false,
-		description: "list (modules and whether they are installed), add <module...>, sync, upgrade, data (a migration with the rows a schema diff skips) or print <module>"
-	},
-	check: {
-		type: "boolean",
-		description: "With sync: fail when a file is stale. With upgrade: fail when a module is behind"
-	},
-	"tests-dir": {
-		type: "string",
-		description: "Where the pgtap module goes. Defaults to sql.testsDir",
-		valueHint: "dir"
-	},
-	"dry-run": {
-		type: "boolean",
-		description: "Show what would be written"
-	},
-	force: {
-		type: "boolean",
-		description: "Write tenant even though a permdock.config.ts is present"
-	}
-};
-const USAGE = "Run `better-supabase sql --help` for the actions.";
-/** Modules that fill a claim PermDock's hook also writes (`memberships`). */
-const PERMDOCK_OWNED = /* @__PURE__ */ new Set(["tenant"]);
-/**
-* PermDock's helpers for the `entitlements` module. When `names` resolve to
-* that module, an invalid PermDock mode (no manifest, a scope it lacks, an
-* unknown id type) throws instead of falling back to the tenant module.
-* Without `names` (`sql list`) it only describes the modules, so it doesn't.
-*/
-async function permdockFor(config, names) {
-	const mode = entitlementsMode(config, await readPermdock(config.root, config.permdock));
-	switch (mode.kind) {
-		case "tenant": return;
-		case "permdock": return mode.permdock;
-		case "invalid":
-			if (names === void 0 || !resolveModules(names, {}).some((module) => module.name === "entitlements")) return void 0;
-			throw new TypeError(mode.problem);
-		default: return mode;
-	}
-}
-/**
-* PermDock's helpers for the `access` module's `permdock` model, read from
-* the manifest whatever `entitlements` says. When `names` resolve to
-* `access`, an invalid mode throws, and so does a kit permission key the
-* catalog doesn't mark `rowConditions: false`. `sql list` (no `names`)
-* doesn't render, so it doesn't throw.
-*/
-async function accessPermdockFor(config, names) {
-	const project = await readPermdock(config.root, config.permdock);
-	const mode = accessPermdockMode(config, project);
-	const renders = names !== void 0 && resolveModules(names, {}).some((module) => module.name === "access");
-	switch (mode.kind) {
-		case "off": return;
-		case "permdock": {
-			if (!renders || !project) return mode.access;
-			const problems = kitKeyProblems(project, kitPermissionKeys(config.kits, names), mode.access);
-			if (problems.length > 0) throw new TypeError(problems.map((problem) => problem.message).join("\n"));
-			return mode.access;
-		}
-		case "invalid":
-			if (!renders) return void 0;
-			throw new TypeError(mode.problem);
-		default: return mode;
-	}
-}
-async function layout(config, args, names) {
-	return kitLayout(config, args["tests-dir"], [], await permdockFor(config, names), await accessPermdockFor(config, names));
-}
-/** The layout, with `config.readSets` compiled when `names` includes `read-sets`. */
-async function layoutFor(config, args, names) {
-	const permdock = await permdockFor(config, names);
-	const needsReadSets = resolveModules(names, { ...permdock ? { permdock } : {} }).some((module) => module.name === "read-sets");
-	return kitLayout(config, args["tests-dir"], needsReadSets ? await compiledReadSets(config) : [], permdock, await accessPermdockFor(config, names));
-}
-/**
-* The migrations folder next to the `config.toml` found walking up from
-* `sql.dir`, relative to the root; `supabase/migrations` without one. The
-* walk stops where `sql.dir` and the root meet, so a `sql.dir` outside the
-* project (a shared stack in a monorepo) finds that stack's folder.
-*/
-function migrationsDir(config) {
-	const root = resolve(config.root);
-	let dir = resolve(root, config.sql.dir);
-	let stop = root;
-	while (dir !== stop && !dir.startsWith(stop + sep) && dirname(stop) !== stop) stop = dirname(stop);
-	for (;;) {
-		if (existsSync(join(dir, "config.toml"))) return relative(root, join(dir, "migrations")).replaceAll("\\", "/");
-		if (dir === stop || dirname(dir) === dir) break;
-		dir = dirname(dir);
-	}
-	return "supabase/migrations";
-}
-/** `YYYYMMDDHHMMSS` in UTC, the Supabase CLI's migration prefix. */
-const migrationStamp = (now) => now.toISOString().replaceAll(/[-:T]/g, "").slice(0, 14);
-/**
-* A stamp for `now`, or one second after the newest migration when that one
-* has the same stamp or a later one: the Supabase CLI keys migrations by
-* stamp, and the data has to run after the schema.
-*/
-function stampAfter(migrations, now) {
-	const newest = migrations.map((name) => /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})_/.exec(name)).filter((match) => match !== null).map((match) => Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6]))).reduce((max, time) => Math.max(max, time), Number.NEGATIVE_INFINITY);
-	const at = Math.floor(now.getTime() / 1e3) * 1e3;
-	return migrationStamp(new Date(Math.max(at, newest + 1e3)));
-}
-async function write(config, args, names, kit) {
-	const lines = [];
-	const dryRun = args["dry-run"] === true;
-	let data = false;
-	for (const file of renderKit(names, kit)) {
-		const path = resolve(config.root, file.path);
-		const shown = display(config.root, file.path);
-		if (dryRun) {
-			lines.push(`Would write ${shown} (${file.module})`);
-			continue;
-		}
-		const wrote = await writeIfChanged(path, file.contents);
-		if (wrote && file.kind === "data") data = true;
-		lines.push(`${wrote ? "Wrote" : "Unchanged"} ${shown} (${file.module})`);
-	}
-	if (data) lines.push("", DATA_NEXT);
-	return lines;
-}
-const DATA_NEXT = "The better-supabase-data files hold rows and settings a schema diff skips: after the schema migration, run `better-supabase sql data`.";
-const DATA_SUFFIX = "_better_supabase_kit_data.sql";
-/**
-* Writes the data files of `sql.kit` into one migration, meant to run after
-* the schema migration that creates their tables. Every statement is
-* idempotent, so the migration carries all of them, not only the changes.
-*/
-async function dataMigration(config, args) {
-	if (config.sql.kit.length === 0) return {
-		code: 0,
-		output: "sql.kit is empty; nothing to write."
-	};
-	const files = renderKit(config.sql.kit, await layoutFor(config, args, config.sql.kit)).filter((file) => file.kind === "data");
-	const contents = `-- better-supabase sql data: the rows and settings of ${files.map((file) => file.module).join(", ")}, which a schema diff skips.\n\n${files.map((file) => file.contents.trim()).join("\n\n")}\n`;
-	const dir = migrationsDir(config);
-	const existing = await readdir(resolve(config.root, dir)).catch(() => []);
-	const latest = existing.toSorted().findLast((name) => name.endsWith(DATA_SUFFIX));
-	if (latest !== void 0 && await readFile(resolve(config.root, dir, latest), "utf8") === contents) return {
-		code: 0,
-		output: `${dir}/${latest} already has these rows; nothing to write.`
-	};
-	const path = `${dir}/${stampAfter(existing, /* @__PURE__ */ new Date())}${DATA_SUFFIX}`;
-	if (args["dry-run"] === true) return {
-		code: 0,
-		output: `Would write ${path}`
-	};
-	await writeIfChanged(resolve(config.root, path), contents);
-	return {
-		code: 0,
-		output: `Wrote ${path}`
-	};
-}
-/** A note when migra's `schema_paths` is set and misses kit files, which `supabase db diff` would then skip. */
-async function unlistedKitFiles(config, names, kit) {
-	const order = await schemaPaths(config.root, await readSupabaseToml(config.root));
-	if (!order.configured) return [];
-	const unlisted = new Set(order.unlisted);
-	const listed = new Set(order.files.filter((path) => !unlisted.has(path)));
-	const dir = `${config.sql.dir.replace(/\/$/, "")}/`;
-	const missing = renderKit(names, kit).filter((file) => file.kind !== "data").map((file) => file.path).filter((path) => path.startsWith(dir) && !listed.has(path));
-	if (missing.length === 0) return [];
-	return [
-		"",
-		"supabase/config.toml sets [db.migrations] schema_paths, and no entry matches these files, so `supabase db diff` skips them.",
-		"Add them before the schemas that call their functions:",
-		...missing.map((path) => `  "./${path.startsWith("supabase/") ? path.slice(9) : path}",`)
-	];
-}
-/**
-* Rewrites the kit files of modules behind the current version, and writes
-* their upgrade steps (renames, backfills) as a migration that runs before
-* the one the schema diff creates.
-*/
-async function upgrade(config, args, paint) {
-	if (config.sql.kit.length === 0) return {
-		code: 0,
-		output: "sql.kit is empty; nothing to upgrade."
-	};
-	const kit = await layoutFor(config, args, config.sql.kit);
-	const files = renderKit(config.sql.kit, kit);
-	const installed = [];
-	const stale = [];
-	const diffs = [];
-	for (const file of files) {
-		if (file.kind === "data") continue;
-		const current = await readFile(resolve(config.root, file.path), "utf8").catch(() => void 0);
-		if (current === void 0) continue;
-		installed.push({
-			module: file.module,
-			version: kitFileVersion(current)?.version ?? 1
-		});
-		if (!sameKitFile(current, file.contents)) {
-			stale.push(file);
-			diffs.push(fileDiff(display(config.root, file.path), current, file.contents, paint));
-		}
-	}
-	const plan = upgradePlan(installed, kit);
-	const behind = plan.map((entry) => `${entry.module} is at version ${String(entry.from)}; the current version is ${String(entry.to)}`);
-	if (args.check === true) {
-		if (plan.length === 0 && stale.length === 0) return {
-			code: 0,
-			output: "SQL kit modules are at their current versions."
-		};
-		return {
-			code: 1,
-			output: diffs.join("\n\n"),
-			error: [
-				...behind,
-				...stale.length > 0 ? [`Out of date: ${stale.map((file) => display(config.root, file.path)).join(", ")}.`] : [],
-				"Run `better-supabase sql upgrade`."
-			].join("\n")
-		};
-	}
-	if (plan.length === 0 && stale.length === 0) return {
-		code: 0,
-		output: "SQL kit modules are at their current versions."
-	};
-	const lines = [];
-	const steps = plan.flatMap((entry) => entry.steps.filter((step) => step.sql !== "").map((step) => `-- ${entry.module}: version ${String(step.from)} to ${String(step.from + 1)}. ${step.description}\n${step.sql}`));
-	const dryRun = args["dry-run"] === true;
-	if (steps.length > 0) {
-		const path = `${migrationsDir(config)}/${migrationStamp(/* @__PURE__ */ new Date())}_better_supabase_kit_upgrade.sql`;
-		const contents = `-- better-supabase sql upgrade: steps that run before the schema diff.\n\n${steps.join("\n\n")}\n`;
-		if (dryRun) lines.push(`Would write ${path}`);
-		else {
-			await writeIfChanged(resolve(config.root, path), contents);
-			lines.push(`Wrote ${path}`);
-		}
-	}
-	for (const entry of plan) lines.push(`${entry.module}: version ${String(entry.from)} to ${String(entry.to)}`, ...entry.steps.map((step) => `  ${step.description}`));
-	lines.push(...await write(config, args, config.sql.kit, kit), "", `Then create a migration: ${migrationCommand(await readSupabaseToml(config.root), "better_supabase_kit")}`);
-	return {
-		code: 0,
-		output: lines.join("\n")
-	};
-}
-async function runSql(config, args, paint = plain) {
-	const [action, ...names] = args._;
-	switch (action) {
-		case "list": {
-			const kit = await layout(config, args);
-			const files = kitFilePaths(Object.keys(SQL_MODULES), kit);
-			return {
-				code: 0,
-				output: `${Object.values(SQL_MODULES).map((module) => {
-					const path = files.get(module.name);
-					const installed = path !== void 0 && existsSync(resolve(config.root, path));
-					const tracked = config.sql.kit.includes(module.name);
-					const mark = path === void 0 ? "◇" : installed ? tracked ? "●" : "○" : " ";
-					const requires = kit.permdock && module.permdockRequires ? module.permdockRequires : module.requires;
-					const needs = requires.length > 0 ? ` (needs ${requires.join(", ")})` : "";
-					return `${mark} ${module.name.padEnd(15)} ${module.description}${needs}`;
-				}).join("\n")}\n\n● installed and in sql.kit   ○ installed, not in sql.kit   ◇ custom mode (the app implements it)`
-			};
-		}
-		case "add": {
-			if (names.length === 0) return {
-				code: 2,
-				error: `Name at least one module.\n${USAGE}`
-			};
-			const unknown = names.filter((name) => !(name in SQL_MODULES));
-			if (unknown.length > 0) return {
-				code: 2,
-				error: `Unknown module ${unknown.join(", ")}. Available: ${Object.keys(SQL_MODULES).join(", ")}`
-			};
-			const project = await readPermdock(config.root, config.permdock);
-			const permdock = project ? permdockSource(project) : void 0;
-			const hookModules = names.filter((name) => PERMDOCK_OWNED.has(name));
-			if (permdock && hookModules.length > 0 && args.force !== true) return {
-				code: 1,
-				error: [
-					`${permdock} is present, so PermDock owns the access token hook and the memberships claim.`,
-					`${hookModules.join(" and ")} would add a second source for them. Use \`permdock supabase hook generate\` instead,`,
-					"or pass --force to write the modules anyway."
-				].join("\n")
-			};
-			const kit = await layoutFor(config, args, names);
-			const lines = await write(config, args, names, kit);
-			const pulledIn = resolveModules(names, kit).map((module) => module.name).filter((name) => PERMDOCK_OWNED.has(name) && !names.includes(name));
-			if (permdock && pulledIn.length > 0) lines.push("", `${pulledIn.join(" and ")} came along as a dependency: its memberships table backs has_org_role() and has_entitlement().`, `PermDock's hook still owns the memberships claim, so don't call better_supabase.membership_claims from a hook.`, "List better_supabase.memberships as a PermDock membership source if both should agree.");
-			const untracked = resolveModules(names, kit).map((module) => module.name).filter((name) => !config.sql.kit.includes(name));
-			if (untracked.length > 0) lines.push("", `Add them to your config so \`sql sync --check\` keeps them current:`, `  sql: { kit: [${[...config.sql.kit, ...untracked].map((name) => `'${name}'`).join(", ")}] }`);
-			if (args["dry-run"] !== true) lines.push(...await unlistedKitFiles(config, names, kit));
-			lines.push("", `Then create a migration: ${migrationCommand(await readSupabaseToml(config.root), "better_supabase_kit")}`);
-			return {
-				code: 0,
-				output: lines.join("\n")
-			};
-		}
-		case "sync": {
-			if (config.sql.kit.length === 0) return {
-				code: 0,
-				output: "sql.kit is empty; nothing to sync."
-			};
-			if (args.check !== true) return {
-				code: 0,
-				output: (await write(config, args, config.sql.kit, await layoutFor(config, args, config.sql.kit))).join("\n")
-			};
-			const stale = [];
-			const diffs = [];
-			for (const file of renderKit(config.sql.kit, await layoutFor(config, args, config.sql.kit))) {
-				const current = await readFile(resolve(config.root, file.path), "utf8").catch(() => void 0);
-				if (!sameKitFile(current, file.contents)) {
-					const shown = display(config.root, file.path);
-					stale.push(shown);
-					diffs.push(fileDiff(shown, current, file.contents, paint));
-				}
-			}
-			return stale.length === 0 ? {
-				code: 0,
-				output: "SQL kit files are up to date."
-			} : {
-				code: 1,
-				output: diffs.join("\n\n"),
-				error: `Out of date: ${stale.join(", ")}. Run \`better-supabase sql sync\`.`
-			};
-		}
-		case "upgrade": return upgrade(config, args, paint);
-		case "data": return dataMigration(config, args);
-		case "print": {
-			const [name] = names;
-			const module = name ? SQL_MODULES[name] : void 0;
-			if (!module) return {
-				code: 2,
-				error: `Name one module: ${Object.keys(SQL_MODULES).join(", ")}`
-			};
-			const body = moduleBody(module.name, await layout(config, args, [module.name]));
-			if (body === void 0) return {
-				code: 0,
-				output: `-- kits.${module.name} is in custom mode: the app writes these functions.\n${customContracts([module.name], await layout(config, args, [module.name])).flatMap((contract) => contract.functions.map((fn) => `-- ${contract.schema}.${fn.name}(${contractSignature(fn, contract.idType)}) returns ${fn.returns.replaceAll("{id}", contract.idType)}`)).join("\n")}`
-			};
-			return {
-				code: 0,
-				output: body
-			};
-		}
-		case void 0: return {
-			code: 2,
-			error: `Name an action.\n${USAGE}`
-		};
-		default: return {
-			code: 2,
-			error: `Unknown sql action "${action}".\n${USAGE}`
-		};
-	}
-}
-const sqlCommand = defineCliCommand({
-	meta: {
-		name: "sql",
-		description: "Lists, adds, syncs, upgrades and prints SQL kit modules, and writes their data migration"
-	},
-	args: SQL_ARGS,
-	run: (args, { config, io }) => runSql(config, args, painter(io.color))
-});
-//#endregion
-export { sqlCommand };

package/dist/entitlements-CTEBm7IB.js

@@ -1,20 +0,0 @@
-//#region src/auth/entitlements.ts
-/**
-* Whether the session's plan-features claim grants `key` in `tenantId`.
-* `claim` is `config.claims.features` (default `features`), the claim
-* `better_supabase.feature_claims()` fills. The claim is as fresh as the
-* token: enforce it in RLS with `better_supabase.has_entitlement()`, and
-* refresh the session after checkout.
-*/
-function hasEntitlement(session, tenantId, key, claim = "features") {
-	if (session.kind !== "user") return false;
-	const claims = session.claims;
-	if (!isRecord(claims)) return false;
-	const features = claims[claim];
-	if (!isRecord(features) || !Object.hasOwn(features, tenantId)) return false;
-	const keys = features[tenantId];
-	return Array.isArray(keys) && keys.includes(key);
-}
-const isRecord = (value) => typeof value === "object" && value !== null;
-//#endregion
-export { hasEntitlement as t };

package/dist/events-aIO7vsIk.d.ts

@@ -1,230 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { U as Operation, _ as DbError } from "./executor-BunPOO-k.js";
-import { g as RequestContext, l as MutationIntent, u as MutationKind } from "./plugin-o144f322.js";
-//#region src/core/logger.d.ts
-type LogFields = Readonly<Record<string, unknown>>;
-/**
- * Where better-supabase reports problems it swallows on purpose: event
- * handlers, `afterMutation` hooks, sinks and cache adapters that throw.
- * Structured loggers (pino, consola, OpenTelemetry logs) fit directly.
- */
-interface Logger {
-  debug(message: string, fields?: LogFields): void;
-  info(message: string, fields?: LogFields): void;
-  warn(message: string, fields?: LogFields): void;
-  error(message: string, fields?: LogFields): void;
-}
-/** The default: `console`, with a `better-supabase:` prefix. */
-declare const consoleLogger: Logger;
-declare const silentLogger: Logger;
-//#endregion
-//#region src/core/kit-events.d.ts
-/** `support.*`: support sessions, where a platform admin views the app as a user. */
-interface SupportEventData {
-  /** Absent on `support.denied`. */
-  readonly sessionId?: string;
-  readonly adminId: string;
-  readonly targetUserId: string;
-  readonly reason?: string;
-  readonly readOnly?: boolean;
-  readonly expiresAt?: Temporal.Instant;
-  /** `support.denied`: which check refused it. */
-  readonly denial?: "authorize" | "permission" | "policy" | "store";
-  /** `support.ended`: who or what ended it. */
-  readonly endedBy?: "admin" | "expired" | "revoked";
-}
-/** `org.*`: organizations and their members. */
-interface OrgEventData {
-  readonly organizationId: string;
-  /** The member the event is about. */
-  readonly userId?: string;
-  readonly role?: string;
-  readonly previousRole?: string;
-}
-/** `invitation.*`. The token is never part of the event. */
-interface InvitationEventData {
-  readonly invitationId: string;
-  /** Absent for a platform-scope invitation. */
-  readonly organizationId?: string;
-  readonly email?: string;
-  readonly role?: string;
-}
-/** `notification.*`. */
-interface NotificationEventData {
-  readonly notificationId: string;
-  readonly type: string;
-  readonly recipientIds?: readonly string[];
-  readonly channel?: string;
-  readonly error?: string;
-}
-/** `webhook.*`: outgoing webhooks. */
-interface WebhookEventData {
-  readonly endpointId: string;
-  readonly deliveryId?: string;
-  readonly eventType?: string;
-  /** The HTTP status of the attempt, when there was a response. */
-  readonly status?: number;
-  readonly attempt?: number;
-  readonly error?: string;
-}
-/** Every kit event type and its data. */
-interface KitEventMap {
-  "support.started": SupportEventData;
-  "support.ended": SupportEventData;
-  "support.denied": SupportEventData;
-  "org.created": OrgEventData;
-  "org.updated": OrgEventData;
-  "org.deleted": OrgEventData;
-  "org.member_added": OrgEventData;
-  "org.member_removed": OrgEventData;
-  "org.member_left": OrgEventData;
-  "org.role_changed": OrgEventData;
-  "org.ownership_transferred": OrgEventData;
-  "org.switched": OrgEventData;
-  "invitation.created": InvitationEventData;
-  "invitation.resent": InvitationEventData;
-  "invitation.accepted": InvitationEventData;
-  "invitation.declined": InvitationEventData;
-  "invitation.revoked": InvitationEventData;
-  "notification.created": NotificationEventData;
-  "notification.delivered": NotificationEventData;
-  "notification.failed": NotificationEventData;
-  "webhook.delivered": WebhookEventData;
-  "webhook.failed": WebhookEventData;
-  "webhook.disabled": WebhookEventData;
-}
-type KitEventType = keyof KitEventMap;
-/** Where an event came from, beyond its data. */
-interface KitEventMeta {
-  /** e.g. `organizations/<id>`; becomes the CloudEvents `subject`. */
-  readonly subject?: string;
-  readonly tenant?: string;
-  /** The user who caused it. */
-  readonly actorId?: string;
-  readonly context?: RequestContext;
-}
-/** A kit event as `betterSupabase.on('kit', handler)` receives it. */
-type KitEvent<K extends KitEventType = KitEventType> = { readonly [T in K]: KitEventMeta & {
-  readonly type: T;
-  /** A copy: changing it never changes what the kit does (invariant 5). */
-  readonly data: KitEventMap[T];
-  readonly time: Temporal.Instant;
-}; }[K];
-/** A type, or a `prefix.*` pattern such as `support.*`. */
-type KitEventPattern = KitEventType | `${KitEventType extends `${infer P}.${string}` ? P : never}.*`;
-/** The event types a pattern matches. */
-type KitEventsMatching<P extends KitEventPattern> = P extends `${infer Prefix}.*` ? Extract<KitEventType, `${Prefix}.${string}`> : Extract<P, KitEventType>;
-/**
- * Fixed OpenTelemetry attribute names for kit work, so dashboards and
- * queries can rely on them.
- */
-declare const KIT_ATTRIBUTES: {
-  readonly event: "better_supabase.kit.event";
-  readonly tenant: "better_supabase.tenant";
-  readonly actor: "better_supabase.actor.id";
-  readonly supportSessionId: "better_supabase.support.session_id";
-  readonly orgId: "better_supabase.org.id";
-  readonly invitationId: "better_supabase.invitation.id";
-  readonly notificationType: "better_supabase.notification.type";
-  readonly webhookEndpointId: "better_supabase.webhook.endpoint_id";
-};
-/** The `KIT_ATTRIBUTES` an event carries. */
-declare function kitEventAttributes(event: KitEvent): Record<string, string>;
-/**
- * Listens to the kit events that match `pattern` (`'support.started'` or
- * `'support.*'`). Returns a function that stops listening.
- */
-declare function onKitEvent<P extends KitEventPattern>(betterSupabase: {
-  readonly events: EventHub;
-}, pattern: P, handler: (event: KitEvent<KitEventsMatching<P>>) => void): () => void;
-//#endregion
-//#region src/core/events.d.ts
-interface QueryEvent {
-  readonly table: string;
-  readonly operation: Operation["kind"];
-  readonly ok: boolean;
-  readonly durationMs: number;
-  readonly rows: number;
-  /**
-   * An unbounded read returned `maxRows` rows: PostgREST's `db-max-rows`
-   * probably cut it short. Add `limit` or use `paginate`.
-   */
-  readonly truncated: boolean;
-}
-interface MutationNotice {
-  readonly table: string;
-  readonly kind: MutationKind;
-  /** See `MutationEvent.intent`. */
-  readonly intent?: MutationIntent;
-  /** A copy of the returned rows: changing it never changes the result. */
-  readonly rows: readonly Readonly<Record<string, unknown>>[];
-  /** See `MutationEvent.keys`. */
-  readonly keys?: readonly Readonly<Record<string, unknown>>[];
-  /** See `MutationEvent.tenant`. */
-  readonly tenant?: string;
-  readonly context: RequestContext;
-}
-/** A successful RPC registered with `betterSupabase.defineRpc(name, { invalidates })`. */
-interface RpcNotice {
-  readonly name: string;
-  /** App keys of the tables the function changes. */
-  readonly invalidates: readonly string[];
-  readonly context: RequestContext;
-}
-interface ErrorEvent {
-  readonly table?: string;
-  readonly error: DbError;
-}
-interface AuthEvent {
-  readonly source: "bearer" | "cookie" | "none";
-  readonly ok: boolean;
-  readonly userId?: string;
-  /**
-   * Why there is no user: the anon reason (`expired`, `signed_out`, ...) or
-   * the invalid reason (`token`, `claims`, `actor`).
-   */
-  readonly reason?: "none" | "expired" | "signed_out" | "refresh_failed" | "token" | "claims" | "actor";
-  /** The user's `source` as the resolver set it, e.g. a custom resolver's name. */
-  readonly rawSource?: string;
-}
-interface RefreshEvent {
-  readonly ok: boolean;
-  readonly shared: boolean;
-  readonly durationMs: number;
-}
-interface BetterSupabaseEvents {
-  query: QueryEvent;
-  mutation: MutationNotice;
-  rpc: RpcNotice;
-  error: ErrorEvent;
-  auth: AuthEvent;
-  refresh: RefreshEvent;
-  /** Support sessions, organizations, invitations, notifications and webhooks. */
-  kit: KitEvent;
-}
-type EventName = keyof BetterSupabaseEvents;
-type EventHandler<K extends EventName> = (event: BetterSupabaseEvents[K]) => void;
-/**
- * Observers only: a handler that throws is reported to the logger and never
- * changes a result.
- */
-declare class EventHub {
-  #private;
-  readonly logger: Logger;
-  constructor(logger?: Logger);
-  on<K extends EventName>(name: K, handler: EventHandler<K>): () => void;
-  has(name: EventName): boolean;
-  /**
-   * Keeps async work a handler started (a sink send) until it settles, so
-   * adapters can hand it to `after()` or `waitUntil`. Its outcome is ignored:
-   * handlers report their own failures.
-   */
-  track(work: PromiseLike<unknown>): void;
-  /** Whether tracked work is still running. */
-  get pending(): boolean;
-  /** Resolves once the work tracked so far has settled. Never rejects. */
-  settled(): Promise<void>;
-  emit<K extends EventName>(name: K, event: BetterSupabaseEvents[K]): void;
-}
-//#endregion
-export { kitEventAttributes as C, consoleLogger as D, Logger as E, silentLogger as O, WebhookEventData as S, LogFields as T, KitEventType as _, EventHub as a, OrgEventData as b, QueryEvent as c, InvitationEventData as d, KIT_ATTRIBUTES as f, KitEventPattern as g, KitEventMeta as h, EventHandler as i, RefreshEvent as l, KitEventMap as m, BetterSupabaseEvents as n, EventName as o, KitEvent as p, ErrorEvent as r, MutationNotice as s, AuthEvent as t, RpcNotice as u, KitEventsMatching as v, onKitEvent as w, SupportEventData as x, NotificationEventData as y };