better-supabase 0.11.0 → 0.13.0

package/dist/client-DzTtOVRR.js

@@ -1,137 +0,0 @@
-import { n as dbError } from "./errors-BV1SKTVs.js";
-import { r as err } from "./result-DIeYscA3.js";
-import { n as isRecord, t as isList } from "./guards-6F2bCtQR.js";
-import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
-//#region src/blocks/settings/client.ts
-const isConverter = (value) => isRecord(value) && typeof value["input"] === "function";
-const jsonSchemaOf = (entry) => {
-	const standard = entry.schema["~standard"];
-	const converter = isRecord(standard) ? standard["jsonSchema"] : void 0;
-	if (!isConverter(converter)) return;
-	try {
-		const converted = converter.input({ target: "draft-2020-12" });
-		return isRecord(converted) ? converted : void 0;
-	} catch {
-		return;
-	}
-};
-const kindOfValue = (value) => typeof value === "boolean" ? "boolean" : typeof value === "number" ? "number" : typeof value === "string" ? "text" : "json";
-const text = (value) => typeof value === "string" ? value : void 0;
-function fieldOf(key, entry) {
-	const schema = jsonSchemaOf(entry);
-	const values = schema?.["enum"];
-	const choices = isList(values) ? values.filter((value) => typeof value === "string" || typeof value === "number") : [];
-	const type = schema?.["type"];
-	return {
-		key,
-		kind: choices.length > 0 ? "choice" : type === "boolean" ? "boolean" : type === "number" || type === "integer" ? "number" : type === "string" ? "text" : type === void 0 ? kindOfValue(entry.default) : "json",
-		choices,
-		title: text(schema?.["title"]),
-		description: text(schema?.["description"]),
-		default: entry.default
-	};
-}
-/**
-* The form fields of one scope of a settings definition, in declaration
-* order: `settingFields(settings.schemas.organization)`.
-*/
-function settingFields(entries) {
-	const fields = [];
-	for (const key of Object.keys(entries)) {
-		const entry = entries[key];
-		if (!entry) continue;
-		fields.push(fieldOf(key, entry));
-	}
-	return fields;
-}
-function storeOf(options) {
-	const { user, organization } = options;
-	if (user) return {
-		get: () => user.getUser(),
-		set: (key, value) => user.setUser(key, value),
-		reset: (key) => user.resetUser(key)
-	};
-	if (!organization) throw new TypeError("better-supabase: createSettingsController needs `user` or `organization`");
-	const organizationId = options.organizationId ?? null;
-	if (organizationId === null) return;
-	return {
-		get: () => organization.getOrganization(organizationId),
-		set: (key, value) => organization.setOrganization(organizationId, key, value),
-		reset: (key) => organization.resetOrganization(organizationId, key)
-	};
-}
-/**
-* One scope of the app's settings for a settings page: the form fields
-* generated from the definition, the stored values over the defaults, and
-* `set` and `reset` per key.
-*/
-function createSettingsController(options) {
-	const store = storeOf(options);
-	return defineController({
-		fields: settingFields(options.entries),
-		values: void 0,
-		saving: void 0,
-		error: void 0
-	}, (state) => {
-		const refresh = async () => {
-			if (!store) return;
-			const run = state.run();
-			const result = await store.get();
-			if (run !== state.run()) return;
-			state.set(result.ok ? {
-				values: result.data,
-				error: void 0
-			} : { error: result.error });
-		};
-		const waiting = () => err(dbError("invalid_input", "No organization to save the setting for"));
-		const set = async (key, value) => {
-			if (!store) return waiting();
-			state.set({
-				saving: key,
-				error: void 0
-			});
-			const result = await store.set(key, value);
-			if (!result.ok) {
-				state.set({
-					saving: void 0,
-					error: result.error
-				});
-				return result;
-			}
-			state.set((current) => ({
-				saving: void 0,
-				...current.values === void 0 ? {} : { values: {
-					...current.values,
-					[key]: result.data
-				} }
-			}));
-			return result;
-		};
-		return {
-			actions: {
-				refresh,
-				set,
-				setField: (key, value) => set(key, value),
-				reset: async (key) => {
-					if (!store) return waiting();
-					state.set({
-						saving: key,
-						error: void 0
-					});
-					const result = await store.reset(key);
-					state.set(result.ok ? { saving: void 0 } : {
-						saving: void 0,
-						error: result.error
-					});
-					if (result.ok) await refresh();
-					return result;
-				}
-			},
-			start: () => store ? whileSignedIn(options.auth, () => {
-				refresh();
-			}) : void 0
-		};
-	});
-}
-//#endregion
-export { settingFields as n, createSettingsController as t };

package/dist/client-Ezlbskjq.js

@@ -1,60 +0,0 @@
-import { t as defineController } from "./controller-D6NyNrlZ.js";
-import { t as tenantOf } from "./tenant-B-fiItlJ.js";
-//#region src/auth/entitlements.ts
-/**
-* Whether the session's plan-features claim grants `key` in `tenantId`.
-* `claim` is `config.claims.features` (default `features`), the claim
-* `better_supabase.feature_claims()` fills, or `{ claim, keys }` when
-* `entitlements.claim.keys` writes short codes. The claim is as fresh as the
-* token: enforce it in RLS with `better_supabase.has_entitlement()`, and
-* refresh the session after checkout. A tenant left out by
-* `entitlements.claim.maxTenants` reads as not granted. Takes a server
-* session or the client's `useAuth()` snapshot.
-*/
-function hasEntitlement(session, tenantId, key, claim = "features") {
-	const options = typeof claim === "string" ? { claim } : claim;
-	const claims = "kind" in session ? session.kind === "user" ? session.claims : void 0 : session.claims;
-	if (!isRecord(claims)) return false;
-	const features = claims[options.claim ?? "features"];
-	if (!isRecord(features) || !Object.hasOwn(features, tenantId)) return false;
-	const keys = features[tenantId];
-	const code = options.keys?.[key] ?? key;
-	return Array.isArray(keys) && keys.includes(code);
-}
-const isRecord = (value) => typeof value === "object" && value !== null;
-//#endregion
-//#region src/blocks/entitlements/client.ts
-/**
-* Whether the active organization's plan includes `feature`, from the
-* session's plan-features claim. It updates when the session does, so a
-* session refresh after checkout opens the gate. UX only: enforce the
-* feature in RLS with `better_supabase.has_entitlement()`.
-*/
-function createFeatureGateController(options) {
-	const read = () => {
-		const session = options.auth.current();
-		if (session.status === "loading") return {
-			allowed: void 0,
-			organizationId: void 0
-		};
-		const organizationId = options.organizationId ?? tenantOf(session, options.tenantClaim);
-		return {
-			allowed: organizationId === void 0 ? false : hasEntitlement(session, organizationId, options.feature, options.claim),
-			organizationId
-		};
-	};
-	return defineController(read(), (state) => {
-		const recheck = () => {
-			state.set(read());
-		};
-		return {
-			actions: { recheck },
-			start: () => {
-				recheck();
-				return options.auth.subscribe(recheck);
-			}
-		};
-	});
-}
-//#endregion
-export { hasEntitlement as n, createFeatureGateController as t };

package/dist/client-GdJH4XJM.d.ts

@@ -1,101 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { b as DbError, t as AsyncResult } from "./result-BREt7qOh.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { n as BlockOptions } from "./block-helpers-CjcQM1yA.js";
-import { n as BlockHooks } from "./block-hooks-DcPJHztl.js";
-import { n as Controller, t as AuthPort } from "./controller-BBXX1RMw.js";
-//#region src/blocks/onboarding/onboarding.d.ts
-type ChecklistScope = "user" | "organization";
-/** One step. `events` completes it when the outbox records one of those types. */
-interface ChecklistStep<Id extends string = string> {
-  readonly id: Id;
-  readonly title?: string;
-  readonly description?: string;
-  /** Where the step is done in the app, for a "Start" link. */
-  readonly href?: string;
-  readonly events?: readonly string[];
-}
-interface ChecklistSpec<Id extends string, Scope extends ChecklistScope> {
-  readonly id: string;
-  /** `user` tracks each user; `organization` tracks each tenant. */
-  readonly scope: Scope;
-  readonly steps: readonly ChecklistStep<Id>[];
-}
-interface OnboardingOptions extends BlockOptions {
-  /** `withBlockHooks` hooks around the client's methods. */
-  readonly hooks?: BlockHooks<Onboarding>;
-  /** Receives the errors `after` hooks throw. Default: `console`. */
-  readonly logger?: Logger;
-}
-/** A step with the subject's progress. */
-interface StepProgress<Id extends string> extends ChecklistStep<Id> {
-  readonly completed: boolean;
-  readonly completedAt: Temporal.Instant | undefined;
-  readonly completedBy: string | undefined;
-}
-interface ChecklistProgress<Id extends string> {
-  readonly steps: readonly StepProgress<Id>[];
-  readonly completed: number;
-  readonly total: number;
-  /** Every step is complete. */
-  readonly done: boolean;
-  /** The first step not done yet. */
-  readonly next: StepProgress<Id> | undefined;
-}
-/** The organization for an organization checklist; nothing for a user one. */
-type ChecklistSubject<Scope extends ChecklistScope> = Scope extends "organization" ? [organizationId: string] : [];
-/** The onboarding block: progress through any checklist `defineChecklist` declared. */
-interface Onboarding {
-  /** The subject's progress: the caller's for a user checklist, the organization's otherwise. */
-  progress<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
-  /** Marks a step done; `false` when it already was. */
-  complete<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-  /** Marks a step not done; `false` when it wasn't. */
-  reset<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-}
-/** A checklist `defineChecklist` checked; pass it to the onboarding client's methods. */
-type Checklist<Id extends string, Scope extends ChecklistScope> = ChecklistSpec<Id, Scope>;
-/**
- * Declares an onboarding checklist. Pass the result to
- * `blocks.onboarding.options.checklists` so the database knows its
- * steps, and to the methods of `createOnboarding` to read and complete them.
- */
-declare function defineChecklist<const Id extends string, const Scope extends ChecklistScope>(spec: ChecklistSpec<Id, Scope>): Checklist<Id, Scope>;
-/**
- * The onboarding block: reads and completes the steps of the checklists in
- * `blocks.onboarding.options.checklists`, for the caller or an organization.
- */
-declare function createOnboarding(options: OnboardingOptions): Onboarding;
-//#endregion
-//#region src/blocks/onboarding/client.d.ts
-/** The calls the controller makes for one checklist; `createOnboarding` fits. */
-interface OnboardingControllerClient<Id extends string, Scope extends ChecklistScope> {
-  progress(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
-  complete(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-  reset(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
-}
-interface OnboardingControllerOptions<Id extends string, Scope extends ChecklistScope> {
-  /** `createOnboarding({ transport })`. */
-  readonly client: OnboardingControllerClient<Id, Scope>;
-  /** The checklist, from `defineChecklist`. */
-  readonly checklist: Checklist<Id, Scope>;
-  readonly auth: AuthPort;
-  /** The organization, for an organization checklist; it waits without one. */
-  readonly organizationId?: string | null;
-}
-interface OnboardingSnapshot<Id extends string> {
-  /** `undefined` until the first load. */
-  readonly progress: ChecklistProgress<Id> | undefined;
-  readonly error: DbError | undefined;
-}
-interface OnboardingActions<Id extends string> {
-  /** Marks a step done, then loads the progress again. */
-  readonly complete: (step: Id) => Promise<void>;
-  readonly reset: (step: Id) => Promise<void>;
-  readonly refresh: () => Promise<void>;
-}
-type OnboardingController<Id extends string> = Controller<OnboardingSnapshot<Id>, OnboardingActions<Id>>;
-/** A checklist's progress for the signed-in user, or for an organization. */
-declare function createOnboardingController<Id extends string, Scope extends ChecklistScope>(options: OnboardingControllerOptions<Id, Scope>): OnboardingController<Id>;
-//#endregion
-export { defineChecklist as _, OnboardingSnapshot as a, ChecklistProgress as c, ChecklistStep as d, ChecklistSubject as f, createOnboarding as g, StepProgress as h, OnboardingControllerOptions as i, ChecklistScope as l, OnboardingOptions as m, OnboardingController as n, createOnboardingController as o, Onboarding as p, OnboardingControllerClient as r, Checklist as s, OnboardingActions as t, ChecklistSpec as u };

package/dist/client-QvuCfO4b.d.ts

@@ -1,263 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, b as DbError, f as Result, t as AsyncResult } from "./result-BREt7qOh.js";
-import { B as TableKey, a as AnyModels, i as AnyFunctions } from "./types-BrpW5ixT.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { t as StandardSchemaV1 } from "./standard-BcUQuUgu.js";
-import { t as BlockTransport } from "./block-transport-DezJPPA0.js";
-import { i as CursorPageOptions, r as BlockTemporalOptions } from "./block-helpers-CjcQM1yA.js";
-import { n as BlockHooks } from "./block-hooks-DcPJHztl.js";
-import { n as ExtraFields, r as FieldsOf } from "./block-fields-DnaDbgZS.js";
-import { i as EventSink, t as CloudEvent } from "./cloud-event-DXkNoI6v.js";
-import { t as BetterSupabase } from "./define-M_r1d2AT.js";
-import { p as SubscriptionStatus } from "./topic-1WTkDnPd.js";
-import { n as TopicPort } from "./watch-topic-DWHy63ZJ.js";
-import { i as ListDefinition } from "./list-query-FhFXzObg.js";
-import { n as Controller, t as AuthPort } from "./controller-BBXX1RMw.js";
-//#region src/blocks/comments/comments.d.ts
-interface CommentsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
-  /**
-   * A Standard Schema for the comment's extra columns
-   * (`blocks.comments.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 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[];
-}
-/** A comment. `F` types the extra columns the `fields` schema describes. */
-interface Comment<F extends object = Record<never, never>> {
-  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;
-  /** The extra columns, keyed by database name. */
-  readonly fields: ExtraFields<F>;
-}
-interface NewComment<F extends object = Record<never, never>> {
-  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;
-  /** The extra columns to set, keyed by database name. */
-  readonly fields?: Partial<F>;
-}
-interface CommentEdit<F extends object = Record<never, never>> {
-  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[];
-  /** The extra columns to set, keyed by database name; others keep their value. */
-  readonly fields?: Partial<F>;
-}
-/**
- * Where a timeline entry comes from: `event` for an `activity_entries` row
- * that `activitySink()` wrote, `audit` for an audit log entry on the
- * subject's row (with the `audit` and `subjects` modules), `delivery` for a
- * notification delivery about the subject (with `notifications`) and `run`
- * for a workflow run on it (with `workflows`).
- */
-type ActivitySource = "event" | "audit" | "delivery" | "run";
-interface ActivityEntry {
-  /** An `activity_entries` id, or the audit entry's, delivery's or run's id. */
-  readonly id: string;
-  readonly source: ActivitySource;
-  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;
-  /** The kinds of entry to return; all of them when left out. */
-  readonly sources?: readonly ActivitySource[];
-}
-interface ListCommentsOptions extends CursorPageOptions<Temporal.Instant> {
-  /** Comments created after this instant, for polling a thread. */
-  readonly cursor?: Temporal.Instant;
-  /**
-   * The id of the last comment you have, next to `cursor`, so comments
-   * created 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. */
-interface Comments<F extends object = Record<never, never>> {
-  create(comment: NewComment<F>): AsyncResult<Comment<F>>;
-  /** Only the author edits; `not_found` when the caller can't see it. */
-  edit(id: string, edit: CommentEdit<F>): AsyncResult<Comment<F>>;
-  /** 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<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. 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. With the `subjects`
-   * module, an entry on a registered subject type needs `can_subject` read,
-   * and a subject's timeline also lists its audit log entries
-   * (`source: "audit"`) when `audit` is installed with its read policy, the
-   * deliveries of notifications about it (`source: "delivery"`, for members
-   * who also hold `notifications.send`) and its workflow runs
-   * (`source: "run"`, as the runs' read policy allows).
-   */
-  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.
- */
-declare function mentionsIn(body: string): readonly string[];
-/** Comments over the `comments` module's functions, as the caller. */
-declare function createComments<S extends StandardSchemaV1 | undefined = undefined>(options: CommentsOptions<S>): Comments<FieldsOf<S>>;
-/** 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.
- */
-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, less those on a registered subject that
- * `can_subject` doesn't let them read (with the `subjects` module). It
- * reads the table, so it lists no audit entries; `history()` does.
- */
-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>;
-//#endregion
-//#region src/blocks/comments/client.d.ts
-interface CommentsControllerOptions {
-  readonly client: Pick<Comments, "list" | "create" | "edit" | "remove">;
-  readonly auth: AuthPort;
-  readonly ports: {
-    readonly topic: TopicPort;
-  };
-  /** The organization; the thread waits without one. */
-  readonly organizationId: string | null;
-  readonly subjectType: string;
-  readonly subjectId: string;
-  /**
-   * A private topic that hears of new comments on the subject, such as a
-   * `realtime-tables` topic on the comments table. Each message loads the
-   * thread again. Default `null`: 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 or explicit mentions for `add`. */
-type CommentDraft = Pick<NewComment, "document" | "mentions" | "parentId">;
-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>>;
-  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 `add`, `edit` and `remove`, and loads it again for each
- * message on `topic`.
- */
-declare function createCommentsController(options: CommentsControllerOptions): CommentsController;
-//#endregion
-export { mentionsIn as C, createComments as S, CommentsOptions as _, CommentsSnapshot as a, activityListQuery as b, ActivityEntry as c, ActivitySinkOptions as d, ActivitySort as f, Comments as g, CommentEdit as h, CommentsControllerOptions as i, ActivityFacet as l, Comment as m, CommentsActions as n, createCommentsController as o, ActivitySource as p, CommentsController as r, ActivityDescription as s, CommentDraft as t, ActivityHistoryOptions as u, ListCommentsOptions as v, activitySink as x, NewComment as y };