better-supabase 0.14.0 → 0.15.0

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

@@ -1,11 +1,179 @@
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-d53POsem.js";
-import { O as CommentsSqlOptions } from "../../authorization-BuT26_sR.js";
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, b as DbError, f as Result, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "../../standard-DBV730sF.js";
+import { r as FieldsOf } from "../../block-fields-BE7pInWZ.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { N as CommentsSqlOptions } from "../../authorization-HZdJCaVm.js";
 import { t as Author } from "../../block-authors-DzXLUiIq.js";
 import { a as isFileAnchor, i as fileAnchor, n as FileAnchor, o as conversationTopic, r as FileAnchorAt, t as AnchorRegion } from "../../anchors-7F34QyHa.js";
-import { c as MessageEdit } from "../../messaging-CZ6aWb10.js";
-import { Gt as SectionWrite, Lt as Section, Wt as SectionRowInput, c as BlockOf, rn as EntitySchema } from "../../define-block-COpcS6aT.js";
-import { a as CommentsSnapshot, c as CommentAssignment, d as CommentsOptions, f as ListCommentsOptions, h as mentionsIn, i as CommentsControllerOptions, l as CommentEdit, m as createComments, n as CommentsActions, o as createCommentsController, p as NewComment, r as CommentsController, s as Comment, t as CommentDraft, u as Comments } from "../../client-CA6KuLDu.js";
-//#region src/blocks/comments/section.d.ts
+import { c as MessageEdit, l as MessageEdition, o as Message } from "../../messaging-C_Pr9tGx.js";
+import { Sn as EntitySchema, c as BlockOf, ln as RecordBindingWrite, mn as RecordRowInput, rn as RecordBinding } from "../../define-block-BVcLQ3DF.js";
+import { p as SubscriptionStatus } from "../../topic-CJrQZQaa.js";
+import { n as TopicPort } from "../../watch-topic-BcGfvZOE.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+//#region src/blocks/comments/comments.d.ts
+interface CommentsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions, BlockTenantOptions {
+  /**
+   * A Standard Schema for the message extra columns
+   * (`blocks.messaging.options.extraColumns`), keyed by database name. It types
+   * and parses them on reads, and validates them on `create` and `edit`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Comments<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /**
+   * The user ids (or mention groups) a comment mentions when the call passes no
+   * `mentionIds`, such as the mention nodes of a rich-text `document`. Default
+   * `mentionsIn(body)`.
+   */
+  readonly mentionsOf?: (comment: {
+    readonly body: string;
+    readonly document: unknown;
+  }) => readonly string[];
+}
+/**
+ * A comment: a message in its record's conversation. `F` types the extra
+ * columns the `fields` schema describes.
+ */
+interface Comment<F extends object = Record<never, never>> extends Message<F> {
+  /** The record the comment is on. */
+  readonly subject: RecordRef;
+  /** The work item `assign` turned it into, with the `tasks` block. */
+  readonly taskId: string | undefined;
+}
+interface NewComment<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 the comment points, such as a text range or a field
+   * (any JSON), or a page, region or moment of a file (`fileAnchor`). Top-level
+   * comments only.
+   */
+  readonly anchor?: unknown;
+  /**
+   * User ids or mention groups (`options.mentionGroups`); default `mentionsOf`,
+   * or the ids `mentionsIn(body)` finds.
+   */
+  readonly mentionIds?: readonly string[];
+  /** A reply: with one level of threads, a reply to a reply joins the root. */
+  readonly parentId?: string;
+  /** Files the caller uploaded to the record's conversation (`attachments`). */
+  readonly attachmentIds?: readonly string[];
+  /** The extra columns to set, keyed by database name. */
+  readonly fields?: Partial<F>;
+}
+/** What `edit` takes. */
+type CommentEdit<F extends object = Record<never, never>> = MessageEdition<F>;
+/** What `assign` passes to the work item. */
+interface CommentAssignment {
+  /** Who works on it; nobody when left out. */
+  readonly assigneeId?: string;
+  /** Default the comment's first 120 characters. */
+  readonly title?: string;
+  /** Default the comment's body. */
+  readonly body?: string;
+  /** Other `create_work_item` attributes, such as `projectId` or `priority`. */
+  readonly attrs?: Readonly<Record<string, unknown>>;
+}
+interface ListCommentsOptions extends CursorPageOptions<Temporal.Instant> {
+  /** Comments sent after this instant, for polling a thread. */
+  readonly cursor?: Temporal.Instant;
+  /**
+   * The id of the last comment you have, next to `cursor`, so comments sent in
+   * the same instant as it aren't skipped.
+   */
+  readonly cursorId?: string;
+  /** Default 100, at most 500. */
+  readonly limit?: number;
+  /** Comments to skip, for page-number paging. */
+  readonly offset?: number;
+}
+/**
+ * `F` is the extra fields `options.fields` describes. Every method that takes a
+ * record acts in the block's `tenant`.
+ */
+interface Comments<F extends object = Record<never, never>> {
+  /** Posts a comment on `subject`, opening its conversation the first time. */
+  create(subject: RecordRef, comment: NewComment<F>): AsyncResult<Comment<F>>;
+  /** One comment, or `not_found` when the caller can't read it. */
+  get(id: string): AsyncResult<Comment<F>>;
+  /** The top-level comments anchored to a file (`fileAnchor`), oldest first. */
+  anchoredTo(attachmentId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<Comment<F>[]>;
+  /** The author edits within `editWindow`; the old version is kept. */
+  edit(id: string, edit: CommentEdit<F>): AsyncResult<Comment<F>>;
+  /** Soft-deletes (the author, or a member with `comments.moderate`). */
+  remove(id: string): AsyncResult<boolean>;
+  /** Resolves a thread by its root comment, or opens it again. */
+  resolve(id: string, resolved?: boolean): AsyncResult<Comment<F>>;
+  /** Pins a comment to the top of its record, or unpins it. */
+  pin(id: string, pinned?: boolean): AsyncResult<Comment<F>>;
+  /** The earlier versions of an edited comment, newest first. */
+  edits(id: string): AsyncResult<readonly MessageEdit[]>;
+  /**
+   * Turns a comment into a work item (with the `tasks` block) and returns its
+   * id; assigning it again returns the same one.
+   */
+  assign(id: string, assignment?: CommentAssignment): AsyncResult<string>;
+  /**
+   * A record's comments and replies, oldest first, deleted ones as
+   * placeholders.
+   */
+  list(subject: RecordRef, options?: ListCommentsOptions): AsyncResult<readonly Comment<F>[]>;
+  /**
+   * How many comments each subject has that the caller can read, deleted ones
+   * left out, such as for a counter on each row of a list, keyed by
+   * `subjectKey(subject)` (`type:id`). Subjects without comments are 0.
+   */
+  counts(subjects: readonly RecordRef[]): AsyncResult<Readonly<Record<string, number>>>;
+  /**
+   * Copies a subject's thread to another subject in the tenant, keeping
+   * authors, times and replies; returns how many comments it copied. Needs a
+   * service-role transport.
+   */
+  copy(from: RecordRef, to: RecordRef): AsyncResult<number>;
+  /**
+   * The record's conversation id, for Realtime (`conversationTopic`) and for
+   * uploads to attach (`attachments` on subject `conversation`). `open` creates
+   * it before the first comment; without it, `undefined` until then.
+   */
+  conversation(subject: RecordRef, options?: {
+    readonly open?: boolean;
+  }): AsyncResult<string | undefined>;
+  /**
+   * Moves the caller's read marker on the record's comments forward; returns
+   * where it is, or `undefined` before the first comment.
+   */
+  markRead(subject: RecordRef, options?: {
+    readonly readAt?: Temporal.Instant;
+  }): AsyncResult<Temporal.Instant | undefined>;
+}
+/**
+ * The user ids mentioned in a body written as `@[Ada](user:<user id>)` or
+ * `@[Ada](<user id>)`, the markup mention inputs produce, in order and without
+ * repeats.
+ */
+export declare function mentionsIn(body: string): readonly string[];
+/** Comments over the messaging core, as the caller. */
+export declare function createComments<S extends StandardSchemaV1 | undefined = undefined>(options: CommentsOptions<S>): Comments<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/comments/record-binding.d.ts
 /** A pending write to a thread, for `useOptimistic`. */
 type CommentsOptimisticAction = {
   readonly type: "add";
@@ -23,24 +191,73 @@ type CommentsOptimisticAction = {
  * comment with the same id), `edit` changes the body, `remove` takes it out.
  */
 export declare function commentsOptimistic(state: readonly Comment[], action: CommentsOptimisticAction): readonly Comment[];
-/** The writes of the comments section. */
+/** The writes of the comments binding. */
 type CommentsWrites = {
   /** Adds a comment to the record's thread. */
-  readonly add: SectionWrite<Comments, NewComment, Comment>;
+  readonly add: RecordBindingWrite<Comments, NewComment, Comment>;
   /** Removes one comment; its author or a moderator. */
-  readonly remove: SectionWrite<Comments, SectionRowInput, boolean>;
+  readonly remove: RecordBindingWrite<Comments, RecordRowInput, boolean>;
 };
 /**
  * A record's comment thread, oldest first. The messaging events make it stale:
  * a record conversation's messages carry `conversationKind: "subject"`.
  */
-export declare const commentsSection: Section<Comments, readonly Comment[], ListCommentsOptions, CommentsOptimisticAction, CommentsWrites>;
+export declare const commentsBinding: RecordBinding<Comments, readonly Comment[], ListCommentsOptions, CommentsOptimisticAction, CommentsWrites>;
 //#endregion
 //#region src/blocks/comments/manifest.d.ts
 /** The `comments` block's manifest (ADR 0029, ADR 0062). */
-export declare const commentsBlock: BlockOf<"comments", typeof createComments, Record<never, never>, Record<never, never>, never, {
-  readonly comments: typeof commentsSection;
-}>;
+export declare const commentsBlock: BlockOf<"comments", typeof createComments, Record<never, never>, Record<never, never>, never, typeof commentsBinding>;
+//#endregion
+//#region src/blocks/comments/client.d.ts
+interface CommentsControllerOptions {
+  readonly client: Pick<Comments, "list" | "get" | "create" | "edit" | "remove" | "resolve" | "pin" | "conversation">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The subject whose thread to follow; the thread waits without one. */
+  readonly subject: RecordRef | null;
+  /**
+   * `blocks.messaging.options.topic`, default `messages`: the thread joins the
+   * record conversation's private topic and fetches the comment each ping
+   * names, with its thread's root for the reply count. `null` turns Realtime
+   * off, so the thread loads again after its own writes only.
+   */
+  readonly topic?: string | null;
+  /** The most comments to load, default 100, at most 500. */
+  readonly limit?: number;
+}
+interface CommentsSnapshot {
+  /**
+   * The thread, oldest first, deleted comments as placeholders; `undefined`
+   * until the first load.
+   */
+  readonly comments: readonly Comment[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+/** A reply, a rich-text document, an anchor, mentions or files for `add`. */
+type CommentDraft = Omit<NewComment, "body">;
+interface CommentsActions {
+  /** Posts a comment on the subject; a failure is also kept in `error`. */
+  readonly add: (body: string, draft?: CommentDraft) => Promise<Result<Comment>>;
+  /** Edits one of the caller's comments. */
+  readonly edit: (id: string, edit: CommentEdit) => Promise<Result<Comment>>;
+  /** Soft-deletes a comment: it stays in the thread as a placeholder. */
+  readonly remove: (id: string) => Promise<Result<boolean>>;
+  /** Resolves a thread by its root comment, or opens it again. */
+  readonly resolve: (id: string, resolved?: boolean) => Promise<Result<Comment>>;
+  readonly pin: (id: string, pinned?: boolean) => Promise<Result<Comment>>;
+  readonly refresh: () => Promise<void>;
+}
+type CommentsController = Controller<CommentsSnapshot, CommentsActions>;
+/**
+ * One subject's comment thread for the signed-in user: loads it, keeps it
+ * current after its own writes, and fetches the one comment each ping on the
+ * record conversation's topic names (joined once the record has a
+ * conversation), so a busy thread never reloads whole.
+ */
+export declare function createCommentsController(options: CommentsControllerOptions): CommentsController;
 //#endregion
 //#region src/blocks/comments/schemas.d.ts
 /**
@@ -51,4 +268,4 @@ export declare const commentInputSchema: EntitySchema<NewComment>;
 /** What `edit` takes: a message edit. */
 export declare const commentChangeSchema: EntitySchema<CommentEdit>;
 //#endregion
-export { type AnchorRegion, type Author, type BlockTransport, type Comment, type CommentAssignment, type CommentDraft, type CommentEdit, type Comments, type CommentsActions, type CommentsController, type CommentsControllerOptions, type CommentsOptimisticAction, type CommentsOptions, type CommentsSnapshot, type CommentsSqlOptions, type CommentsWrites, type FileAnchor, type FileAnchorAt, type ListCommentsOptions, type MessageEdit, type NewComment, conversationTopic, createComments, createCommentsController, dbTransport, fileAnchor, isFileAnchor, mentionsIn, rpcTransport, sqlTransport };
+export { type AnchorRegion, type Author, type BlockTransport, type Comment, type CommentAssignment, type CommentDraft, type CommentEdit, type Comments, type CommentsActions, type CommentsController, type CommentsControllerOptions, type CommentsOptimisticAction, type CommentsOptions, type CommentsSnapshot, type CommentsSqlOptions, type CommentsWrites, type FileAnchor, type FileAnchorAt, type ListCommentsOptions, type MessageEdit, type NewComment, conversationTopic, dbTransport, fileAnchor, isFileAnchor, rpcTransport, sqlTransport };

package/dist/blocks/comments/index.js

@@ -1,12 +1,149 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { r as err, t as AsyncResult } from "../../result-ntFBW2p2.js";
 import { t as commentsSqlOptions } from "../../options-DrSkIBCD.js";
-import { B as dbTransport, H as rpcTransport, U as sqlTransport } from "../../block-helpers-CiKtrb6g.js";
-import { n as entitySchema } from "../../entity-schema-BXXC1NnT.js";
-import { r as sectionRowInput, t as defineSection } from "../../sections-DjxYmpu-.js";
-import { n as defineBlock } from "../../define-block-Dze77QTw.js";
-import { t as conversationTopic } from "../../rows-Bb0EPupt.js";
-import { i as isFileAnchor, r as fileAnchor, t as messageChangeSchema } from "../../schemas-9Ci3K0Hk.js";
-import { t as createCommentsController } from "../../client-B1cjaIfv.js";
-import { n as mentionsIn, t as createComments } from "../../comments-CB8pFSV1.js";
+import { n as whileSignedIn, t as defineController } from "../../controller-BEliOBOv.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, U as sqlTransport, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall, w as pageOf } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
+import { i as recordRowInput, t as defineRecordBinding } from "../../record-bindings-DkBJpC5A.js";
+import { n as blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { i as subjectRefOf, t as bySubjectType } from "../../block-subjects-BhDKK_j7.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+import { n as editOf, r as messageOf, t as conversationTopic } from "../../rows-BDLZStp4.js";
+import { i as isFileAnchor, o as parseMentions, r as fileAnchor, t as messageChangeSchema } from "../../schemas-l2aF78zQ.js";
+//#region src/blocks/comments/comments.ts
+/**
+* The user ids mentioned in a body written as `@[Ada](user:<user id>)` or
+* `@[Ada](<user id>)`, the markup mention inputs produce, in order and without
+* repeats.
+*/
+function mentionsIn(body) {
+	return parseMentions(body).users;
+}
+/** A row of `list_comments` or `create_comment`. */
+function commentOf(value) {
+	const row = recordOf(value, "comment");
+	return {
+		...messageOf(row),
+		subject: subjectRefOf(row["subject_type"], row["subject_id"]),
+		taskId: optionalText(row["task_id"])
+	};
+}
+const notFound = () => dbError("not_found", "No comment you can read has this id", { hint: "COMMENT_NOT_FOUND" });
+/** Comments over the messaging core, as the caller. */
+function createComments(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "comment fields");
+	const tenant = () => requireOrganization(options.tenant);
+	const mentionsOf = (body, rich) => options.mentionsOf ? options.mentionsOf({
+		body,
+		document: rich
+	}) : mentionsIn(body);
+	const get = (id) => call("get_comment", { message: id }, (value) => value === null || value === void 0 ? void 0 : commentOf(value)).andThen((comment) => comment === void 0 ? AsyncResult.err(notFound()) : fields.row(comment));
+	const conversation = (subject, open = {}) => tenant().andThen((organizationId) => open.open === true ? call("open_conversation", {
+		tenant: organizationId,
+		kind: "subject",
+		attrs: {
+			subjectType: subject.type,
+			subjectId: subject.id
+		},
+		members: []
+	}, (value) => optionalText(recordOf(value, "conversation")["id"])) : call("comment_conversation", {
+		tenant: organizationId,
+		subject_type: subject.type,
+		subject_id: subject.id
+	}, optionalText));
+	return withBlockHooks({
+		create: (subject, comment) => tenant().andThen((organizationId) => fields.args(comment.fields).andThen((checked) => call("create_comment", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			body: comment.body,
+			attrs: {
+				mentions: [...comment.mentionIds ?? mentionsOf(comment.body, comment.document)],
+				...comment.parentId === void 0 ? {} : { parentId: comment.parentId },
+				...comment.document === void 0 ? {} : { document: comment.document },
+				...comment.anchor === void 0 ? {} : { anchor: comment.anchor },
+				...checked === void 0 ? {} : { fields: checked }
+			},
+			attachments: [...comment.attachmentIds ?? []]
+		}, commentOf).andThen(fields.row))),
+		get,
+		edit: (id, edit) => fields.args(edit.fields).andThen((checked) => call("edit_message", {
+			message: id,
+			body: edit.body,
+			attrs: {
+				mentions: [...edit.mentionIds ?? mentionsOf(edit.body, edit.document)],
+				...edit.document === void 0 ? {} : { document: edit.document },
+				...checked === void 0 ? {} : { fields: checked }
+			}
+		}, () => void 0)).andThen(() => get(id)),
+		remove: (id) => call("delete_message", { message: id }, (value) => value === true),
+		resolve: (id, resolved = true) => call("resolve_message", {
+			message: id,
+			resolved
+		}, () => void 0).andThen(() => get(id)),
+		pin: (id, pinned = true) => call("pin_message", {
+			message: id,
+			pinned
+		}, () => void 0).andThen(() => get(id)),
+		edits: (id) => call("list_message_edits", { message: id }, (value) => recordsOf(value, "list_message_edits").map(editOf)),
+		assign: (id, assignment = {}) => call("assign_comment", {
+			message: id,
+			assignee: assignment.assigneeId ?? null,
+			attrs: {
+				...assignment.attrs,
+				...assignment.title === void 0 ? {} : { title: assignment.title },
+				...assignment.body === void 0 ? {} : { body: assignment.body }
+			}
+		}, (value) => {
+			const task = optionalText(value);
+			if (task === void 0) throw new TypeError("assign_comment returned no work item id");
+			return task;
+		}),
+		list: (subject, list = {}) => tenant().andThen((organizationId) => call("list_comments", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			after: instantArg(pageOf(list).cursor),
+			max_rows: list.limit,
+			skip: list.offset,
+			after_id: list.cursorId
+		}, (value) => recordsOf(value, "list_comments").map(commentOf)).andThen(fields.rows)),
+		anchoredTo: (attachmentId, list = {}) => call("list_file_comments", {
+			attachment: attachmentId,
+			max_rows: list.limit
+		}, (value) => recordsOf(value, "list_file_comments").map(commentOf)).andThen(fields.rows),
+		counts: (subjects) => tenant().andThen((organizationId) => bySubjectType(subjects, (type, ids) => call("comment_counts", {
+			tenant: organizationId,
+			subject_type: type,
+			subject_ids: ids
+		}, (value) => {
+			const found = isRecord(value) ? value : {};
+			return Object.fromEntries(ids.map((id) => [id, Number(found[id] ?? 0)]));
+		}))),
+		copy: (from, to) => tenant().andThen((organizationId) => call("copy_comments", {
+			tenant: organizationId,
+			from_type: from.type,
+			from_id: from.id,
+			to_type: to.type,
+			to_id: to.id
+		}, (value) => Number(value ?? 0))),
+		conversation,
+		markRead: (subject, read = {}) => conversation(subject).andThen((id) => id === void 0 ? AsyncResult.ok(void 0) : call("mark_read", {
+			conversation: id,
+			thread: null,
+			read_at: instantArg(read.readAt) ?? null
+		}, (value) => requiredInstant(value, "readAt")))
+	}, options.hooks, {
+		block: "comments",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
 //#region src/blocks/comments/schemas.ts
 /**
 * What `create` takes after the subject. The body's length limit is
@@ -50,7 +187,7 @@ const commentInputSchema = entitySchema({
 /** What `edit` takes: a message edit. */
 const commentChangeSchema = messageChangeSchema;
 //#endregion
-//#region src/blocks/comments/section.ts
+//#region src/blocks/comments/record-binding.ts
 /**
 * The thread with a pending write applied: `add` appends (or replaces the
 * comment with the same id), `edit` changes the body, `remove` takes it out.
@@ -70,7 +207,7 @@ function commentsOptimistic(state, action) {
 * A record's comment thread, oldest first. The messaging events make it stale:
 * a record conversation's messages carry `conversationKind: "subject"`.
 */
-const commentsSection = defineSection({
+const commentsBinding = defineRecordBinding({
 	permissions: {
 		read: "read",
 		write: "create"
@@ -98,7 +235,7 @@ const commentsSection = defineSection({
 			run: (client, subject, input) => client.create(subject, input)
 		},
 		remove: {
-			input: sectionRowInput,
+			input: recordRowInput,
 			run: (client, _subject, { id }) => client.remove(id)
 		}
 	}
@@ -111,7 +248,7 @@ const commentsBlock = defineBlock({
 	sql: ["comments"],
 	options: { comments: commentsSqlOptions },
 	create: createComments,
-	sections: { comments: commentsSection },
+	record: commentsBinding,
 	category: "collaboration",
 	recipes: [
 		"comment-thread",
@@ -121,4 +258,114 @@ const commentsBlock = defineBlock({
 	]
 });
 //#endregion
-export { commentChangeSchema, commentInputSchema, commentsBlock, commentsOptimistic, commentsSection, conversationTopic, createComments, createCommentsController, dbTransport, fileAnchor, isFileAnchor, mentionsIn, rpcTransport, sqlTransport };
+//#region src/blocks/comments/client.ts
+const idOf = (payload, key) => {
+	const value = isRecord(payload) ? payload[key] : void 0;
+	return typeof value === "string" && value !== "" ? value : void 0;
+};
+/**
+* One subject's comment thread for the signed-in user: loads it, keeps it
+* current after its own writes, and fetches the one comment each ping on the
+* record conversation's topic names (joined once the record has a
+* conversation), so a busy thread never reloads whole.
+*/
+function createCommentsController(options) {
+	const { client, subject } = options;
+	const topic = options.topic === void 0 ? "messages" : options.topic;
+	return defineController({
+		comments: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		let leave;
+		let watching = false;
+		const refresh = async () => {
+			if (subject === null) return;
+			ticket += 1;
+			const request = ticket;
+			const result = await client.list(subject, options.limit === void 0 ? {} : { limit: options.limit });
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				comments: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const merge = (comment) => {
+			state.set((current) => {
+				const comments = current.comments ?? [];
+				return {
+					error: void 0,
+					comments: comments.some((each) => each.id === comment.id) ? comments.map((each) => each.id === comment.id ? comment : each) : [...comments, comment]
+				};
+			});
+		};
+		const replace = (comment) => {
+			ticket += 1;
+			merge(comment);
+		};
+		const fetch = async (id) => {
+			const result = await client.get(id);
+			if (result.ok && state.get().comments !== void 0) merge(result.data);
+		};
+		const ping = async (payload) => {
+			const messageId = idOf(payload, "messageId");
+			if (messageId === void 0) return;
+			const threadId = idOf(payload, "threadId");
+			await Promise.all([fetch(messageId), ...threadId === void 0 || threadId === messageId ? [] : [fetch(threadId)]]);
+		};
+		const join = (conversationId) => {
+			if (topic === null || !watching || leave !== void 0) return;
+			leave = options.ports.topic(conversationTopic(conversationId, topic), {
+				onMessage: (_event, payload) => void ping(payload),
+				onRejoin: () => void refresh(),
+				onStatus: (status) => {
+					state.set({ status });
+				}
+			}).leave;
+		};
+		const watch = async () => {
+			if (subject === null || topic === null) return;
+			const found = await client.conversation(subject);
+			if (found.ok && found.data !== void 0) join(found.data);
+		};
+		const write = async (result) => {
+			const settled = await result;
+			if (settled.ok) {
+				replace(settled.data);
+				join(settled.data.conversationId);
+			} else state.set({ error: settled.error });
+			return settled;
+		};
+		return {
+			actions: {
+				refresh,
+				add: (body, draft = {}) => subject === null ? Promise.resolve(err(dbError("invalid_input", "No subject is open"))) : write(client.create(subject, {
+					...draft,
+					body
+				})),
+				edit: (id, edit) => write(client.edit(id, edit)),
+				resolve: (id, resolved) => write(client.resolve(id, resolved)),
+				pin: (id, pinned) => write(client.pin(id, pinned)),
+				remove: async (id) => {
+					const result = await client.remove(id);
+					if (result.ok) await fetch(id);
+					else state.set({ error: result.error });
+					return result;
+				}
+			},
+			start: () => subject === null ? void 0 : whileSignedIn(options.auth, () => {
+				watching = true;
+				refresh();
+				watch();
+				return () => {
+					watching = false;
+					leave?.();
+					leave = void 0;
+				};
+			})
+		};
+	});
+}
+//#endregion
+export { commentChangeSchema, commentInputSchema, commentsBinding, commentsBlock, commentsOptimistic, conversationTopic, createComments, createCommentsController, dbTransport, fileAnchor, isFileAnchor, mentionsIn, rpcTransport, sqlTransport };