@adula/kit 0.2.0-alpha.4 → 1.0.0

package/build/src/admin/resource_service.js

@@ -8,6 +8,10 @@ import { sequence } from '../services/settings.js';
 import { recordMutation } from '../events/record_mutation.js';
 import { fieldValue } from '../resource/values.js';
 import { claimAttachment, isAttachmentId, loadAttachments, releaseAttachment, } from '../attachments/attachment_service.js';
+/** Per-process cache of planner row estimates for identical list queries. */
+const estimates = new Map();
+const ESTIMATE_TTL_MS = 30_000;
+const ESTIMATE_CACHE_LIMIT = 500;
 /**
  * Whether an actor may sort, filter or search by a field. Querying reveals values
  * indirectly, so it needs unconditional view access at the field's level.
@@ -28,6 +32,10 @@ export class ResourceService {
         this.db = db;
         this.registry = registry;
     }
+    /** The Arabic label of a registered resource, for notifications and titles. */
+    label(name) {
+        return this.registry.get(name).label.ar;
+    }
     /** Project navigation is derived from registered resources and the current actor. */
     navigation(actor) {
         const ability = buildAbility(actor.rules, this.registry.all());
@@ -85,7 +93,7 @@ export class ResourceService {
                     !['update', 'delete', 'submit'].includes(action) ||
                     record.docStatus === 0) &&
                 (action !== 'cancel' || (resource.submittable && record.docStatus === 1)) &&
-                action !== 'amend',
+                (action !== 'amend' || (resource.submittable && record.docStatus === 2)),
         ]));
     }
     normalizeValues(resource, record) {
@@ -160,6 +168,37 @@ export class ResourceService {
         if (!canRecord(ability, actor, resource, action, record))
             throw new KitError(403, 'E_FORBIDDEN', 'ليس لديك صلاحية لهذا الإجراء');
     }
+    /**
+     * Authorizes one record for collaboration features (comments, tags, assignments...).
+     * Scope and conditional rules apply exactly as for show/update.
+     */
+    async access(name, id, actor, action = 'view', db = this.db) {
+        let resource;
+        try {
+            resource = this.registry.get(name);
+        }
+        catch {
+            throw new KitError(404, 'E_NOT_FOUND', 'الكيان غير موجود');
+        }
+        if (!Number.isSafeInteger(id) || id <= 0)
+            throw new KitError(404, 'E_NOT_FOUND', 'السجل غير موجود');
+        const ability = this.authorizeAction(resource, actor, action);
+        const record = await this.find(db, resource, actor, ability, id);
+        this.requireRecord(ability, actor, resource, action, record);
+        return { resource, record, ability };
+    }
+    /** Whether a (possibly other) actor may perform an action on a record; never throws for denial. */
+    async permits(name, id, actor, action = 'view') {
+        try {
+            await this.access(name, id, actor, action);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof KitError && [403, 404].includes(error.status))
+                return false;
+            throw error;
+        }
+    }
     async list(name, actor, options = {}) {
         const resource = this.registry.get(name);
         const ability = this.authorizeAction(resource, actor, 'view');
@@ -190,15 +229,36 @@ export class ResourceService {
                 throw new KitError(422, 'E_FILTER', 'Invalid filter value');
             query.where(`r.${resource.fields[key].column ?? columnName(key)}`, value);
         }
+        if (options.tag !== undefined && options.tag !== null && options.tag !== '') {
+            if (typeof options.tag !== 'string' || options.tag.length > 60)
+                throw new KitError(422, 'E_FILTER', 'Invalid tag filter');
+            query.whereExists((exists) => exists
+                .from('taggables as tg')
+                .join('tags as tn', 'tn.id', 'tg.tag_id')
+                .where('tg.resource', name)
+                .whereRaw('tg.record_id = r.id')
+                .where('tn.name', options.tag));
+        }
         // Estimate the authorized, filtered query, never the deployment-wide table cardinality.
         // Only the first page pays for the extra planner round trip; later pages keep its figure.
         let estimatedTotal;
         if (options.estimate !== false && !options.cursor) {
             const compiled = query.clone().clearSelect().select('r.id').toSQL();
-            const estimate = await this.db.raw(`EXPLAIN (FORMAT JSON) ${compiled.sql}`, [
-                ...compiled.bindings,
-            ]);
-            estimatedTotal = Number(estimate.rows[0]['QUERY PLAN'][0].Plan['Plan Rows']);
+            // The planner estimate is approximate by nature; reuse it briefly for the same
+            // authorized, filtered query instead of planning it on every first page.
+            const key = `${compiled.sql}\u0000${JSON.stringify(compiled.bindings)}`;
+            const cached = estimates.get(key);
+            if (cached && cached.at > Date.now() - ESTIMATE_TTL_MS)
+                estimatedTotal = cached.rows;
+            else {
+                const estimate = await this.db.raw(`EXPLAIN (FORMAT JSON) ${compiled.sql}`, [
+                    ...compiled.bindings,
+                ]);
+                estimatedTotal = Number(estimate.rows[0]['QUERY PLAN'][0].Plan['Plan Rows']);
+                if (estimates.size >= ESTIMATE_CACHE_LIMIT)
+                    estimates.delete(estimates.keys().next().value);
+                estimates.set(key, { rows: estimatedTotal, at: Date.now() });
+            }
         }
         if (options.cursor) {
             let cursor;
@@ -700,7 +760,17 @@ export class ResourceService {
                     }, childId === undefined ? undefined : Number(childId), trx, { name, id: Number(row.id), action });
                 }
             }
-            await this.audit(trx, resource, actor, action, saved, Object.keys(form));
+            const changes = [];
+            if (id !== undefined)
+                for (const key of Object.keys(resource.fields)) {
+                    if (resource.fields[key].type === 'hasMany' || !(key in saved))
+                        continue;
+                    const before = existing[key] ?? null;
+                    const after = saved[key] ?? null;
+                    if (JSON.stringify(before) !== JSON.stringify(after))
+                        changes.push({ field: key, before, after });
+                }
+            await this.audit(trx, resource, actor, action, saved, Object.keys(form), changes);
             await resource.hooks?.afterSave?.(saved, context);
             return serialize(resource, await this.hydrateOne(trx, resource, saved), ability, actor);
         };
@@ -769,7 +839,92 @@ export class ResourceService {
         };
         return transaction ? work(transaction) : this.db.transaction(work);
     }
-    async audit(trx, resource, actor, action, record, fields) {
+    /**
+     * Amend-by-copy: a cancelled document is copied into a new draft that points to
+     * it through amended_from_id, together with its inline lines. The original stays
+     * cancelled and unchanged; sequence fields receive new numbers.
+     */
+    async amend(name, id, actor, transaction) {
+        const resource = this.registry.get(name);
+        if (!resource.submittable)
+            throw new KitError(409, 'E_DOCUMENT_STATE', 'Only submittable documents can be amended');
+        const ability = this.authorizeAction(resource, actor, 'amend');
+        const work = async (trx) => {
+            const source = await this.find(trx, resource, actor, ability, id, true);
+            this.requireRecord(ability, actor, resource, 'amend', source);
+            if (source.docStatus !== 2)
+                throw new KitError(409, 'E_DOCUMENT_STATE', 'Only cancelled documents can be amended');
+            const existing = await trx(name)
+                .where('amended_from_id', id)
+                .whereNull('deleted_at')
+                .first('id');
+            if (existing)
+                throw new KitError(409, 'E_ALREADY_AMENDED', 'تم تعديل هذا المستند بالنسخ من قبل');
+            const values = {
+                created_by: actor.id,
+                updated_by: actor.id,
+                doc_status: 0,
+                amended_from_id: id,
+            };
+            if (resource.scoped)
+                values.org_unit_id = source.orgUnitId;
+            if (resource.version)
+                values.version = 1;
+            const copied = [];
+            for (const [key, field] of Object.entries(resource.fields)) {
+                if (field.type === 'hasMany' || !(key in source))
+                    continue;
+                const column = field.column ?? columnName(key);
+                if (field.sequence)
+                    values[column] = await sequence(trx, field.sequence);
+                else if (field.type === 'attachment')
+                    continue;
+                else {
+                    values[column] = field.type === 'json' ? JSON.stringify(source[key]) : source[key];
+                    copied.push(key);
+                }
+            }
+            const [row] = await trx(name).insert(values).returning('*');
+            const saved = { ...fromRow(row, resource), orgPath: source.orgPath };
+            for (const field of Object.values(resource.fields)) {
+                if (field.type !== 'hasMany' || !field.inline)
+                    continue;
+                const child = this.registry.get(field.resource);
+                const foreign = child.fields[field.foreignKey].column ?? columnName(field.foreignKey);
+                const lines = await trx(child.name).where(foreign, id).whereNull('deleted_at').orderBy('id');
+                for (const line of lines) {
+                    const copy = {
+                        created_by: actor.id,
+                        updated_by: actor.id,
+                        [foreign]: row.id,
+                    };
+                    if (child.scoped)
+                        copy.org_unit_id = line.org_unit_id;
+                    if (child.version)
+                        copy.version = 1;
+                    for (const [key, childField] of Object.entries(child.fields)) {
+                        const column = childField.column ?? columnName(key);
+                        if (key === field.foreignKey ||
+                            childField.type === 'hasMany' ||
+                            childField.type === 'attachment' ||
+                            !(column in line))
+                            continue;
+                        copy[column] = childField.sequence
+                            ? await sequence(trx, childField.sequence)
+                            : childField.type === 'json'
+                                ? JSON.stringify(line[column])
+                                : line[column];
+                    }
+                    const [inserted] = await trx(child.name).insert(copy).returning('id');
+                    await this.audit(trx, child, actor, 'create', { id: inserted.id }, Object.keys(child.fields));
+                }
+            }
+            await this.audit(trx, resource, actor, 'amend', saved, copied);
+            return serialize(resource, await this.hydrateOne(trx, resource, saved), ability, actor);
+        };
+        return transaction ? work(transaction) : this.db.transaction(work);
+    }
+    async audit(trx, resource, actor, action, record, fields, changes) {
         await recordMutation(trx, {
             module: this.registry.owner(resource.name),
             resource: resource.name,
@@ -778,6 +933,7 @@ export class ResourceService {
             impersonatorId: actor.impersonatorId,
             action,
             fields,
+            changes,
         });
     }
 }

package/build/src/collaboration/assignments.d.ts

@@ -0,0 +1,78 @@
+import type { Knex } from 'knex';
+import type { Actor } from '../auth/ability.js';
+import type { ResourceService } from '../admin/resource_service.js';
+import type { ActorLoader } from './record_collaboration.js';
+export type AssignmentStatus = 'open' | 'done' | 'cancelled';
+export type Assignment = {
+    id: number;
+    resource: string;
+    resourceLabel: string;
+    recordId: number;
+    assigneeId: number;
+    assigneeName: string | null;
+    assignedBy: number | null;
+    assignedByName: string | null;
+    kind: string;
+    title: string;
+    note: string | null;
+    dueOn: string | null;
+    status: AssignmentStatus;
+    outcome: string | null;
+    createdAt: string;
+    completedAt: string | null;
+    /** Set for approval steps; completion goes through the workflow engine instead. */
+    workflowRunId: string | null;
+    canComplete: boolean;
+    canCancel: boolean;
+};
+export type AssignmentPage = {
+    data: Assignment[];
+    nextCursor: string | null;
+    open: number;
+};
+/**
+ * Assignments put a record on someone's "my tasks" list. Assigning needs update
+ * permission on the record, the assignee must be able to read it, and every read
+ * re-checks the record so lost access hides the task instead of leaking it.
+ */
+export declare class Assignments {
+    private db;
+    private resources;
+    private actors;
+    constructor(db: Knex, resources: ResourceService, actors: ActorLoader);
+    forRecord(name: string, id: number, actor: Actor): Promise<Assignment[]>;
+    assign(name: string, id: number, actor: Actor, input: {
+        assigneeId: unknown;
+        title: unknown;
+        note?: unknown;
+        dueOn?: unknown;
+    }): Promise<Assignment>;
+    /**
+     * Inserts an assignment and its notification. Used by assign() and by workflow
+     * approval steps inside their own transaction; callers authorize beforehand.
+     */
+    create(db: Knex, input: {
+        resource: string;
+        recordId: number;
+        assigneeId: number;
+        assignedBy: number | null;
+        title: string;
+        note?: string | null;
+        dueOn?: string | null;
+        kind?: string;
+        workflowRunId?: string;
+        workflowStep?: string;
+    }): Promise<any>;
+    /** The signed-in user's own tasks, open first; records they can no longer read are hidden. */
+    mine(actor: Actor, options?: {
+        status?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<AssignmentPage>;
+    /** The assignee marks the task done, or the assigner cancels it. */
+    complete(assignmentId: unknown, actor: Actor, outcome?: 'done' | 'cancelled'): Promise<void>;
+    private query;
+    private present;
+    private label;
+    private canView;
+}

package/build/src/collaboration/assignments.js

@@ -0,0 +1,219 @@
+import { KitError } from '../admin/errors.js';
+import { notifyWithTemplate } from '../core/message_templates.js';
+const TITLE_LIMIT = 200;
+const NOTE_LIMIT = 2000;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+function dateOnly(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date)
+        return `${value.getFullYear()}-${String(value.getMonth() + 1).padStart(2, '0')}-${String(value.getDate()).padStart(2, '0')}`;
+    return String(value);
+}
+/**
+ * Assignments put a record on someone's "my tasks" list. Assigning needs update
+ * permission on the record, the assignee must be able to read it, and every read
+ * re-checks the record so lost access hides the task instead of leaking it.
+ */
+export class Assignments {
+    db;
+    resources;
+    actors;
+    constructor(db, resources, actors) {
+        this.db = db;
+        this.resources = resources;
+        this.actors = actors;
+    }
+    async forRecord(name, id, actor) {
+        await this.resources.access(name, id, actor);
+        const rows = await this.query()
+            .where({ 'a.resource': name, 'a.record_id': id })
+            .orderByRaw("(a.status = 'open') DESC, a.id DESC")
+            .limit(100);
+        return rows.map((row) => this.present(row, actor));
+    }
+    async assign(name, id, actor, input) {
+        await this.resources.access(name, id, actor, 'update');
+        const assigneeId = Number(input.assigneeId);
+        if (!Number.isSafeInteger(assigneeId) || assigneeId <= 0)
+            throw new KitError(422, 'E_ASSIGNEE', 'اختر المستخدم المكلف');
+        const title = typeof input.title === 'string' ? input.title.trim() : '';
+        if (!title || title.length > TITLE_LIMIT)
+            throw new KitError(422, 'E_ASSIGNMENT_TITLE', 'عنوان المهمة مطلوب ولا يتجاوز 200 حرف');
+        const note = input.note === undefined || input.note === null || input.note === ''
+            ? null
+            : typeof input.note === 'string' && input.note.length <= NOTE_LIMIT
+                ? input.note.trim()
+                : null;
+        if (input.note && note === null)
+            throw new KitError(422, 'E_ASSIGNMENT_NOTE', 'الملاحظة لا تتجاوز 2000 حرف');
+        const dueOn = input.dueOn === undefined || input.dueOn === null || input.dueOn === ''
+            ? null
+            : typeof input.dueOn === 'string' &&
+                DATE.test(input.dueOn) &&
+                !Number.isNaN(Date.parse(input.dueOn))
+                ? input.dueOn
+                : undefined;
+        if (dueOn === undefined)
+            throw new KitError(422, 'E_ASSIGNMENT_DUE', 'تاريخ الاستحقاق غير صالح');
+        if (!(await this.canView(name, id, assigneeId)))
+            throw new KitError(422, 'E_ASSIGNEE', 'لا يمكن تكليف مستخدم لا يملك صلاحية عرض السجل');
+        return this.create(this.db, {
+            resource: name,
+            recordId: id,
+            assigneeId,
+            assignedBy: actor.id,
+            title,
+            note,
+            dueOn,
+        }).then((created) => this.present(created, actor));
+    }
+    /**
+     * Inserts an assignment and its notification. Used by assign() and by workflow
+     * approval steps inside their own transaction; callers authorize beforehand.
+     */
+    async create(db, input) {
+        const insert = async (trx) => {
+            const [row] = await trx('assignments')
+                .insert({
+                resource: input.resource,
+                record_id: input.recordId,
+                assignee_id: input.assigneeId,
+                assigned_by: input.assignedBy,
+                kind: input.kind ?? 'task',
+                title: input.title,
+                note: input.note ?? null,
+                due_on: input.dueOn ?? null,
+                workflow_run_id: input.workflowRunId ?? null,
+                workflow_step: input.workflowStep ?? null,
+            })
+                .returning('id');
+            await notifyWithTemplate(trx, input.assigneeId, input.kind === 'approval' ? 'assignment.approval' : 'assignment.created', {
+                title: input.title,
+                resource: this.label(input.resource),
+                id: input.recordId,
+                due: input.dueOn ?? '',
+            });
+            return this.query(trx).where('a.id', row.id).first();
+        };
+        return 'isTransaction' in db && db.isTransaction ? insert(db) : this.db.transaction(insert);
+    }
+    /** The signed-in user's own tasks, open first; records they can no longer read are hidden. */
+    async mine(actor, options = {}) {
+        const status = options.status === 'done' || options.status === 'all' ? options.status : 'open';
+        const limit = Math.max(1, Math.min(100, Math.floor(Number(options.limit) || 50)));
+        const query = this.query().where('a.assignee_id', actor.id).orderBy('a.id', 'desc');
+        if (status === 'open')
+            query.where('a.status', 'open');
+        if (status === 'done')
+            query.whereNot('a.status', 'open');
+        let last = null;
+        if (options.cursor !== undefined && options.cursor !== '') {
+            last = Number(options.cursor);
+            if (!Number.isSafeInteger(last) || last <= 0)
+                throw new KitError(422, 'E_CURSOR', 'مؤشر الصفحة غير صالح');
+        }
+        const data = [];
+        let more = true;
+        // Access is re-checked per record; scan bounded batches to fill the page.
+        for (let round = 0; round < 10 && more && data.length < limit; round++) {
+            const rows = await query
+                .clone()
+                .modify((q) => {
+                if (last !== null)
+                    q.where('a.id', '<', last);
+            })
+                .limit(100);
+            more = rows.length === 100;
+            for (const row of rows) {
+                if (data.length >= limit) {
+                    more = true;
+                    break;
+                }
+                last = Number(row.id);
+                if (await this.resources.permits(row.resource, Number(row.record_id), actor))
+                    data.push(this.present(row, actor));
+            }
+        }
+        const [{ count }] = await this.db('assignments')
+            .where({ assignee_id: actor.id, status: 'open' })
+            .count('* as count');
+        return {
+            data,
+            nextCursor: more && last !== null ? String(last) : null,
+            open: Number(count),
+        };
+    }
+    /** The assignee marks the task done, or the assigner cancels it. */
+    async complete(assignmentId, actor, outcome = 'done') {
+        const id = Number(assignmentId);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            throw new KitError(404, 'E_ASSIGNMENT_NOT_FOUND', 'المهمة غير موجودة');
+        return this.db.transaction(async (trx) => {
+            const row = await trx('assignments').where('id', id).forUpdate().first();
+            if (!row)
+                throw new KitError(404, 'E_ASSIGNMENT_NOT_FOUND', 'المهمة غير موجودة');
+            const involved = row.assignee_id === actor.id || row.assigned_by === actor.id;
+            if (!involved || !(await this.resources.permits(row.resource, Number(row.record_id), actor)))
+                throw new KitError(404, 'E_ASSIGNMENT_NOT_FOUND', 'المهمة غير موجودة');
+            if (row.workflow_run_id)
+                throw new KitError(409, 'E_ASSIGNMENT_WORKFLOW', 'تُحسم خطوات الموافقة من صندوق الموافقات');
+            if (outcome === 'done' && row.assignee_id !== actor.id)
+                throw new KitError(403, 'E_FORBIDDEN', 'يُنجز المهمة المكلف بها فقط');
+            if (outcome === 'cancelled' && row.assigned_by !== actor.id)
+                throw new KitError(403, 'E_FORBIDDEN', 'يلغي المهمة من أسندها فقط');
+            if (row.status !== 'open')
+                throw new KitError(409, 'E_ASSIGNMENT_CLOSED', 'المهمة مغلقة بالفعل');
+            await trx('assignments')
+                .where('id', id)
+                .update({ status: outcome, completed_at: trx.fn.now(), completed_by: actor.id });
+            const notify = outcome === 'done' ? row.assigned_by : row.assignee_id;
+            if (notify && notify !== actor.id)
+                await notifyWithTemplate(trx, notify, outcome === 'done' ? 'assignment.done' : 'assignment.cancelled', { title: row.title, resource: this.label(row.resource), id: row.record_id });
+        });
+    }
+    query(db = this.db) {
+        return db('assignments as a')
+            .leftJoin('users as u', 'u.id', 'a.assignee_id')
+            .leftJoin('users as b', 'b.id', 'a.assigned_by')
+            .select('a.*', 'u.full_name as assignee_name', 'b.full_name as assigned_by_name');
+    }
+    present(row, actor) {
+        const open = row.status === 'open';
+        return {
+            id: Number(row.id),
+            resource: String(row.resource),
+            resourceLabel: this.label(row.resource),
+            recordId: Number(row.record_id),
+            assigneeId: Number(row.assignee_id),
+            assigneeName: row.assignee_name ? String(row.assignee_name) : null,
+            assignedBy: row.assigned_by === null ? null : Number(row.assigned_by),
+            assignedByName: row.assigned_by_name ? String(row.assigned_by_name) : null,
+            kind: String(row.kind),
+            title: String(row.title),
+            note: row.note === null ? null : String(row.note),
+            dueOn: dateOnly(row.due_on),
+            status: row.status,
+            outcome: row.outcome === null || row.outcome === undefined ? null : String(row.outcome),
+            createdAt: new Date(row.created_at).toISOString(),
+            completedAt: row.completed_at ? new Date(row.completed_at).toISOString() : null,
+            workflowRunId: row.workflow_run_id ? String(row.workflow_run_id) : null,
+            canComplete: open && !row.workflow_run_id && Number(row.assignee_id) === actor.id,
+            canCancel: open && !row.workflow_run_id && Number(row.assigned_by) === actor.id,
+        };
+    }
+    label(name) {
+        try {
+            return this.resources.label(name);
+        }
+        catch {
+            return name;
+        }
+    }
+    async canView(name, id, userId) {
+        const user = await this.db('users').where('id', userId).first('disabled_at');
+        if (!user || user.disabled_at)
+            return false;
+        return this.resources.permits(name, id, await this.actors.load(userId));
+    }
+}

package/build/src/collaboration/record_collaboration.d.ts

@@ -0,0 +1,86 @@
+import type { Knex } from 'knex';
+import type { Actor } from '../auth/ability.js';
+import type { ResourceService } from '../admin/resource_service.js';
+import type { JsonValue, Resource } from '../resource/types.js';
+import type { Listener } from '../events/outbox.js';
+export type ActorLoader = {
+    load(id: number): Promise<Actor>;
+};
+export type CommentEntry = {
+    id: number;
+    body: string;
+    authorId: number;
+    authorName: string | null;
+    mentions: {
+        id: number;
+        name: string;
+    }[];
+    createdAt: string;
+    editedAt: string | null;
+    own: boolean;
+};
+export type FieldChangeEntry = {
+    id: number;
+    field: string;
+    before: JsonValue;
+    after: JsonValue;
+    actorName: string | null;
+    createdAt: string;
+};
+export type RecordCollaborationState = {
+    comments: CommentEntry[];
+    hasMoreComments: boolean;
+    tags: string[];
+    following: boolean;
+    followers: number;
+    changes: FieldChangeEntry[];
+    canComment: boolean;
+    canTag: boolean;
+};
+export type MentionCandidate = {
+    id: number;
+    name: string;
+};
+/**
+ * Collaboration around a record: comments with mentions, followers, tags and the
+ * per-field change history. Every read and write re-authorizes the record itself
+ * through ResourceService, so these features can never widen record access.
+ */
+export declare class RecordCollaboration {
+    private db;
+    private resources;
+    private actors;
+    constructor(db: Knex, resources: ResourceService, actors: ActorLoader);
+    state(name: string, id: number, actor: Actor): Promise<RecordCollaborationState>;
+    private readChanges;
+    comment(name: string, id: number, actor: Actor, input: {
+        body: unknown;
+        mentions?: unknown;
+    }): Promise<CommentEntry>;
+    /** Authors edit or remove their own comments while they can still read the record. */
+    editComment(name: string, id: number, comment: unknown, actor: Actor, body: unknown): Promise<void>;
+    deleteComment(name: string, id: number, comment: unknown, actor: Actor): Promise<void>;
+    follow(name: string, id: number, actor: Actor, following: boolean): Promise<void>;
+    /** Replaces the record's tags. Tagging changes how a record is found, so it needs update. */
+    setTags(name: string, id: number, actor: Actor, input: unknown): Promise<string[]>;
+    tags(name: string, id: number): Promise<string[]>;
+    /** Tag vocabulary used on records of a resource the actor may list. */
+    tagOptions(name: string, actor: Actor): Promise<string[]>;
+    /** Active users that may read the record, for the mention picker. */
+    mentionCandidates(name: string, id: number, actor: Actor, search?: string): Promise<MentionCandidate[]>;
+    /**
+     * Listener factory: followers hear about updates and document transitions of the
+     * records they follow, but only while they can still read the record.
+     */
+    followerListener(module: string, resource: string, event: string): Listener;
+    private label;
+    private canView;
+    /** Parsed after the record is authorized, so malformed ids never bypass the 403. */
+    private commentId;
+    private userIds;
+}
+/** Follower notifications for every registered resource's update and document events. */
+export declare function followerListeners(registry: {
+    all(): Resource[];
+    owner(name: string): string;
+}, collaboration: () => RecordCollaboration): Listener[];