better-supabase 0.5.1 → 0.6.1

package/dist/blocks/knowledge/index.d.ts

@@ -0,0 +1,3 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { a as KnowledgeDocument, c as KnowledgeQuery, d as KnowledgeStatus, f as NewKnowledgeDocument, i as KnowledgeChunk, l as KnowledgeScope, m as createKnowledge, n as Embedder, o as KnowledgeHit, p as chunk, r as Knowledge, s as KnowledgeOptions, t as ChunkOptions, u as KnowledgeSearchOptions } from "../../knowledge-BXBbT0Tr.js";
+export { type BlockTransport, type ChunkOptions, type Embedder, type Knowledge, type KnowledgeChunk, type KnowledgeDocument, type KnowledgeHit, type KnowledgeOptions, type KnowledgeQuery, type KnowledgeScope, type KnowledgeSearchOptions, type KnowledgeStatus, type NewKnowledgeDocument, chunk, createKnowledge, rpcTransport, sqlTransport };

package/dist/blocks/knowledge/index.js

@@ -0,0 +1,3 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { n as chunk, r as createKnowledge } from "../../knowledge-CDmiMLew.js";
+export { chunk, createKnowledge, rpcTransport, sqlTransport };

package/dist/blocks/memory/index.d.ts

@@ -0,0 +1,8 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { n as Embedder } from "../../knowledge-BXBbT0Tr.js";
+import { a as MemoryKind, c as MemoryRecord, d as RecalledMessage, i as MemoryHit, l as MemoryScope, n as MemoryCommand, o as MemoryNamespace, r as MemoryDocument, s as MemoryOptions, t as Memory, u as MemoryView } from "../../types-DGs5L0VN.js";
+//#region src/blocks/memory/memory.d.ts
+/** Core memory files, archival facts and recall over earlier chats. */
+export declare function createMemory(options: MemoryOptions): Memory;
+//#endregion
+export { type BlockTransport, type Embedder, type Memory, type MemoryCommand, type MemoryDocument, type MemoryHit, type MemoryKind, type MemoryNamespace, type MemoryOptions, type MemoryRecord, type MemoryScope, type MemoryView, type RecalledMessage, rpcTransport, sqlTransport };

package/dist/blocks/memory/index.js

@@ -0,0 +1,289 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { t as vectorLiteral } from "../../search-CUWCRYKL.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { C as run, O as textOf, d as isRecord, h as optionalText, i as blockCall, k as toInstant, l as injectableOf, n as applyTemporal, p as oneOf, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { t as checkVectors } from "../../knowledge-CDmiMLew.js";
+//#region src/blocks/memory/rows.ts
+const SCOPES = [
+	"user",
+	"agent",
+	"chat",
+	"project",
+	"organization"
+];
+const scopeOf = (value) => oneOf(textOf(value), SCOPES, "user");
+const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+function memoryOf(value) {
+	const row = recordOf(value, "memories");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		ownerId: optionalText(row["owner_id"]),
+		scope: scopeOf(row["scope"]),
+		agentId: optionalText(row["agent_id"]),
+		chatId: optionalText(row["chat_id"]),
+		projectId: optionalText(row["project_id"]),
+		kind: row["kind"] === "core" ? "core" : "archival",
+		path: optionalText(row["path"]),
+		content: textOf(row["content"]),
+		version: Number(row["version"] ?? 1),
+		embeddingModel: optionalText(row["embedding_model"]),
+		sourceMessageId: optionalText(row["source_message_id"]),
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+function hitOf(value) {
+	const row = recordOf(value, "memory_search");
+	const similarity = row["similarity"];
+	return {
+		...memoryOf(row),
+		score: Number(row["score"]),
+		similarity: typeof similarity === "number" ? similarity : void 0
+	};
+}
+function viewOf(value) {
+	if (!isRecord(value)) return void 0;
+	if (value["type"] === "file") return {
+		type: "file",
+		path: textOf(value["path"]),
+		content: textOf(value["content"]),
+		version: Number(value["version"])
+	};
+	return {
+		type: "directory",
+		path: textOf(value["path"]),
+		entries: recordsOf(value["entries"], "memory_view").map((entry) => ({
+			path: textOf(entry["path"]),
+			size: Number(entry["size"])
+		}))
+	};
+}
+function documentOf(value) {
+	const row = recordOf(value, "memory_document");
+	return {
+		content: textOf(row["content"]),
+		version: textOf(row["version"])
+	};
+}
+function recalledOf(value) {
+	return recordsOf(value, "recall_ai_messages").map((row) => ({
+		chatId: textOf(row["chat_id"]),
+		messageId: textOf(row["message_id"]),
+		similarity: Number(row["similarity"])
+	}));
+}
+//#endregion
+//#region src/blocks/memory/memory.ts
+const nsArg = (ns = {}) => {
+	const arg = {};
+	if (ns.scope !== void 0) arg["scope"] = ns.scope;
+	if (ns.agentId !== void 0) arg["agent_id"] = ns.agentId;
+	if (ns.chatId !== void 0) arg["chat_id"] = ns.chatId;
+	if (ns.projectId !== void 0) arg["project_id"] = ns.projectId;
+	if (ns.ownerId !== void 0) arg["owner_id"] = ns.ownerId;
+	return arg;
+};
+const noEmbedder = () => dbError("invalid_request", "createMemory has no embedder", { hint: "MEMORY_NO_EMBEDDER" });
+/** Numbered lines, as the memory tool shows a file. */
+function numbered(content, range) {
+	const lines = content.split("\n");
+	const from = Math.max(range?.[0] ?? 1, 1);
+	const to = range === void 0 || range[1] === -1 ? lines.length : range[1];
+	return lines.slice(from - 1, to).map((line, index) => `${String(from + index).padStart(6)}\t${line}`).join("\n");
+}
+const escapeTag = (text) => text.replaceAll("</memory", "<\\/memory");
+/** Core memory files, archival facts and recall over earlier chats. */
+function createMemory(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const embedder = injectableOf("embedder", options.embedder);
+	const maxRender = options.maxRender ?? 8e3;
+	const threshold = options.dedupeThreshold ?? .92;
+	const embedOne = (text, signal) => embedder ? run(() => embedder.embed([text], signal === void 0 ? void 0 : { signal })).map((vectors) => vectors[0] === void 0 ? void 0 : vectorLiteral(vectors[0])) : AsyncResult.ok(void 0);
+	const view = (organizationId, path = "/memories", ns) => call("memory_view", {
+		tenant: organizationId,
+		path,
+		ns: nsArg(ns)
+	}, viewOf);
+	const core = {
+		view,
+		write: (organizationId, path, content, ns, writeOptions = {}) => call("memory_create", {
+			tenant: organizationId,
+			path,
+			content,
+			ns: nsArg(ns),
+			expected_version: writeOptions.expectedVersion
+		}, memoryOf),
+		strReplace: (organizationId, path, oldText, newText, ns) => call("memory_str_replace", {
+			tenant: organizationId,
+			path,
+			old_text: oldText,
+			new_text: newText,
+			ns: nsArg(ns)
+		}, memoryOf),
+		insert: (organizationId, path, line, text, ns) => call("memory_insert", {
+			tenant: organizationId,
+			path,
+			insert_line: line,
+			insert_text: text,
+			ns: nsArg(ns)
+		}, memoryOf),
+		remove: (organizationId, path, ns) => call("memory_delete", {
+			tenant: organizationId,
+			path,
+			ns: nsArg(ns)
+		}, Number),
+		rename: (organizationId, oldPath, newPath, ns) => call("memory_rename", {
+			tenant: organizationId,
+			old_path: oldPath,
+			new_path: newPath,
+			ns: nsArg(ns)
+		}, Number),
+		list: (organizationId, ns) => call("memory_list", {
+			tenant: organizationId,
+			ns: nsArg(ns),
+			kind: "core"
+		}, (value) => recordsOf(value, "memory_list").map(memoryOf))
+	};
+	const save = (organizationId, content, ns, saveOptions = {}, viaService = false, embedded) => (embedded === void 0 ? embedOne(content) : AsyncResult.ok(embedded)).andThen((embedding) => (viaService ? service : call)("memory_save", {
+		tenant: organizationId,
+		content,
+		ns: nsArg(ns),
+		embedding,
+		model: embedding === void 0 ? void 0 : embedder?.model,
+		source_message_id: saveOptions.sourceMessageId
+	}, memoryOf));
+	const search = (organizationId, query, ns, searchOptions = {}, viaService = false, embedded) => (embedded === void 0 ? embedOne(query, searchOptions.signal) : AsyncResult.ok(embedded)).andThen((embedding) => (viaService ? service : call)("memory_search", {
+		tenant: organizationId,
+		query_embedding: embedding,
+		query_text: query,
+		ns: nsArg(ns),
+		k: searchOptions.k
+	}, (value) => recordsOf(value, "memory_search").map(hitOf)));
+	const runCommand = (organizationId, command, ns) => {
+		switch (command.command) {
+			case "view": return view(organizationId, command.path, ns).map((result) => {
+				if (result === void 0) return `${command.path} does not exist.`;
+				if (result.type === "file") return `Here's the content of ${result.path} with line numbers:\n${numbered(result.content, command.view_range)}`;
+				const entries = result.entries.map((entry) => `${String(entry.size)}\t${entry.path}`);
+				return `Here are the files in ${result.path}:\n${entries.join("\n")}`;
+			});
+			case "create": return core.write(organizationId, command.path, command.file_text, ns).map(() => `File created successfully at: ${command.path}`);
+			case "str_replace": return core.strReplace(organizationId, command.path, command.old_str, command.new_str ?? "", ns).map(() => `The memory file ${command.path} has been edited.`);
+			case "insert": return core.insert(organizationId, command.path, command.insert_line, command.insert_text, ns).map(() => `The memory file ${command.path} has been edited.`);
+			case "delete": return core.remove(organizationId, command.path, ns).map((count) => count === 0 ? `${command.path} does not exist.` : `Successfully deleted ${command.path}`);
+			case "rename": return core.rename(organizationId, command.old_path, command.new_path, ns).map(() => `Successfully renamed ${command.old_path} to ${command.new_path}`);
+			default: {
+				const unknown = command;
+				return AsyncResult.err(dbError("invalid_request", `Unknown memory command ${JSON.stringify(unknown)}`, { hint: "MEMORY_COMMAND" }));
+			}
+		}
+	};
+	return {
+		core,
+		run: runCommand,
+		archival: {
+			save: (organizationId, content, ns, saveOptions) => save(organizationId, content, ns, saveOptions),
+			search: (organizationId, query, ns, searchOptions) => search(organizationId, query, ns, searchOptions),
+			list: (organizationId, ns, listOptions = {}) => call("memory_list", {
+				tenant: organizationId,
+				ns: nsArg(ns),
+				kind: "archival",
+				max_rows: listOptions.limit
+			}, (value) => recordsOf(value, "memory_list").map(memoryOf)),
+			forget: (memoryId, forgetOptions = {}) => call("memory_forget", {
+				memory_id: memoryId,
+				superseded_by: forgetOptions.supersededBy
+			}, (value) => value === true)
+		},
+		recall: {
+			index: (message) => embedder ? embedOne(message.text).andThen((embedding) => service("set_ai_message_embedding", {
+				chat_id: message.chatId,
+				message_id: message.messageId,
+				user_id: message.userId,
+				tenant: message.organizationId,
+				embedding,
+				model: embedder.model
+			}, (value) => value === true)) : AsyncResult.err(noEmbedder()),
+			search: (organizationId, query, recallOptions = {}) => embedder ? embedOne(query, recallOptions.signal).andThen((embedding) => call("recall_ai_messages", {
+				tenant: organizationId,
+				query_embedding: embedding,
+				k: recallOptions.k,
+				exclude_chat: recallOptions.excludeChat,
+				owner: recallOptions.ownerId
+			}, recalledOf)) : AsyncResult.err(noEmbedder())
+		},
+		render: (organizationId, ns) => core.list(organizationId, ns).map((files) => {
+			if (files.length === 0) return "";
+			const close = "</memories>";
+			let text = "<memories>\n";
+			for (const file of files) {
+				const block = `<memory path="${file.path ?? ""}">\n${escapeTag(file.content)}\n</memory>\n`;
+				if (text.length + block.length + 11 > maxRender) {
+					text += `<!-- ${String(files.length)} files; the rest is cut at ${String(maxRender)} characters -->\n`;
+					break;
+				}
+				text += block;
+			}
+			return text + close;
+		}),
+		saveExtracted: (organizationId, facts, ns, saveOptions) => AsyncResult.from(async () => {
+			const saved = [];
+			const contents = facts.map((fact) => fact.trim()).filter((content) => content !== "");
+			if (contents.length === 0) return ok(saved);
+			let embeddings = [];
+			if (embedder) {
+				const vectors = await run(() => embedder.embed(contents));
+				if (!vectors.ok) return vectors;
+				const invalid = checkVectors(vectors.data, contents.length);
+				if (invalid) return err(invalid);
+				embeddings = vectors.data.map((vector) => vectorLiteral(vector));
+			}
+			for (const [index, content] of contents.entries()) {
+				const embedding = embeddings[index];
+				const similar = await search(organizationId, content, ns, { k: 1 }, true, embedding);
+				if (!similar.ok) return similar;
+				const nearest = similar.data[0];
+				if (nearest !== void 0 && (nearest.content === content || (nearest.similarity ?? 0) >= threshold)) continue;
+				const record = await save(organizationId, content, ns, saveOptions, true, embedding);
+				if (!record.ok) return record;
+				saved.push(record.data);
+			}
+			return ok(saved);
+		}),
+		embedPending: (embedOptions = {}) => embedder ? service("pending_memory_embeddings", { batch: embedOptions.batch }, (value) => recordsOf(value, "pending_memory_embeddings")).andThen((rows) => AsyncResult.from(async () => {
+			if (rows.length === 0) return ok(0);
+			const vectors = await run(() => embedder.embed(rows.map((row) => textOf(row["content"])), embedOptions.signal === void 0 ? void 0 : { signal: embedOptions.signal }));
+			if (!vectors.ok) return vectors;
+			const invalid = checkVectors(vectors.data, rows.length);
+			if (invalid) return err(invalid);
+			return service("set_memory_embeddings", {
+				items: { items: rows.map((row, index) => ({
+					id: textOf(row["id"]),
+					hash: row["hash"],
+					embedding: vectorLiteral(vectors.data[index] ?? [])
+				})) },
+				model: embedder.model
+			}, Number);
+		})) : AsyncResult.err(noEmbedder()),
+		documents: {
+			read: (scopeKey, path) => service("memory_document_read", {
+				scope_key: scopeKey,
+				path
+			}, (value) => isRecord(value) ? documentOf(value) : void 0),
+			write: (scopeKey, path, content, writeOptions) => service("memory_document_write", {
+				scope_key: scopeKey,
+				path,
+				content,
+				expected_version: writeOptions.expectedVersion,
+				expires_in: writeOptions.expiresIn
+			}, documentOf),
+			purge: (batch) => service("purge_memory_documents", { batch }, Number)
+		}
+	};
+}
+//#endregion
+export { createMemory, rpcTransport, sqlTransport };

package/dist/blocks/notifications/index.d.ts

@@ -0,0 +1,297 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
+import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { m as RequestContext } from "../../plugin-FGY8UhYm.js";
+import { a as EventHub } from "../../events-DWDhx77e.js";
+import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
+import { r as EventSink, t as CloudEvent } from "../../cloud-event-C1JCc1bH.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-plbZ0AbJ.js";
+import { a as NotificationSubject, i as NotificationItem, n as NotificationMessage, o as RenderedText, r as NotificationSendResult, t as NotificationChannel } from "../../channel-_2Mx1Oyu.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/notifications/notifications.d.ts
+/** Notification type to the Standard Schema of its `data`. */
+type NotificationTypes = Readonly<Record<string, StandardSchemaV1>>;
+type TypeName<K extends NotificationTypes> = keyof K & string;
+interface SendInput<D = unknown> {
+  /** Who gets it. Watchers of `subject` and the `notification_audience` hook add more. */
+  readonly recipients?: readonly string[];
+  /** The organization; required when an authenticated user sends. */
+  readonly tenant?: string;
+  readonly subject?: NotificationSubject;
+  readonly summary?: string;
+  readonly actionPath?: string;
+  /** One of `sql.modules.notifications.options.priorities`. Defaults to `normal`. */
+  readonly priority?: string;
+  readonly data: D;
+  /** With a key, sending again (per tenant) returns the first notification. */
+  readonly key?: string;
+  /** Defaults to `sql.modules.notifications.options.channels`. */
+  readonly channels?: readonly string[];
+  /** Also notify the user who caused it. Defaults to `false`. */
+  readonly includeActor?: boolean;
+  /**
+   * `participating` (default) reaches subject watchers at both levels;
+   * `all` is routine activity that only `all` watchers get.
+   */
+  readonly activity?: "participating" | "all";
+  /** Create it already resolved, e.g. for a record of a finished approval. */
+  readonly resolved?: boolean;
+  /** The actor, when the service sends on a user's behalf. */
+  readonly actorId?: string;
+  /**
+   * Add the watchers of `subject`. Defaults to `true`; `false` reaches only
+   * `recipients` and the audience hook (members ignoring the subject stay
+   * out either way).
+   */
+  readonly watchers?: boolean;
+  /** Users left out after the watchers and the audience hook are added. */
+  readonly exclude?: readonly string[];
+}
+interface ListOptions<K extends string = string> extends CursorPageOptions<Temporal.Instant | Pick<NotificationItem, "createdAt" | "id">> {
+  readonly tenant?: string;
+  readonly status?: "all" | "unread" | "read" | "unresolved" | "settled";
+  readonly read?: boolean;
+  readonly resolved?: boolean;
+  readonly dismissed?: boolean | null;
+  readonly types?: readonly K[];
+  readonly subjectTypes?: readonly string[];
+  readonly search?: string;
+  /**
+   * Page: only notifications older than this. Pass the last item of the
+   * previous page; a bare instant skips items created at that same instant.
+   */
+  readonly cursor?: Temporal.Instant | Pick<NotificationItem, "createdAt" | "id">;
+  /** Up to 200. Defaults to 50. */
+  readonly limit?: number;
+  /** Passed to `render`. */
+  readonly locale?: string;
+  /**
+   * `actor` adds each item's actor profile (`id` and the public profile
+   * columns), read in one call from the `profiles` module's table.
+   */
+  readonly include?: readonly "actor"[];
+}
+interface PageOptions<K extends string = string> extends Omit<ListOptions<K>, "before" | "cursor"> {
+  readonly offset?: number;
+}
+interface NotificationPage<K extends string = string, R extends Rendered<K> = Rendered<K>> {
+  readonly items: readonly R[];
+  readonly total: number;
+}
+interface NotificationSubscription {
+  readonly subject: {
+    readonly type: string;
+    readonly id: string;
+  };
+  readonly level: SubscriptionLevel;
+  readonly tenant: string | null;
+  readonly createdAt: Temporal.Instant | null;
+}
+interface NotificationPreference {
+  readonly type: string;
+  readonly channel: string;
+  readonly enabled: boolean;
+  readonly tenant: string | null;
+}
+/** The actor of a notification, from the `profiles` module's table. */
+interface NotificationActor {
+  readonly id: string;
+  readonly username?: string | null;
+  readonly fullName?: string | null;
+  readonly firstName?: string | null;
+  readonly lastName?: string | null;
+  readonly avatar?: string | null;
+  readonly avatarPath?: string | null;
+  readonly avatarUrl?: string | null;
+}
+type AvatarUrls = {
+  readonly url: string;
+  readonly bucket: string;
+} | ((path: string) => string | null);
+interface SentNotification {
+  readonly id: string;
+  readonly recipients: readonly string[];
+}
+interface NotificationUpdate {
+  readonly count: number;
+  readonly items: readonly NotificationItem[];
+}
+interface NotificationCounts {
+  readonly unread: number;
+  /** Unresolved notifications of the `actionable` types. */
+  readonly actionable: number;
+  readonly actionableSubjects: number;
+}
+type SubscriptionLevel = "participating" | "all" | "ignore";
+interface DeliverOptions {
+  /** Channel names to work on. Defaults to every channel in `channels`. */
+  readonly channels?: readonly string[];
+  /** Deliveries per claim. Defaults to 50. */
+  readonly batch?: number;
+  /** How long a claimed delivery waits before another worker retries it. */
+  readonly lease?: string;
+  /**
+   * Tries before a delivery is `failed`. Defaults to 5. Retries wait a random
+   * time up to 30 seconds, doubling per attempt to an hour.
+   */
+  readonly maxAttempts?: number;
+  readonly budgetMs?: number;
+}
+interface DeliverResult {
+  readonly sent: number;
+  readonly skipped: number;
+  /** Deliveries that threw; retried later unless they ran out of attempts. */
+  readonly failed: number;
+}
+interface Rendered<K extends string = string, D = unknown> extends NotificationItem<K, D> {
+  /** What `render` returned. Absent without a `render` option. */
+  readonly text?: RenderedText;
+  /** With `include: ['actor']`: the actor's profile, or null. */
+  readonly actor?: NotificationActor | null;
+}
+/**
+ * A notification as `get`, `list` and `page` return it: its `data` parsed
+ * with its type's schema, so checking `type` narrows `data`.
+ */
+type NotificationOf<K extends NotificationTypes> = { [N in TypeName<K>]: Rendered<N, StandardSchemaV1.InferOutput<K[N]>>; }[TypeName<K>];
+interface NotificationsOptions<K extends NotificationTypes, H = undefined> extends BlockTemporalOptions {
+  /** `sqlTransport(postgres.asUser(claims))`, or over `postgres.admin` for the service. */
+  readonly transport: BlockTransport;
+  /**
+   * Each type's `data` schema. `send` validates against it, and `get`,
+   * `list` and `page` parse stored data with it, so keep a schema able to
+   * read the notifications already sent (or purge them). A stored value it
+   * rejects is a `validation` error with the hint `NOTIFICATION_DATA_INVALID`;
+   * a type no longer listed keeps its data as stored.
+   */
+  readonly types: K;
+  /** `withBlockHooks` hooks around the methods, such as a rule on `send`. */
+  readonly hooks?: NoInfer<BlockHooks<Notifications<K>>>;
+  /** `sql.modules.notifications.schema`. Defaults to `better_supabase`. */
+  readonly schema?: string;
+  /**
+   * Loads what `render` needs for a whole page at once (actor names,
+   * subject titles), so a list of 50 items costs one query instead of 50.
+   * Its result reaches `render` as `context.hydrated`.
+   */
+  readonly hydrate?: (items: readonly NotificationItem[], context: {
+    readonly locale?: string;
+  }) => H | Promise<H>;
+  /** Turns a notification into text at read time, in the reader's locale. */
+  readonly render?: (item: NotificationItem, context: {
+    readonly locale?: string;
+    readonly hydrated?: H;
+  }) => RenderedText;
+  /** Types that wait for an action; `counts().actionable` counts them. */
+  readonly actionable?: readonly TypeName<K>[];
+  readonly avatars?: AvatarUrls;
+  /** Senders for the non-`in_app` channels, used by `deliver()`. */
+  readonly channels?: readonly NotificationChannel[];
+  /** Runs after a notification is stored, e.g. to call Next's `updateTag`. */
+  readonly onSent?: (sent: {
+    readonly id: string;
+    readonly type: string;
+    readonly tenant: string | null;
+    readonly recipients: readonly string[];
+  }) => void | Promise<void>;
+  /** `betterSupabase.events`, for `notification.*` block events. */
+  readonly events?: EventHub;
+  readonly actorId?: string;
+  readonly context?: RequestContext;
+  /** Error mappers that run before the built-in ones. */
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The `notifications` SQL module as typed calls. `send` validates the
+ * data against its type's schema; the database checks the send permission,
+ * leaves out the actor and non-members and applies subscriptions and
+ * preferences.
+ */
+interface Notifications<K extends NotificationTypes> {
+  /** The notification id, or `null` when nobody was left to notify. */
+  send<N extends TypeName<K>>(type: N, input: SendInput<StandardSchemaV1.InferInput<K[N]>>): AsyncResult<SentNotification | null>;
+  get(id: string, options?: Pick<ListOptions, "locale" | "include">): AsyncResult<NotificationOf<K> | null>;
+  list(options?: ListOptions<TypeName<K>>): AsyncResult<readonly NotificationOf<K>[]>;
+  page(options?: PageOptions<TypeName<K>>): AsyncResult<NotificationPage<TypeName<K>, NotificationOf<K>>>;
+  counts(options?: {
+    readonly tenant?: string;
+  }): AsyncResult<NotificationCounts>;
+  /** Marks the given notifications, or all of them, read. */
+  markRead(options?: {
+    readonly ids?: readonly string[];
+    readonly tenant?: string;
+  }): AsyncResult<NotificationUpdate>;
+  markUnread(options: {
+    readonly ids: readonly string[];
+    readonly tenant?: string;
+  }): AsyncResult<NotificationUpdate>;
+  dismiss(ids: readonly string[]): AsyncResult<NotificationUpdate>;
+  /** Resolves every recipient's notification of a type about a subject. */
+  resolve(input: {
+    readonly type: TypeName<K>;
+    readonly subject: NotificationSubject;
+    readonly tenant?: string;
+  }): AsyncResult<NotificationUpdate>;
+  /** Sets the user's level for a subject; `null` removes it. */
+  subscribe(input: {
+    readonly subject: NotificationSubject;
+    readonly level: SubscriptionLevel | null;
+    readonly tenant?: string;
+    /**
+     * Another member; the service can set it, and with `ifAbsent` so can a
+     * sender with the send permission in `tenant`.
+     */
+    readonly userId?: string;
+    /**
+     * Only add `level` when the member has no level for the subject, so an
+     * auto-follow keeps their own `ignore` or `all`.
+     */
+    readonly ifAbsent?: boolean;
+  }): AsyncResult<void>;
+  subscriptions(options?: {
+    readonly tenant?: string;
+    readonly subject?: {
+      readonly type: string;
+      readonly id?: string;
+    };
+  }): AsyncResult<readonly NotificationSubscription[]>;
+  preferences(options?: {
+    readonly tenant?: string;
+  }): AsyncResult<readonly NotificationPreference[]>;
+  /** Turns a type (`*` for all) on or off on a channel; `null` removes it. */
+  setPreference(input: {
+    readonly type: TypeName<K> | "*";
+    readonly channel: string;
+    readonly enabled: boolean | null;
+    /** One organization, or everywhere when omitted. */
+    readonly tenant?: string;
+  }): AsyncResult<void>;
+  /** Sends pending deliveries through `channels`. Run it from a cron or a job. */
+  deliver(options?: DeliverOptions): Promise<DeliverResult>;
+  /**
+   * Deletes up to `batch` (10,000) notifications older than `olderThan`
+   * (`90 days`) with their recipients and deliveries. Service only.
+   */
+  purge(olderThan?: string, batch?: number): AsyncResult<number>;
+  /**
+   * An `EventSink` that sends a notification for each event `map` returns
+   * one for. The key defaults to the event id and the tenant to its
+   * `partitionkey`, so a redelivered event sends nothing new. A failed send
+   * rejects, so the forwarder retries. The comments module already notifies
+   * `comment.mentioned`; don't map it again.
+   */
+  sink(options: NotificationSinkOptions<K>): EventSink;
+}
+/** A notification for `sink`, with its type next to the `send` input. */
+type SinkNotification<K extends NotificationTypes> = { [N in TypeName<K>]: {
+  readonly type: N;
+} & SendInput<StandardSchemaV1.InferInput<K[N]>>; }[TypeName<K>];
+interface NotificationSinkOptions<K extends NotificationTypes> {
+  /** The notification for an event, or `null` to skip it. `event.type` has no `typePrefix`. */
+  map(event: CloudEvent): SinkNotification<K> | null | Promise<SinkNotification<K> | null>;
+  /** Stripped from each event type before `map`. Defaults to `dev.better-supabase.`. */
+  readonly typePrefix?: string;
+}
+export declare function createNotifications<const K extends NotificationTypes, H = undefined>(options: NotificationsOptions<K, H>): Notifications<K>;
+//#endregion
+export { type AvatarUrls, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type DeliverOptions, type DeliverResult, type ListOptions, type NotificationActor, type NotificationChannel, type NotificationCounts, type NotificationItem, type NotificationMessage, type NotificationOf, type NotificationPage, type NotificationPreference, type NotificationSendResult, type NotificationSinkOptions, type NotificationSubject, type NotificationSubscription, type NotificationTypes, type NotificationUpdate, type Notifications, type NotificationsOptions, type PageOptions, type Rendered, type RenderedText, type RpcClient, type SendInput, type SentNotification, type SinkNotification, type SubscriptionLevel, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };