better-supabase 0.13.0 → 0.14.0

package/dist/messaging-BC-P-yAv.js

@@ -0,0 +1,329 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { a as ok, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+import { n as blockFields } from "./block-fields-DBSJSeaO.js";
+import { t as requireTenant } from "./block-tenant-C1sNV8_4.js";
+import { i as num, n as editOf, r as messageOf } from "./rows-Bb0EPupt.js";
+//#region src/blocks/messaging/summaries.ts
+/** The most messages one summary reads. */
+const MAX_SUMMARY_MESSAGES = 200;
+function threadSummaryOf(value) {
+	const row = recordOf(value, "thread summary");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		conversationId: textOf(row["conversation_id"]),
+		threadId: optionalText(row["thread_id"]),
+		summary: textOf(row["summary"]),
+		model: optionalText(row["model"]),
+		messageCount: num(row["message_count"]),
+		throughAt: requiredInstant(row["through_at"], "throughAt"),
+		stale: row["stale"] === true,
+		createdAt: requiredInstant(row["created_at"], "createdAt"),
+		updatedAt: requiredInstant(row["updated_at"], "updatedAt")
+	};
+}
+const summaryMessageOf = (message) => ({
+	id: message.id,
+	authorId: message.authorId,
+	authorName: message.author?.name,
+	body: message.body,
+	sentAt: message.sentAt
+});
+/**
+* Returns the saved summary while it is current, or reads the messages as the
+* caller, asks `summarizer` and saves what it wrote.
+*/
+function summarize(steps, target, summarizer, options = {}) {
+	const max = Math.min(Math.max(Math.trunc(options.maxMessages ?? MAX_SUMMARY_MESSAGES), 1), MAX_SUMMARY_MESSAGES);
+	return steps.current(target).andThen((saved) => {
+		if (saved !== void 0 && !saved.stale && options.force !== true) return AsyncResult.ok(saved);
+		return steps.read(target, max).andThen((read) => {
+			const sent = read.filter((message) => message.kind === "message" && message.sentAt !== void 0 && message.deletedAt === void 0 && message.body.trim() !== "");
+			const first = sent[0];
+			if (first === void 0) return AsyncResult.err(dbError("invalid_input", "There are no messages to summarize", { code: "MESSAGING_SUMMARY_EMPTY" }));
+			const messages = sent.map(summaryMessageOf);
+			const newest = messages.at(-1);
+			return AsyncResult.from(async () => ok(await summarizer.summarize({
+				organizationId: first.organizationId,
+				conversationId: first.conversationId,
+				threadId: "threadId" in target ? target.threadId : void 0,
+				messages,
+				previous: saved?.summary,
+				...options.signal === void 0 ? {} : { signal: options.signal }
+			}))).andThen((output) => steps.save(target, {
+				...output,
+				messageCount: messages.length,
+				throughAt: newest.sentAt
+			}));
+		});
+	});
+}
+//#endregion
+//#region src/blocks/messaging/messaging.ts
+const KINDS = [
+	"channel",
+	"dm",
+	"group_dm",
+	"subject",
+	"inbox"
+];
+const ACCESS = [
+	"members",
+	"tenant",
+	"subject"
+];
+const NOTIFY = [
+	"all",
+	"mentions",
+	"none"
+];
+function conversationOf(value) {
+	const row = recordOf(value, "conversation");
+	const subjectType = optionalText(row["subject_type"]);
+	const subjectId = optionalText(row["subject_id"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		kind: enumOrThrow(row["kind"], KINDS, "conversation kind"),
+		access: enumOrThrow(row["access"], ACCESS, "conversation access"),
+		subject: subjectType === void 0 || subjectId === void 0 ? void 0 : {
+			type: subjectType,
+			id: subjectId
+		},
+		title: optionalText(row["title"]),
+		createdBy: optionalText(row["created_by"]),
+		lastMessageAt: optionalInstant(row["last_message_at"]),
+		archivedAt: optionalInstant(row["archived_at"]),
+		createdAt: requiredInstant(row["created_at"], "createdAt"),
+		updatedAt: requiredInstant(row["updated_at"], "updatedAt")
+	};
+}
+function summaryOf(value) {
+	const row = recordOf(value, "conversation");
+	return {
+		...conversationOf(row),
+		unread: num(row["unread"]),
+		mentions: num(row["mentions"]),
+		lastReadAt: optionalInstant(row["lastReadAt"]),
+		notify: enumOrThrow(row["notify"] ?? "all", NOTIFY, "notify level")
+	};
+}
+function mentionOf(value) {
+	const row = recordOf(value, "record mention");
+	const conversation = recordOf(row["conversation"], "conversation");
+	const subjectType = optionalText(conversation["subject_type"]);
+	const subjectId = optionalText(conversation["subject_id"]);
+	return {
+		message: messageOf(row["message"]),
+		conversation: {
+			id: textOf(conversation["id"]),
+			kind: enumOrThrow(conversation["kind"], KINDS, "conversation kind"),
+			title: optionalText(conversation["title"]),
+			subject: subjectType === void 0 || subjectId === void 0 ? void 0 : {
+				type: subjectType,
+				id: subjectId
+			}
+		}
+	};
+}
+const cursorArgs = (prefix, cursor) => ({
+	[prefix]: cursor === void 0 ? null : instantArg(cursor.sentAt),
+	[`${prefix}_id`]: cursor?.id ?? null
+});
+/**
+* The messaging block: channels, direct and group messages and record
+* conversations, with threads, mentions, edits, pins, resolved threads,
+* scheduled sends, read markers, files and reactions.
+*/
+function createMessaging(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = options.service ? blockCall(options.service, options.schema, options.mappers) : call;
+	const tenant = () => requireTenant(options.tenant);
+	const fields = blockFields(options.fields, "message fields");
+	const one = (fn, args) => call(fn, args, messageOf).andThen(fields.row);
+	const many = (fn, args) => call(fn, args, (value) => recordsOf(value, fn).map(messageOf)).andThen(fields.rows);
+	const open = (conversation) => tenant().andThen((organizationId) => call("open_conversation", {
+		tenant: organizationId,
+		kind: conversation.kind,
+		attrs: {
+			...conversation.title === void 0 ? {} : { title: conversation.title },
+			...conversation.access === void 0 ? {} : { access: conversation.access },
+			...conversation.subject === void 0 ? {} : {
+				subjectType: conversation.subject.type,
+				subjectId: conversation.subject.id
+			}
+		},
+		members: [...conversation.memberIds ?? []]
+	}, conversationOf));
+	const targetArgs = (target) => "threadId" in target ? {
+		conversation: null,
+		thread: target.threadId
+	} : {
+		conversation: target.conversationId,
+		thread: null
+	};
+	const currentSummary = (target) => call("thread_summary", targetArgs(target), (value) => value === null || value === void 0 ? void 0 : threadSummaryOf(value));
+	/** A thread's root and its newest replies, oldest first. */
+	const readThread = (threadId, max, replies = [], after) => many("list_replies", {
+		message: threadId,
+		...cursorArgs("after", after),
+		max_rows: 500
+	}).andThen((page) => {
+		const all = [...replies, ...page];
+		const last = page.at(-1);
+		if (page.length === 500 && last?.sentAt !== void 0) return readThread(threadId, max, all, {
+			sentAt: last.sentAt,
+			id: last.id
+		});
+		return one("get_message", { message: threadId }).map((root) => [root, ...all.slice(-(max - 1))]);
+	});
+	const steps = {
+		current: currentSummary,
+		read: (target, max) => "threadId" in target ? readThread(target.threadId, max) : many("list_messages", {
+			conversation: target.conversationId,
+			...cursorArgs("after", void 0),
+			...cursorArgs("before", void 0),
+			max_rows: max
+		}).map((messages) => messages.filter((message) => message.threadId === void 0)),
+		save: (target, saved) => service("save_thread_summary", {
+			...targetArgs(target),
+			summary: saved.summary,
+			attrs: {
+				messageCount: saved.messageCount,
+				throughAt: saved.throughAt.toString(),
+				...saved.model === void 0 ? {} : { model: saved.model }
+			}
+		}, threadSummaryOf)
+	};
+	return withBlockHooks({
+		open,
+		openDirect: (userIds) => open({
+			kind: new Set(userIds).size > 1 ? "group_dm" : "dm",
+			memberIds: userIds
+		}),
+		openSubject: (subject) => open({
+			kind: "subject",
+			subject
+		}),
+		addMembers: (conversationId, userIds) => call("add_conversation_members", {
+			conversation: conversationId,
+			users: [...userIds]
+		}, num),
+		removeMember: (conversationId, userId) => call("remove_conversation_member", {
+			conversation: conversationId,
+			member: userId
+		}, (value) => value === true),
+		archive: (conversationId, archived = true) => call("archive_conversation", {
+			conversation: conversationId,
+			archived
+		}, (value) => value === true),
+		conversations: (list = {}) => tenant().andThen((organizationId) => call("list_conversations", {
+			tenant: organizationId,
+			kinds: list.kinds === void 0 ? null : [...list.kinds],
+			max_rows: list.limit ?? null
+		}, (value) => recordsOf(value, "list_conversations").map(summaryOf))),
+		unreadCounts: () => tenant().andThen((organizationId) => call("unread_counts", { tenant: organizationId }, (value) => Object.fromEntries(Object.entries(recordOf(value, "unread_counts")).map(([id, count]) => {
+			const row = recordOf(count, "unread count");
+			return [id, {
+				unread: num(row["unread"]),
+				mentions: num(row["mentions"])
+			}];
+		})))),
+		markRead: (conversationId, read = {}) => call("mark_read", {
+			conversation: conversationId,
+			thread: read.threadId ?? null,
+			read_at: instantArg(read.readAt) ?? null
+		}, (value) => requiredInstant(value, "readAt")),
+		setNotify: (conversationId, level) => call("set_conversation_notify", {
+			conversation: conversationId,
+			level
+		}, (value) => value === true),
+		typing: (conversationId, typing = true) => call("set_typing", {
+			conversation: conversationId,
+			typing
+		}, (value) => value === true),
+		follow: (target, following = true) => call("follow", "conversationId" in target ? {
+			target_type: "conversation",
+			target_id: target.conversationId,
+			following
+		} : {
+			target_type: "thread",
+			target_id: target.threadId,
+			following
+		}, (value) => value === true),
+		can: (conversationId, action) => call("can_conversation", {
+			conversation: conversationId,
+			action
+		}, (value) => value === true),
+		send: (conversationId, message) => fields.args(message.fields).andThen((checked) => one("send_message", {
+			conversation: conversationId,
+			body: message.body,
+			attrs: {
+				...message.parentId === void 0 ? {} : { parentId: message.parentId },
+				...message.document === void 0 ? {} : { document: message.document },
+				...message.anchor === void 0 ? {} : { anchor: message.anchor },
+				...message.mentionIds === void 0 ? {} : { mentions: [...message.mentionIds] },
+				...message.broadcast === void 0 ? {} : { broadcast: message.broadcast },
+				...message.scheduledFor === void 0 ? {} : { scheduledFor: message.scheduledFor.toString() },
+				...checked === void 0 ? {} : { fields: checked }
+			},
+			attachments: [...message.attachmentIds ?? []]
+		})),
+		edit: (messageId, edition) => fields.args(edition.fields).andThen((checked) => one("edit_message", {
+			message: messageId,
+			body: edition.body,
+			attrs: {
+				...edition.document === void 0 ? {} : { document: edition.document },
+				...edition.mentionIds === void 0 ? {} : { mentions: [...edition.mentionIds] },
+				...checked === void 0 ? {} : { fields: checked }
+			}
+		})),
+		remove: (messageId) => call("delete_message", { message: messageId }, (value) => value === true),
+		pin: (messageId, pinned = true) => one("pin_message", {
+			message: messageId,
+			pinned
+		}),
+		resolve: (messageId, resolved = true) => one("resolve_message", {
+			message: messageId,
+			resolved
+		}),
+		list: (conversationId, list = {}) => many("list_messages", {
+			conversation: conversationId,
+			...cursorArgs("after", list.after),
+			...cursorArgs("before", list.before),
+			max_rows: list.limit ?? null
+		}),
+		replies: (messageId, list = {}) => many("list_replies", {
+			message: messageId,
+			...cursorArgs("after", list.after),
+			max_rows: list.limit ?? null
+		}),
+		anchoredTo: (attachmentId, list = {}) => many("list_file_anchors", {
+			attachment: attachmentId,
+			max_rows: list.limit ?? null
+		}),
+		get: (messageId) => call("get_message", { message: messageId }, (value) => value === null || value === void 0 ? void 0 : messageOf(value)).andThen((message) => message === void 0 ? fields.rows([]).map(() => void 0) : fields.row(message)),
+		edits: (messageId) => call("list_message_edits", { message: messageId }, (value) => recordsOf(value, "list_message_edits").map(editOf)),
+		pinned: (conversationId) => many("list_pinned_messages", { conversation: conversationId }),
+		recordMentions: (subject, list = {}) => call("list_record_mentions", {
+			subject_type: subject.type,
+			subject_id: subject.id,
+			...cursorArgs("before", list.before),
+			max_rows: list.limit ?? null
+		}, (value) => recordsOf(value, "list_record_mentions").map(mentionOf)).andThen((found) => fields.rows(found.map((item) => item.message)).map((messages) => found.map((item, index) => ({
+			conversation: item.conversation,
+			message: messages[index]
+		})))),
+		publishDue: (limit) => call("publish_due_messages", { max_rows: limit ?? null }, num),
+		summary: currentSummary,
+		summarize: (target, summarizer, summarizeOptions) => summarize(steps, target, summarizer, summarizeOptions)
+	}, options.hooks, {
+		block: "messaging",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { createMessaging as t };

package/dist/messaging-CZ6aWb10.d.ts

@@ -0,0 +1,297 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { t as Author } from "./block-authors-DzXLUiIq.js";
+import { a as ThreadSummary, i as ThreadSummarizer, r as SummaryTarget, t as SummarizeOptions } from "./summaries-8jQTELIX.js";
+//#region src/blocks/messaging/messaging.d.ts
+/** What a conversation is for. */
+type ConversationKind = "channel" | "dm" | "group_dm" | "subject" | "inbox";
+/**
+ * Who reads a conversation: its members, everyone in the tenant who holds
+ * `messages.read`, or whoever reads its record.
+ */
+type ConversationAccess = "members" | "tenant" | "subject";
+/** How a member hears of new messages. */
+type NotifyLevel = "all" | "mentions" | "none";
+interface Conversation {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly kind: ConversationKind;
+  readonly access: ConversationAccess;
+  /** The record of a `subject` conversation. */
+  readonly subject: SubjectRef | undefined;
+  readonly title: string | undefined;
+  readonly createdBy: string | undefined;
+  readonly lastMessageAt: Temporal.Instant | undefined;
+  readonly archivedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A conversation from `listConversations`, with the caller's read state. */
+interface ConversationSummary extends Conversation {
+  /** Top-level messages from others since the caller's read marker. */
+  readonly unread: number;
+  /** How many of those mention the caller, `@channel` and `@here` included. */
+  readonly mentions: number;
+  readonly lastReadAt: Temporal.Instant | undefined;
+  readonly notify: NotifyLevel;
+}
+/** A file on a message, from the `attachments` module. */
+interface MessageFile {
+  readonly id: string;
+  readonly name: string;
+  readonly mimeType: string | undefined;
+  readonly size: number | undefined;
+  /** `pending` until scanned when the bucket requires a scan. */
+  readonly status: string;
+}
+/** One emoji on a message, from the `reactions` module. */
+interface MessageReaction {
+  readonly emoji: string;
+  readonly count: number;
+  readonly reacted: boolean;
+  readonly actors: readonly string[];
+}
+type MessageKind = "message" | "note";
+/** A message. `F` types the extra columns the `fields` schema describes. */
+interface Message<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly conversationId: string;
+  /** The message this replies to. */
+  readonly parentId: string | undefined;
+  /** The thread's root message; `undefined` for a top-level message. */
+  readonly threadId: string | undefined;
+  /** `undefined` once the author's account is deleted. */
+  readonly authorId: string | undefined;
+  /** The author's name and avatar, with the `profiles` module. */
+  readonly author: Author | undefined;
+  /** `note` is an inbox's internal note, which only its staff read. */
+  readonly kind: MessageKind;
+  /** Empty for a deleted message. */
+  readonly body: string;
+  /** The rich-text document an editor wrote, next to `body` as plain text. */
+  readonly document: unknown;
+  /**
+   * Where on the record a top-level message points, such as a text range or a
+   * field (any JSON); `undefined` without one.
+   */
+  readonly anchor: unknown;
+  readonly mentionIds: readonly string[];
+  /** `channel` or `here` when the body says `@channel` or `@here`. */
+  readonly mentionScope: "channel" | "here" | undefined;
+  /** A reply also shown in the conversation. */
+  readonly broadcast: boolean;
+  readonly replyCount: number;
+  readonly lastReplyAt: Temporal.Instant | undefined;
+  /** The first three people who replied. */
+  readonly replyUserIds: readonly string[];
+  readonly pinnedAt: Temporal.Instant | undefined;
+  readonly pinnedBy: string | undefined;
+  readonly resolvedAt: Temporal.Instant | undefined;
+  readonly resolvedBy: string | undefined;
+  /** A scheduled message has `scheduledFor` and no `sentAt` yet. */
+  readonly scheduledFor: Temporal.Instant | undefined;
+  readonly sentAt: Temporal.Instant | undefined;
+  readonly editedAt: Temporal.Instant | undefined;
+  readonly deletedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+  /** Empty without the `attachments` module. */
+  readonly attachments: readonly MessageFile[];
+  /** Empty without the `reactions` module. */
+  readonly reactions: readonly MessageReaction[];
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+/** An earlier version of an edited message. */
+interface MessageEdit {
+  readonly id: string;
+  readonly messageId: string;
+  readonly body: string;
+  readonly document: unknown;
+  readonly editedBy: string | undefined;
+  readonly editedAt: Temporal.Instant;
+}
+interface NewMessage<F extends object = Record<never, never>> {
+  /** Plain text; `@[Name](<user id>)` mentions a user. */
+  readonly body: string;
+  /** A rich-text document (any JSON); keep `body` as its plain text. */
+  readonly document?: unknown;
+  /** Where on the record a top-level message points (any JSON). */
+  readonly anchor?: unknown;
+  /** User ids, merged with the ones the body's markup mentions. */
+  readonly mentionIds?: readonly string[];
+  /** A reply: with one level of threads, a reply to a reply joins the root. */
+  readonly parentId?: string;
+  /** A reply also shown in the conversation. */
+  readonly broadcast?: boolean;
+  /** Sends later: with the `jobs` module, or a cron that runs `publishDue`. */
+  readonly scheduledFor?: Temporal.Instant;
+  /** Files the caller uploaded to the conversation (`attachments`). */
+  readonly attachmentIds?: readonly string[];
+  readonly fields?: Partial<F>;
+}
+interface MessageEdition<F extends object = Record<never, never>> {
+  readonly body: string;
+  /** `null` removes the document; leaving it out keeps it. */
+  readonly document?: unknown;
+  readonly mentionIds?: readonly string[];
+  readonly fields?: Partial<F>;
+}
+interface OpenConversation {
+  readonly kind: "channel" | "dm" | "group_dm" | "subject";
+  /** A channel's name. */
+  readonly title?: string;
+  /** A channel's access: `members` (private) or `tenant`. Default `members`. */
+  readonly access?: "members" | "tenant";
+  /** The record of a `subject` conversation. */
+  readonly subject?: SubjectRef;
+  /** The members besides the caller. */
+  readonly memberIds?: readonly string[];
+}
+/** Where a page of messages starts: a message's `sentAt` and `id`. */
+interface MessageCursor {
+  readonly sentAt: Temporal.Instant;
+  readonly id: string;
+}
+interface MessageListOptions {
+  /** The newest messages before this one. */
+  readonly before?: MessageCursor;
+  /** The oldest messages after this one, for catching up. */
+  readonly after?: MessageCursor;
+  readonly limit?: number;
+}
+/** A sent message that mentions a record, from `recordMentions`. */
+interface RecordMention<F extends object = Record<never, never>> {
+  readonly message: Message<F>;
+  /** The message's conversation: a channel, a direct message, a record's thread. */
+  readonly conversation: {
+    readonly id: string;
+    readonly kind: ConversationKind;
+    readonly title: string | undefined;
+    /** The record of a `subject` conversation. */
+    readonly subject: SubjectRef | undefined;
+  };
+}
+interface UnreadCount {
+  readonly unread: number;
+  readonly mentions: number;
+}
+/** What `follow` follows: a whole conversation or one thread. */
+type FollowTarget = {
+  readonly conversationId: string;
+} | {
+  readonly threadId: string;
+};
+/** Every method that takes no id acts in the block's `tenant`. */
+interface Messaging<F extends object = Record<never, never>> {
+  /**
+   * Opens a conversation. A direct or group message and a record's conversation
+   * are opened once: opening again returns the same one.
+   */
+  open(conversation: OpenConversation): AsyncResult<Conversation>;
+  /** Opens the direct (one other person) or group message with `userIds`. */
+  openDirect(userIds: readonly string[]): AsyncResult<Conversation>;
+  /** The conversation of a record, read by whoever reads the record. */
+  openSubject(subject: SubjectRef): AsyncResult<Conversation>;
+  /** Returns how many joined. Members add members; anyone joins a tenant one. */
+  addMembers(conversationId: string, userIds: readonly string[]): AsyncResult<number>;
+  /** A member leaves, or the owner or a moderator removes them. */
+  removeMember(conversationId: string, userId: string): AsyncResult<boolean>;
+  archive(conversationId: string, archived?: boolean): AsyncResult<boolean>;
+  /** The caller's conversations, latest message first. */
+  conversations(options?: {
+    readonly kinds?: readonly ConversationKind[];
+    readonly limit?: number;
+  }): AsyncResult<ConversationSummary[]>;
+  /** Unread counts by conversation id, for the conversations with any. */
+  unreadCounts(): AsyncResult<Readonly<Record<string, UnreadCount>>>;
+  /** Moves the caller's read marker forward; returns where it is. */
+  markRead(conversationId: string, options?: {
+    readonly threadId?: string;
+    readonly readAt?: Temporal.Instant;
+  }): AsyncResult<Temporal.Instant>;
+  setNotify(conversationId: string, level: NotifyLevel): AsyncResult<boolean>;
+  /** Broadcasts typing on the conversation's topic. */
+  typing(conversationId: string, typing?: boolean): AsyncResult<boolean>;
+  /** With the `notifications` module: hear of every message, or none. */
+  follow(target: FollowTarget, following?: boolean): AsyncResult<boolean>;
+  can(conversationId: string, action: "read" | "send" | "moderate"): AsyncResult<boolean>;
+  send(conversationId: string, message: NewMessage<F>): AsyncResult<Message<F>>;
+  /** The author edits within `editWindow`; the old version is kept. */
+  edit(messageId: string, edition: MessageEdition<F>): AsyncResult<Message<F>>;
+  /** The author or a moderator; the message stays as a placeholder. */
+  remove(messageId: string): AsyncResult<boolean>;
+  pin(messageId: string, pinned?: boolean): AsyncResult<Message<F>>;
+  /** Resolves a thread by its root message, or opens it again. */
+  resolve(messageId: string, resolved?: boolean): AsyncResult<Message<F>>;
+  /** A page of top-level messages (and broadcast replies), oldest first. */
+  list(conversationId: string, options?: MessageListOptions): AsyncResult<Message<F>[]>;
+  /** A thread's replies, oldest first. */
+  replies(messageId: string, options?: {
+    readonly after?: MessageCursor;
+    readonly limit?: number;
+  }): AsyncResult<Message<F>[]>;
+  /** The top-level messages anchored to a file (`fileAnchor`), oldest first. */
+  anchoredTo(attachmentId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<Message<F>[]>;
+  /** One message, or `undefined`: for a Realtime ping's id. */
+  get(messageId: string): AsyncResult<Message<F> | undefined>;
+  edits(messageId: string): AsyncResult<MessageEdit[]>;
+  pinned(conversationId: string): AsyncResult<Message<F>[]>;
+  /**
+   * The sent messages that mention a record (`@[Name](subject:<type>/<id>)`),
+   * newest first: its backlinks. Only the messages the caller reads, and none
+   * when they can't read the record.
+   */
+  recordMentions(subject: SubjectRef, options?: {
+    readonly before?: MessageCursor;
+    readonly limit?: number;
+  }): AsyncResult<RecordMention<F>[]>;
+  /** The service role sends the scheduled messages that are due. */
+  publishDue(limit?: number): AsyncResult<number>;
+  /**
+   * The summary of a thread or of a conversation's top-level messages, with
+   * whether it is stale; `undefined` before the first one.
+   */
+  summary(target: SummaryTarget): AsyncResult<ThreadSummary | undefined>;
+  /**
+   * Returns the summary while it is current. Otherwise reads the newest
+   * messages as the caller (internal notes left out), asks `summarizer` and
+   * saves what it wrote through the `service` transport.
+   */
+  summarize(target: SummaryTarget, summarizer: ThreadSummarizer, options?: SummarizeOptions): AsyncResult<ThreadSummary>;
+}
+interface MessagingOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * Calls as the service role, to save thread summaries: `rpcTransport(admin)`.
+   * Default `transport`.
+   */
+  readonly service?: BlockTransport;
+  /** The module schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the message's extra columns
+   * (`blocks.messaging.options.extraColumns`), keyed by database name.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Messaging<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The messaging block: channels, direct and group messages and record
+ * conversations, with threads, mentions, edits, pins, resolved threads,
+ * scheduled sends, read markers, files and reactions.
+ */
+declare function createMessaging<S extends StandardSchemaV1 | undefined = undefined>(options: MessagingOptions<S>): Messaging<FieldsOf<S>>;
+//#endregion
+export { NotifyLevel as _, FollowTarget as a, UnreadCount as b, MessageEdit as c, MessageKind as d, MessageListOptions as f, NewMessage as g, MessagingOptions as h, ConversationSummary as i, MessageEdition as l, Messaging as m, ConversationAccess as n, Message as o, MessageReaction as p, ConversationKind as r, MessageCursor as s, Conversation as t, MessageFile as u, OpenConversation as v, createMessaging as x, RecordMention as y };

package/dist/mfa-wrx1rqJT.d.ts

@@ -0,0 +1,36 @@
+import { b as DbError } from "./result-C6jDfedy.js";
+//#region src/auth/mfa.d.ts
+/**
+ * Authenticator assurance level: `aal2` once a second factor is verified in
+ * this session.
+ */
+type Aal = "aal1" | "aal2";
+/** One way the user proved who they are in this session (the JWT `amr` claim). */
+interface AmrEntry {
+  /** `password`, `otp`, `oauth`, `totp`, `sso/saml`, `anonymous`, ... */
+  readonly method: string;
+  /** Seconds since epoch. */
+  readonly timestamp: number;
+  /** SSO provider id, for `sso/saml`. */
+  readonly provider?: string;
+}
+/**
+ * The session's assurance level from its claims; anything but `aal2` reads as
+ * `aal1`.
+ */
+declare function aalOf(claims: Readonly<Record<string, unknown>>): Aal;
+/** The `amr` claim as typed entries, skipping malformed ones. */
+declare function amrOf(claims: Readonly<Record<string, unknown>>): readonly AmrEntry[];
+/**
+ * `undefined` when a user session meets `required`; otherwise a `forbidden`
+ * error with `required` and code `INSUFFICIENT_AAL`, for the client to start an
+ * MFA challenge. Non-user sessions pass: `allow` decides about them.
+ */
+declare function checkAal(auth: {
+  readonly kind: "user";
+  readonly claims: object;
+} | {
+  readonly kind: string;
+}, required: Aal): DbError | undefined;
+//#endregion
+export { checkAal as a, amrOf as i, AmrEntry as n, aalOf as r, Aal as t };