better-supabase 0.7.1 → 0.9.0

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

@@ -0,0 +1,184 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { m as CollectionEventData, p as CollectionEntryEventData } from "../../index-BlqrGvb3.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { i as CursorPageOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { t as RankNeighbors } from "../../rank-result-Dngpt2n5.js";
+//#region src/blocks/collections/collections.d.ts
+/** Who sees a collection: its owner, a team, or the whole organization. */
+export declare const COLLECTION_SCOPES: readonly ["user", "team", "tenant"];
+type CollectionScope = (typeof COLLECTION_SCOPES)[number];
+/** A record in `config.subjects`. */
+interface CollectionSubject {
+  readonly type: string;
+  readonly id: string;
+}
+/** A named, static list of records of one subject type. */
+interface Collection {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly scope: CollectionScope;
+  /** The owner of a personal (`user`) collection. */
+  readonly ownerId?: string;
+  /** The team of a `team` collection. */
+  readonly teamId?: string;
+  readonly name: string;
+  readonly description?: string;
+  readonly archived: boolean;
+  readonly archivedAt?: Temporal.Instant;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A record in a collection, with its title and URL from `config.subjects`. */
+interface CollectionEntry {
+  readonly collectionId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly rank: string;
+  readonly addedBy?: string;
+  readonly addedAt: Temporal.Instant;
+  readonly title?: string;
+  readonly url?: string;
+}
+/** Where a page of entries stops: the last entry's rank and id. */
+interface CollectionEntryCursor {
+  readonly rank: string;
+  readonly subjectId: string;
+}
+interface CollectionEntryPage {
+  readonly items: readonly CollectionEntry[];
+  /** Pass as `cursor` for the next page; `undefined` on the last page. */
+  readonly next?: CollectionEntryCursor;
+}
+/** A record the caller starred, with its title and URL from `config.subjects`. */
+interface Star {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly rank: string;
+  readonly starredAt: Temporal.Instant;
+  readonly title?: string;
+  readonly url?: string;
+}
+interface CreateCollectionInput {
+  readonly name: string;
+  /** A type in `config.subjects` with a tenant column. */
+  readonly subjectType: string;
+  /** Default `user`. `team` and `tenant` need `collections.share`. */
+  readonly scope?: CollectionScope;
+  /** The team, for `scope: "team"`. */
+  readonly teamId?: string;
+  readonly description?: string;
+}
+interface RenameCollectionInput {
+  /** Left out keeps the name. */
+  readonly name?: string;
+  /** Left out keeps it; `null` clears it. */
+  readonly description?: string | null;
+}
+interface CollectionListOptions {
+  /** Only collections of this subject type. */
+  readonly subjectType?: string;
+  /** Also archived collections. Default `false`. */
+  readonly includeArchived?: boolean;
+}
+/** The most ids `add`, `remove` and `subjectIds` take or return. */
+export declare const MAX_COLLECTION_IDS = 1e3;
+/** `F` is the extra collection fields `options.fields` describes. */
+interface Collections<F extends object = Record<never, never>> {
+  /** Creates a collection. Shared scopes need `collections.share`. */
+  create(organizationId: string, input: CreateCollectionInput & Partial<F>): AsyncResult<Collection & F>;
+  /** Renames a collection or changes its description. */
+  rename(id: string, input: RenameCollectionInput & Partial<F>): AsyncResult<Collection & F>;
+  /** Archives a collection, or restores it with `archived: false`. */
+  archive(id: string, archived?: boolean): AsyncResult<boolean>;
+  /** The collections the caller sees, by name. */
+  list(organizationId: string, options?: CollectionListOptions): AsyncResult<(Collection & F)[]>;
+  /**
+   * Adds records to the end of a collection, in the given order (at most
+   * 1000). Ids already in it are skipped; resolves to the ids added.
+   */
+  add(id: string, subjectIds: readonly string[]): AsyncResult<{
+    readonly added: readonly string[];
+  }>;
+  /** Removes records from a collection. Resolves to how many were removed. */
+  remove(id: string, subjectIds: readonly string[]): AsyncResult<number>;
+  /** Moves an entry between its neighbours' rank keys. Resolves to its new key. */
+  reorder(id: string, subjectId: string, neighbors: RankNeighbors): AsyncResult<string>;
+  /** A page of entries in rank order (default 50, at most 200). */
+  entries(id: string, options?: CursorPageOptions<CollectionEntryCursor>): AsyncResult<CollectionEntryPage>;
+  /** The ids of the records in a collection, in rank order (default 500, at most 1000). */
+  subjectIds(id: string, options?: {
+    readonly max?: number;
+  }): AsyncResult<string[]>;
+  /**
+   * A repository `where` that keeps a list's rows to a collection's records,
+   * for a saved view with `state.collectionId`: `{ [column]: { in: ids } }`.
+   */
+  where<const C extends string = "id">(id: string, options?: {
+    readonly column?: C;
+    readonly max?: number;
+  }): AsyncResult<{ [K in C]: {
+    in: string[];
+  }; }>;
+  /** The active collections the caller sees that hold a record. */
+  listsOf(subject: CollectionSubject): AsyncResult<Collection[]>;
+  /** Stars a record at the end of the caller's favorites. */
+  star(organizationId: string, subject: CollectionSubject): AsyncResult<Star>;
+  /** Resolves to `false` when the record wasn't starred. */
+  unstar(subject: CollectionSubject): AsyncResult<boolean>;
+  /** The caller's stars in sidebar order, of one subject type with `type`. */
+  starred(organizationId: string, options?: {
+    readonly type?: string;
+  }): AsyncResult<Star[]>;
+  /** Moves a star between its neighbours' rank keys. Resolves to its new key. */
+  reorderStar(subject: CollectionSubject, neighbors: RankNeighbors): AsyncResult<string>;
+}
+interface CollectionsOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the collection columns the app adds
+   * (`blocks.collections.options.extraColumns`), keyed by column name. It
+   * types and parses them on `create`, `rename` and `list`, and validates
+   * them on `create` and `rename`, which return a `validation` error for a
+   * bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Collections<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The collections block: favorites (a member's starred records, ranked for
+ * a sidebar) and lists (named, static collections of one subject type owned
+ * by a user, a team or the organization) on any record in `config.subjects`.
+ */
+export declare function createCollections<S extends StandardSchemaV1 | undefined = undefined>(options: CollectionsOptions<S>): Collections<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/collections/events.d.ts
+/** The events of the `collections` block: type to data. */
+type CollectionsEvents = {
+  readonly "collection.created": CollectionEventData;
+  readonly "collection.archived": CollectionEventData;
+  readonly "collection.entry_added": CollectionEntryEventData;
+  readonly "collection.entry_removed": CollectionEntryEventData;
+};
+/** The `collections` block's event types, for its manifest and `onBlockEvent`. */
+export declare const collectionsEvents: Events<CollectionsEvents>;
+//#endregion
+//#region src/blocks/collections/manifest.d.ts
+/** The `collections` block's manifest (ADR 0029). */
+export declare const collectionsBlock: BlockOf<"collections", typeof createCollections, CollectionsEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Collection, type CollectionEntry, type CollectionEntryCursor, type CollectionEntryPage, type CollectionListOptions, type CollectionScope, type CollectionSubject, type Collections, type CollectionsEvents, type CollectionsOptions, type CreateCollectionInput, type RenameCollectionInput, type RpcClient, type Star, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/collections/index.js

@@ -0,0 +1,208 @@
+import { t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, F as stringsOf, I as textOf, S as optionalInstant, b as oneOf, k as recordsOf, o as blockCall, w as pageOf } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { c as withFields, i as extraOf, n as blockFields, r as extraFieldsArg, t as allWithFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as rankBetweenResult } from "../../rank-result-DS8IoLup.js";
+import { t as collectionsSqlOptions } from "../../options-BOOEzor9.js";
+//#region src/blocks/collections/collections.ts
+/** Who sees a collection: its owner, a team, or the whole organization. */
+const COLLECTION_SCOPES = [
+	"user",
+	"team",
+	"tenant"
+];
+/** The most ids `add`, `remove` and `subjectIds` take or return. */
+const MAX_COLLECTION_IDS = 1e3;
+const CREATE_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"subjectType",
+	"scope",
+	"teamId",
+	"description"
+]);
+const RENAME_KEYS = /* @__PURE__ */ new Set(["name", "description"]);
+/** `{ [key]: value }`, or nothing when `value` is undefined. */
+function optional(key, value) {
+	const out = {};
+	if (value !== void 0) out[key] = value;
+	return out;
+}
+function collectionOf(value) {
+	const row = recordOf(value, "collection");
+	const archivedAt = optionalInstant(row["archivedAt"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		subjectType: textOf(row["subjectType"]),
+		scope: oneOf(row["scope"], COLLECTION_SCOPES, "user"),
+		name: textOf(row["name"]),
+		archived: archivedAt !== void 0,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("ownerId", optionalText(row["ownerId"])),
+		...optional("teamId", optionalText(row["teamId"])),
+		...optional("description", optionalText(row["description"])),
+		...optional("archivedAt", archivedAt),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function entryOf(value) {
+	const row = recordOf(value, "collection entry");
+	return {
+		collectionId: textOf(row["collectionId"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		rank: textOf(row["rank"]),
+		addedAt: requiredInstant(row["addedAt"], "addedAt"),
+		...optional("addedBy", optionalText(row["addedBy"])),
+		...optional("title", optionalText(row["title"])),
+		...optional("url", optionalText(row["url"]))
+	};
+}
+function starOf(value) {
+	const row = recordOf(value, "star");
+	return {
+		organizationId: textOf(row["organizationId"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		rank: textOf(row["rank"]),
+		starredAt: requiredInstant(row["starredAt"], "starredAt"),
+		...optional("title", optionalText(row["title"])),
+		...optional("url", optionalText(row["url"]))
+	};
+}
+function entryPage(rows, limit) {
+	const last = rows.at(-1);
+	return rows.length === (limit ?? 50) && last !== void 0 ? {
+		items: rows,
+		next: {
+			rank: last.rank,
+			subjectId: last.subjectId
+		}
+	} : { items: rows };
+}
+/**
+* The collections block: favorites (a member's starred records, ranked for
+* a sidebar) and lists (named, static collections of one subject type owned
+* by a user, a team or the organization) on any record in `config.subjects`.
+*/
+function createCollections(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "collection fields");
+	const saved = (fn, args, extra) => AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => call(fn, {
+		...args,
+		...more
+	}, (value) => value)).andThen((value) => withFields(fields, value, collectionOf(value)));
+	const subjectIds = (id, max) => call("collection_subject_ids", {
+		collection: id,
+		max_ids: max ?? null
+	}, (value) => [...stringsOf(value)]);
+	return withBlockHooks({
+		create: (organizationId, input) => saved("create_collection", {
+			tenant: organizationId,
+			subject_type: input.subjectType,
+			name: input.name,
+			scope: input.scope ?? "user",
+			team: input.teamId ?? null,
+			description: input.description ?? null
+		}, extraOf(input, CREATE_KEYS)),
+		rename: (id, input) => saved("rename_collection", {
+			collection: id,
+			name: input.name ?? null,
+			description: input.description === void 0 ? null : input.description ?? ""
+		}, extraOf(input, RENAME_KEYS)),
+		archive: (id, archived = true) => call("archive_collection", {
+			collection: id,
+			archived
+		}, (value) => value === true),
+		list: (organizationId, listOptions = {}) => call("list_collections", {
+			tenant: organizationId,
+			subject_type: listOptions.subjectType ?? null,
+			include_archived: listOptions.includeArchived ?? false
+		}, (value) => recordsOf(value, "list_collections").map((raw) => [raw, collectionOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+		add: (id, ids) => call("add_collection_entries", {
+			collection: id,
+			subject_ids: [...ids],
+			subject_type: null
+		}, (value) => ({ added: isRecord(value) ? [...stringsOf(value["added"])] : [] })),
+		remove: (id, ids) => call("remove_collection_entries", {
+			collection: id,
+			subject_ids: [...ids]
+		}, Number),
+		reorder: (id, subjectId, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_collection_entry", {
+				collection: id,
+				subject_id: subjectId,
+				rank: key.data
+			}, () => key.data);
+		},
+		entries: (id, pageOptions = {}) => {
+			const { limit, cursor } = pageOf(pageOptions);
+			return call("collection_entries", {
+				collection: id,
+				after_rank: cursor?.rank ?? null,
+				after_id: cursor?.subjectId ?? null,
+				page_size: limit ?? null
+			}, (value) => entryPage(recordsOf(value, "collection_entries").map(entryOf), limit));
+		},
+		subjectIds: (id, idOptions = {}) => subjectIds(id, idOptions.max),
+		where: (id, whereOptions = {}) => subjectIds(id, whereOptions.max).map((ids) => ({ [whereOptions.column ?? "id"]: { in: ids } })),
+		listsOf: (subject) => call("collections_of", {
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => recordsOf(value, "collections_of").map(collectionOf)),
+		star: (organizationId, subject) => call("star_subject", {
+			tenant: organizationId,
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, starOf),
+		unstar: (subject) => call("unstar_subject", {
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => value === true),
+		starred: (organizationId, starredOptions = {}) => call("starred_subjects", {
+			tenant: organizationId,
+			subject_type: starredOptions.type ?? null
+		}, (value) => recordsOf(value, "starred_subjects").map(starOf)),
+		reorderStar: (subject, neighbors) => {
+			const key = rankBetweenResult(neighbors);
+			if (!key.ok) return AsyncResult.err(key.error);
+			return call("rank_star", {
+				subject_type: subject.type,
+				subject_id: subject.id,
+				rank: key.data
+			}, () => key.data);
+		}
+	}, options.hooks, {
+		block: "collections",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/collections/events.ts
+/** The `collections` block's event types, for its manifest and `onBlockEvent`. */
+const collectionsEvents = defineEvents({
+	"collection.created": event(),
+	"collection.archived": event(),
+	"collection.entry_added": event(),
+	"collection.entry_removed": event()
+});
+//#endregion
+//#region src/blocks/collections/manifest.ts
+/** The `collections` block's manifest (ADR 0029). */
+const collectionsBlock = defineBlock({
+	name: "collections",
+	sql: ["collections"],
+	options: { collections: collectionsSqlOptions },
+	events: collectionsEvents,
+	create: createCollections,
+	category: "work"
+});
+//#endregion
+export { COLLECTION_SCOPES, MAX_COLLECTION_IDS, collectionsBlock, collectionsEvents, createCollections, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,168 +1,7 @@
-/// <reference lib="esnext.temporal" />
-import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
-import { L as TableKey, a as AnyModels, i as AnyFunctions } from "../../types-6BdhkmZe.js";
-import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
-import { t as BetterSupabase } from "../../define-CJJkkr1-.js";
-import { r as EventSink, t as CloudEvent } from "../../cloud-event-C1JCc1bH.js";
-import { i as ListDefinition } from "../../list-query-BRt-zDF7.js";
-//#region src/blocks/comments/comments.d.ts
-interface CommentsOptions extends BlockTemporalOptions {
-  readonly transport: BlockTransport;
-  /** The module schema (`sql.modules.comments.schema`), default `better_supabase`. */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-  /**
-   * The user ids a comment mentions when the call passes no `mentions`,
-   * such as the mention nodes of a rich-text `document`. Default
-   * `mentionsIn(body)`.
-   */
-  readonly mentionsOf?: (comment: {
-    readonly body: string;
-    readonly document: unknown;
-  }) => readonly string[];
-}
-interface Comment {
-  readonly id: string;
-  readonly organizationId: string;
-  readonly subjectType: string;
-  readonly subjectId: string;
-  /** `undefined` once the author's account is deleted. */
-  readonly authorId: string | undefined;
-  /** Empty for a deleted comment. */
-  readonly body: string;
-  /** The rich-text document an editor wrote, next to `body` as its plain text. */
-  readonly document: unknown;
-  readonly mentions: readonly string[];
-  readonly parentId: string | undefined;
-  readonly createdAt: Temporal.Instant;
-  readonly editedAt: Temporal.Instant | undefined;
-  readonly deletedAt: Temporal.Instant | undefined;
-}
-interface NewComment {
-  readonly organizationId: string;
-  readonly subjectType: string;
-  readonly subjectId: string;
-  readonly body: string;
-  /** A rich-text document (any JSON); keep `body` as its plain text. */
-  readonly document?: unknown;
-  /** User ids; default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
-  readonly mentions?: readonly string[];
-  /** A reply: the parent must be on the same subject. */
-  readonly parentId?: string;
-}
-interface CommentEdit {
-  readonly body: string;
-  /** A new document; `null` removes it, and leaving it out keeps the current one. */
-  readonly document?: unknown;
-  /** Default `mentionsOf`, or the ids `mentionsIn(body)` finds. */
-  readonly mentions?: readonly string[];
-}
-interface ActivityEntry {
-  readonly id: string;
-  readonly organizationId: string;
-  readonly type: string;
-  readonly actorId: string | undefined;
-  readonly subjectType: string | undefined;
-  readonly subjectId: string | undefined;
-  readonly summary: string | undefined;
-  readonly data: Readonly<Record<string, unknown>>;
-  readonly occurredAt: Temporal.Instant;
-}
-interface ActivityHistoryOptions extends CursorPageOptions<Temporal.Instant> {
-  /** Entries before this instant, for paging back. */
-  readonly cursor?: Temporal.Instant;
-  /** Default 50, at most 500. */
-  readonly limit?: number;
-}
-interface ListCommentsOptions extends CursorPageOptions<Temporal.Instant> {
-  /** Comments created after this instant, for polling a thread. */
-  readonly cursor?: Temporal.Instant;
-  /** Default 100, at most 500. */
-  readonly limit?: number;
-  /** Comments to skip, for page-number paging. */
-  readonly offset?: number;
-}
-interface Comments {
-  create(comment: NewComment): AsyncResult<Comment>;
-  /** Only the author edits; `not_found` when the caller can't see it. */
-  edit(id: string, edit: CommentEdit): AsyncResult<Comment>;
-  /** Soft-deletes (the author, or a member with `comments.moderate`). */
-  remove(id: string): AsyncResult<boolean>;
-  /** A subject's thread, oldest first, deleted comments as placeholders. */
-  list(organizationId: string, subjectType: string, subjectId: string, options?: ListCommentsOptions): AsyncResult<readonly Comment[]>;
-  /**
-   * 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. Subjects
-   * without comments are 0.
-   */
-  counts(organizationId: string, subjectType: string, subjectIds: readonly string[]): 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(organizationId: string, from: {
-    readonly type: string;
-    readonly id: string;
-  }, to: {
-    readonly type: string;
-    readonly id: string;
-  }): AsyncResult<number>;
-  /**
-   * The activity feed of a tenant, newest first, or one subject's timeline
-   * with `subject`. Members with `activity.read` see it.
-   */
-  history(organizationId: string, subject?: {
-    readonly type: string;
-    readonly id: string;
-  }, options?: ActivityHistoryOptions): AsyncResult<readonly ActivityEntry[]>;
-}
-/**
- * The user ids mentioned in a body written as `@[Ada](<user id>)`, the
- * markup mention inputs produce, in order and without repeats.
- */
-export declare function mentionsIn(body: string): readonly string[];
-/** Comments over the `comments` module's functions, as the caller. */
-export declare function createComments(options: CommentsOptions): Comments;
-/** What an activity entry says about an event; `null` skips the event. */
-interface ActivityDescription {
-  readonly summary?: string;
-  readonly actorId?: string;
-  readonly subjectType?: string;
-  readonly subjectId?: string;
-  readonly data?: Readonly<Record<string, unknown>>;
-}
-interface ActivitySinkOptions {
-  /** A service-role transport: `record_activity()` is granted to `service_role` only. */
-  readonly transport: BlockTransport;
-  readonly schema?: string;
-  /** The outbox `typePrefix`, stripped from the stored type. Default `dev.better-supabase`. */
-  readonly typePrefix?: string;
-  /** Types to keep, exact or ending in `.*`. Default every event with a tenant. */
-  readonly types?: readonly string[];
-  /** Summarizes an event, or returns `null` to skip it. */
-  readonly describe?: (event: CloudEvent, type: string) => ActivityDescription | null | undefined;
-}
-/**
- * An outbox sink that writes events into the activity feed:
- * `outbox.relay('activity', activitySink({ transport }))`. Events without a
- * tenant (`partitionkey`) are skipped, and a replayed event writes nothing.
- */
-export declare function activitySink(options: ActivitySinkOptions): EventSink;
-type ActivitySort = "newest" | "oldest";
-type ActivityFacet = "type" | "actor" | "subjectType" | "subjectId";
-/**
- * A cursor-paged list over `activity_entries` (generate types for the
- * `better_supabase` schema to get it in your models), newest first,
- * filtered by type, actor and subject. Members with `activity.read` see
- * their tenants' entries.
- */
-export declare function activityListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>>(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, options?: {
-  readonly pageSize?: number;
-  readonly maxPageSize?: number;
-}): ListDefinition<M, T, E, ActivitySort, ActivityFacet, false, "cursor">;
-//#endregion
+import { j as CommentEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { C as mentionsIn, S as createComments, _ as CommentsOptions, a as CommentsSnapshot, b as activityListQuery, c as ActivityEntry, d as ActivitySinkOptions, f as ActivitySort, g as Comments, h as CommentEdit, i as CommentsControllerOptions, l as ActivityFacet, m as Comment, n as CommentsActions, o as createCommentsController, p as ActivitySource, r as CommentsController, s as ActivityDescription, t as CommentDraft, u as ActivityHistoryOptions, v as ListCommentsOptions, x as activitySink, y as NewComment } from "../../client-B7QVIrJS.js";
 //#region src/sql/subjects.d.ts
 /**
  * One subject type a module's rows belong to (`options.subjects`): the
@@ -197,4 +36,18 @@ interface Subject {
 /** One commentable subject type: its table, and who may read it. */
 type CommentSubject = Omit<Subject, "extra">;
 //#endregion
-export { type ActivityDescription, type ActivityEntry, type ActivityFacet, type ActivityHistoryOptions, type ActivitySinkOptions, type ActivitySort, type BlockTransport, type Comment, type CommentEdit, type CommentSubject, type Comments, type CommentsOptions, type ListCommentsOptions, type NewComment, rpcTransport, sqlTransport };
+//#region src/blocks/comments/events.d.ts
+/** The events of the `comments` block: type to data. */
+type CommentsEvents = {
+  readonly "comment.created": CommentEventData;
+  readonly "comment.mentioned": CommentEventData;
+  readonly "comment.deleted": CommentEventData;
+};
+/** The `comments` block's event types, for its manifest and `onBlockEvent`. */
+export declare const commentsEvents: Events<CommentsEvents>;
+//#endregion
+//#region src/blocks/comments/manifest.d.ts
+/** The `comments` block's manifest (ADR 0029). */
+export declare const commentsBlock: BlockOf<"comments", typeof createComments, CommentsEvents>;
+//#endregion
+export { type ActivityDescription, type ActivityEntry, type ActivityFacet, type ActivityHistoryOptions, type ActivitySinkOptions, type ActivitySort, type ActivitySource, type BlockTransport, type Comment, type CommentDraft, type CommentEdit, type CommentSubject, type Comments, type CommentsActions, type CommentsController, type CommentsControllerOptions, type CommentsEvents, type CommentsOptions, type CommentsSnapshot, type ListCommentsOptions, type NewComment, activityListQuery, activitySink, createComments, createCommentsController, dbTransport, mentionsIn, rpcTransport, sqlTransport };