letopis 1.4.2 → 2.0.0

package/dist/acl.d.ts

@@ -20,6 +20,52 @@ export interface AclDataDecision {
     allow: boolean;
     filter?: Record<string, unknown>;
 }
+/**
+ * Цель правила на строки: имя класса (правило действует и на потомков), `'*'` — все классы, или класс с условием на
+ * строки — шаблоном колонок `owner`, `tenant`, `tags`, `data`, `links`, `id` (`'$actor'` — тот, от чьего имени запрос,
+ * `'$tenant'` — рабочий арендатор): `{ class: 'Ticket', owner: '$actor' }`.
+ */
+export type AclTarget = string | ({
+    class: string;
+} & {
+    [column: string]: unknown;
+});
+/**
+ * Что разрешить, запретить или снять: кому — ровно одно из `role` и `everyone` (иначе `invalid_data`), операции — с
+ * классами, ресурсами приложения или с теми и другими.
+ */
+export interface AclRuleSpec {
+    /** Роль членства в текущем арендаторе (как в `member.roles`). */
+    role?: string;
+    /** Все аккаунты арендатора, кроме анонимных и теневых, — группа правил «можно всё» от createTenant. */
+    everyone?: true;
+    read?: AclTarget | readonly AclTarget[];
+    write?: AclTarget | readonly AclTarget[];
+    delete?: AclTarget | readonly AclTarget[];
+    /** Ресурсы приложения — маски эндпоинтов, как у `check()`: `'reports.*'` — `reports.daily`, но не `reports`. */
+    api?: string | readonly string[];
+    /** Вес правила, целое от 1 до 999; по умолчанию 50 — сильнее правила «можно всё» (вес 10) от createTenant. */
+    weight?: number;
+}
+/** Правило арендатора в виде обёртки. */
+export interface AclRule {
+    id: string;
+    /** Роль группы `role:<роль>:ACCOUNT`; null — группа не одной роли (все аккаунты или своя группа). */
+    role: string | null;
+    /** Группа всех аккаунтов арендатора: `authenticated:ACCOUNT` от createTenant или `everyone:ACCOUNT` обёртки. */
+    everyone: boolean;
+    /** Alias группы. */
+    group: string;
+    op: AclOp | 'API';
+    /** Класс (`'*'` — все классы) или маска эндпоинта. */
+    target: string;
+    /** Условие на строки — шаблон колонок. */
+    condition?: Record<string, unknown>;
+    permission: 'allow' | 'deny';
+    weight: number;
+    /** Действует ли правило: `false` — выключено полем `enabled` строки `rule`, база его не применяет. */
+    enabled: boolean;
+}
 export interface AclApi {
     /**
      * Можно ли тому, от чьего имени идёт запрос, обратиться к ресурсу приложения (эндпоинту). Решают правила доступа
@@ -31,5 +77,36 @@ export interface AclApi {
      * что подходят под условие `filter` в ответе.
      */
     checkData(className: string, op: AclOp): Promise<AclDataDecision>;
+    /**
+     * Разрешить роли (`role`) или всем аккаунтам арендатора (`everyone: true`) операции с классами и ресурсы приложения —
+     * по правилу на каждую операцию и цель, с весом `weight` (по умолчанию 50). Повтор ничего не меняет; запрет той же
+     * группы и цели заменяется разрешением. Внутри `db.begin()` — в её транзакции, иначе — своей.
+     */
+    grant(spec: AclRuleSpec): Promise<AclRule[]>;
+    /** Запретить — те же правила с запретом: при равном весе запрет сильнее разрешения. */
+    deny(spec: AclRuleSpec): Promise<AclRule[]>;
+    /**
+     * Снять правила роли или всех аккаунтов — разрешения и запреты — для этих операций и целей; число снятых.
+     * `revoke({ everyone: true, read: '*', write: '*', delete: '*' })` снимает «можно всё» от createTenant: дальше права —
+     * только по ролям.
+     */
+    revoke(spec: Omit<AclRuleSpec, 'weight'>): Promise<number>;
+    /**
+     * Роли аккаунта в текущем арендаторе (строка `member`); null — не член. Со списком ролей — заменить их (членство
+     * заводится, если его нет), с null — снять членство. Сам арендатор (вход под его аккаунтом) — владелец без строки
+     * `member`: для него ответ null.
+     */
+    roles(account: string | {
+        id: string;
+    }, roles?: readonly string[] | null): Promise<string[] | null>;
+    /**
+     * Правила текущего арендатора — свои и «можно всё» от createTenant. На подключении без RLS (`allowBypassRls`) — тоже
+     * только правила арендатора сессии, без правил других арендаторов и System.
+     */
+    list(): Promise<AclRule[]>;
 }
-export declare function makeAcl(S: string, exec: Executor): AclApi;
+/**
+ * db.acl фасада. db — сам фасад (корень, db.as(), db.begin()): запись правил идёт его цепочками, внутри db.begin() — в её
+ * транзакции.
+ */
+export declare function makeAcl(S: string, exec: Executor, db?: () => unknown): AclApi;

package/dist/acl.js

@@ -1,11 +1,180 @@
 /**
- * db.acl — решения прав для приложения (план, §2.8, этап 5, п. 7). Сами права применяет база
- * (политики RLS по плану прав, 50-acl.sql); эти вызовы отвечают «можно ли» заранее — для интерфейса
- * и эндпоинтов приложения. Правила — строки Resource и rule (группа → объект, allow | deny, вес);
- * решение — ровно одно правило с наибольшим весом, при равном весе запрет сильнее, нет правил — запрет.
+ * db.acl — права приложения (план, §2.8, этап 5, п. 7; план 2.0, этап 3, п. 1). Сами права применяет база
+ * (политики RLS по плану прав, 50-acl.sql); check и checkData отвечают «можно ли» заранее — для интерфейса и
+ * эндпоинтов приложения. Правила — строки Resource и rule (группа → объект, allow | deny, вес); решение — ровно одно
+ * правило с наибольшим весом, при равном весе запрет сильнее, нет правил — запрет.
+ *
+ * Запись правил (план 2.0, 7.9 №1): grant, deny, revoke, roles и list — обёртка над теми же строками Resource, rule и
+ * member текущего арендатора, цепочками фасада: право на саму запись, триггеры и RLS проверяет база, как у любой
+ * записи. Alias ресурсов обёртки детерминированные — группа `role:<роль>:ACCOUNT`, объект `class:<класс>[условие]:<ОП>`
+ * или `api:<эндпоинт>:API`, — а ключ правила — пара [Group, Object]: повтор вызова строк и версий не заводит, а grant
+ * после deny той же роли и цели заменяет запрет разрешением. Ресурсы обёртки живут в арендаторе: ссылку правила
+ * арендатора на ресурс System база не пропустит (цель должна быть видна).
+ *
+ * Все аккаунты арендатора (`everyone: true` вместо `role`): группа обёртки `everyone:ACCOUNT` с маской группы
+ * `authenticated:ACCOUNT` System — её правила «можно всё» (вес 10) заводит createTenant. revoke для всех аккаунтов
+ * снимает правила обеих групп, а цель `'*'` — и объект обёртки `class:*:<ОП>`, и объект System `all:<ОП>`: так
+ * `revoke({ everyone: true, read: '*', write: '*', delete: '*' })` снимает «можно всё». Строк System арендатор не видит,
+ * их id — `v5Id(System, 'Resource', [alias])`.
  */
-import { removed } from './errors.js';
-export function makeAcl(S, exec) {
+import { lerr } from './errors.js';
+import { internalsOf } from './internal.js';
+import { v5Id } from './uuid.js';
+const SYSTEM_ID = '2eba6d0a-1edd-4bb6-a85a-a703dab49035';
+/** Имя класса — как в метасхеме Class (40-class.sql). */
+const NAME = /^[A-Za-zА-Яа-яЁё_][A-Za-zА-Яа-яЁё0-9_]{0,62}$/;
+/** Колонки, на которые ставят условие правила (шаблон acl_row_ok, 50-acl.sql). */
+const COLUMNS = ['id', 'owner', 'tenant', 'tags', 'data', 'links'];
+const OPS = { read: 'READ', write: 'WRITE', delete: 'DELETE' };
+/** Ресурсы сида System (95-seed.system.sql): на них ссылаются правила grantAll арендатора, а самих строк арендатор не видит. */
+const SYSTEM_RESOURCES = ['anonymous:ACCOUNT', 'authenticated:ACCOUNT', 'any:ACCOUNT', 'service:ACCOUNT', 'admin:ACCOUNT',
+    'any:API', 'auth:API', 'letopis:API', 'signals:API', 'all:READ', 'all:WRITE', 'all:DELETE'];
+/** JSON с ключами объектов по порядку: одно условие — один alias. */
+function canon(v) {
+    if (Array.isArray(v))
+        return `[${v.map(canon).join(',')}]`;
+    if (v && typeof v === 'object') {
+        return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canon(v[k])}`).join(',')}}`;
+    }
+    return JSON.stringify(v);
+}
+/**
+ * Имя роли — по тому же правилу, что роли createTenant: маска группы делит роли по запятой и берёт их в скобки. what —
+ * метод db.acl (grant, deny, revoke, roles): им начинается текст ошибки, как и у classItem, apiItem и parse.
+ */
+function roleName(v, what) {
+    if (typeof v !== 'string')
+        throw lerr('access.role_not_string', { what, type: v === null ? 'null' : typeof v });
+    if (!v || v !== v.trim() || /[,{}]/.test(v) || v.startsWith('!')) {
+        throw lerr('access.bad_role_name', { what, role: JSON.stringify(v) });
+    }
+    return v;
+}
+const many = (v) => (Array.isArray(v) ? v : [v]);
+function groupOf(role) {
+    return { alias: `role:${role}:ACCOUNT`, category: 'ACCOUNT', pattern: { roles: `{${role}}` } };
+}
+/** Все аккаунты арендатора: маска как у группы authenticated:ACCOUNT System (95-seed.system.sql). */
+const EVERYONE = { alias: 'everyone:ACCOUNT', category: 'ACCOUNT', pattern: { categories: '!{Anonymous,Shadow}' } };
+function classItem(op, t, what) {
+    let cls = t;
+    let cond = {};
+    if (t && typeof t === 'object' && !Array.isArray(t)) {
+        ({ class: cls, ...cond } = t);
+        for (const k of Object.keys(cond)) {
+            if (!COLUMNS.includes(k))
+                throw lerr('access.bad_condition_column', { what, column: k, columns: COLUMNS.join(', ') });
+        }
+    }
+    if (typeof cls !== 'string' || (cls !== '*' && !NAME.test(cls))) {
+        throw lerr('access.bad_rule_target', { what, target: JSON.stringify(t) });
+    }
+    const condition = Object.keys(cond).length ? cond : undefined;
+    return {
+        op, category: op, target: cls,
+        alias: `class:${cls}${condition ? canon(condition) : ''}:${op}`,
+        pattern: { ...(cls === '*' ? {} : { class: cls }), ...cond },
+        ...(condition ? { condition } : {}),
+    };
+}
+function apiItem(ep, what) {
+    if (typeof ep !== 'string' || !/^[\p{L}\p{N}_.*{},-]+$/u.test(ep)) {
+        throw lerr('access.bad_endpoint_mask', { what, endpoint: JSON.stringify(ep) });
+    }
+    return { op: 'API', category: 'API', target: ep, alias: `api:${ep}:API`, pattern: { endpoint: ep } };
+}
+/** Спецификация правила; role — null, когда правило для всех аккаунтов арендатора (everyone: true). */
+function parse(spec, what, withWeight) {
+    if (!spec || typeof spec !== 'object' || Array.isArray(spec))
+        throw lerr('access.rule_spec_not_object', { what });
+    const o = spec;
+    const keys = ['role', 'everyone', 'read', 'write', 'delete', 'api', ...(withWeight ? ['weight'] : [])];
+    for (const k of Object.keys(o))
+        if (!keys.includes(k))
+            throw lerr('access.unknown_rule_field', { what, field: k, fields: keys.join(', ') });
+    // кому: ровно одно из role и everyone: true
+    if (o.everyone === undefined ? o.role === undefined : o.everyone !== true || o.role !== undefined) {
+        throw lerr('access.rule_who', { what });
+    }
+    const role = o.everyone === true ? null : roleName(o.role, what);
+    let weight = 50;
+    if (o.weight !== undefined) {
+        if (typeof o.weight !== 'number' || !Number.isInteger(o.weight) || o.weight < 1 || o.weight > 999) {
+            throw lerr('access.bad_rule_weight', { what });
+        }
+        weight = o.weight;
+    }
+    const items = [];
+    for (const [key, op] of Object.entries(OPS)) {
+        if (o[key] !== undefined)
+            for (const t of many(o[key]))
+                items.push(classItem(op, t, what));
+    }
+    if (o.api !== undefined)
+        for (const ep of many(o.api))
+            items.push(apiItem(ep, what));
+    if (!items.length)
+        throw lerr('access.no_rule_operations', { what });
+    return { role, weight, items };
+}
+/** Роль группы обёртки и групп вида `{роль}`; иначе null. */
+function roleOf(pattern) {
+    const p = pattern;
+    if (!p || p.categories !== undefined || typeof p.roles !== 'string')
+        return null;
+    const m = /^\{([^,{}!]+)\}$/.exec(p.roles);
+    return m ? m[1] : null;
+}
+/**
+ * db.acl фасада. db — сам фасад (корень, db.as(), db.begin()): запись правил идёт его цепочками, внутри db.begin() — в её
+ * транзакции.
+ */
+export function makeAcl(S, exec, db) {
+    const facade = () => {
+        const d = db?.();
+        if (!d)
+            throw lerr('access.no_facade');
+        return d;
+    };
+    async function inTx(what, fn) {
+        const d = facade();
+        if (internalsOf(d)?.explicit)
+            return fn(d);
+        const tr = await d.begin({ reason: `db.acl.${what}` });
+        try {
+            const r = await fn(tr);
+            await tr.commit();
+            return r;
+        }
+        catch (e) {
+            await tr.rollback().catch(() => { });
+            throw e;
+        }
+    }
+    /** Ресурс целиком (upsert по alias): та же строка — пустая правка, без новой версии. */
+    async function resource(tr, r) {
+        const [row] = await tr.Resource().upsert({ alias: r.alias, category: r.category, pattern: r.pattern }).rows();
+        return row.id;
+    }
+    async function put(spec, permission, what) {
+        const p = parse(spec, what, true);
+        return inTx(what, async (tr) => {
+            const group = p.role === null ? EVERYONE : groupOf(p.role);
+            const g = await resource(tr, group);
+            const out = [];
+            for (const it of p.items) {
+                const o = await resource(tr, it);
+                const [r] = await tr.rule().upsert({ permission, weight: p.weight }).Group.set(g).Object.set(o).rows();
+                out.push({ id: r.id, role: p.role, everyone: p.role === null, group: group.alias, op: it.op, target: it.target,
+                    ...(it.condition ? { condition: it.condition } : {}), permission, weight: p.weight, enabled: true });
+            }
+            return out;
+        });
+    }
+    /** id ресурса сида System: строку арендатор не видит, ссылаться на неё правилом обёртки не может. */
+    const sysId = (alias) => v5Id(SYSTEM_ID, 'Resource', [alias]);
+    const sys = new Map(SYSTEM_RESOURCES.map((a) => [sysId(a), a]));
+    const AUTHENTICATED = sysId('authenticated:ACCOUNT');
     const api = {
         async check(endpoint) {
             const [r] = await exec.run((q) => q.unsafe(`select ${S}.acl_check($1) as d`, [endpoint]), { read: true });
@@ -15,12 +184,94 @@ export function makeAcl(S, exec) {
             const [r] = await exec.run((q) => q.unsafe(`select ${S}.acl_check_data($1, $2) as d`, [className, op]), { read: true });
             return r.d;
         },
-    };
-    return new Proxy(api, {
-        get(t, p, r) {
-            if (p === 'reload')
-                throw removed('db.acl.reload()', 'права обновляются сами: база применяет действующие правила');
-            return Reflect.get(t, p, r);
+        grant: (spec) => put(spec, 'allow', 'grant'),
+        deny: (spec) => put(spec, 'deny', 'deny'),
+        async revoke(spec) {
+            const p = parse(spec, 'revoke', false);
+            return inTx('revoke', async (tr) => {
+                const find = async (alias) => (await tr.Resource({ alias }).rows())[0]?.id;
+                // все аккаунты — группа обёртки и группа «можно всё» System
+                const groups = p.role === null ? [await find(EVERYONE.alias), AUTHENTICATED] : [await find(groupOf(p.role).alias)];
+                let n = 0;
+                for (const it of p.items) {
+                    const objects = [await find(it.alias)];
+                    // все классы — объект обёртки class:*:<ОП> и объект «можно всё» System all:<ОП>
+                    if (it.op !== 'API' && it.target === '*' && !it.condition)
+                        objects.push(sysId(`all:${it.op}`));
+                    for (const g of groups) {
+                        for (const o of objects) {
+                            if (g && o)
+                                n += (await tr.rule({ Group: g, Object: o }).delete({ confirm: true }).rows()).length;
+                        }
+                    }
+                }
+                return n;
+            });
+        },
+        async roles(account, roles) {
+            const acc = typeof account === 'object' && account !== null ? account.id : account;
+            if (typeof acc !== 'string' || !acc)
+                throw lerr('access.bad_account');
+            const d = facade();
+            const tenant = d.tenant;
+            if (!tenant)
+                throw lerr('access.no_session_tenant', { what: 'roles' });
+            if (roles === undefined) {
+                const [m] = await d.member({ User: acc, Tenant: tenant }).rows();
+                return m ? [...(m.data.roles ?? [])] : null;
+            }
+            if (roles === null) {
+                await inTx('roles', (tr) => tr.member({ User: acc, Tenant: tenant }).delete({ confirm: true }).rows());
+                return null;
+            }
+            if (!Array.isArray(roles))
+                throw lerr('access.roles_not_array');
+            const list = roles.map((r) => roleName(r, 'roles'));
+            if (new Set(list).size !== list.length)
+                throw lerr('access.duplicate_roles');
+            await inTx('roles', (tr) => tr.member().upsert({ roles: list }).User.set(acc).Tenant.set(tenant).rows());
+            return list;
         },
-    });
+        async list() {
+            const d = facade();
+            const tenant = d.tenant?.toLowerCase();
+            if (!tenant)
+                throw lerr('access.no_session_tenant', { what: 'list' });
+            // под RLS строки rule — только арендатора сессии; роль без RLS видит правила всех арендаторов и System
+            const rules = (await d.rule().rows()).filter((r) => String(r.tenant).toLowerCase() === tenant);
+            const res = new Map((await d.Resource().rows()).map((r) => [r.id, r.data]));
+            const out = rules.map((r) => {
+                const g = res.get(r.links.Group);
+                const o = res.get(r.links.Object);
+                let op;
+                let target;
+                let condition;
+                if (o) {
+                    op = o.category === 'ACCOUNT' ? 'API' : o.category;
+                    const { class: cls, endpoint, ...rest } = (o.pattern ?? {});
+                    target = String((op === 'API' ? endpoint : cls) ?? '*');
+                    if (op !== 'API' && Object.keys(rest).length)
+                        condition = rest;
+                }
+                else {
+                    // ресурс System (grantAll от createTenant): арендатор строку не видит — по id сида
+                    const a = sys.get(r.links.Object) ?? r.links.Object;
+                    op = a.split(':').pop() ?? 'READ';
+                    target = /^(all|any):/.test(a) ? '*' : a.split(':')[0];
+                }
+                const group = g?.alias ?? sys.get(r.links.Group) ?? r.links.Group;
+                return {
+                    id: r.id, role: g ? roleOf(g.pattern) : null,
+                    everyone: r.links.Group === AUTHENTICATED || (group === EVERYONE.alias && !sys.has(r.links.Group)), group, op, target,
+                    ...(condition ? { condition } : {}),
+                    permission: r.data.permission === 'allow' ? 'allow' : 'deny', weight: Number(r.data.weight ?? 0),
+                    // как acl_plan_for (50-acl.sql): нет поля — правило действует
+                    enabled: r.data.enabled !== false,
+                };
+            });
+            const key = (x) => `${x.op}\u0000${x.target}\u0000${x.role ?? x.group}\u0000${x.permission}`;
+            return out.sort((a, b) => (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0));
+        },
+    };
+    return api;
 }

package/dist/admin.d.ts

@@ -1,35 +1,4 @@
-/**
- * Эксплуатация (план, этап 6, п. 3, 4, 6–8, 12): verify, maintain и его запуск по расписанию, reset,
- * обрезка истории, новый ключ класса, describe. Всё проверяет база: функции владельца 90-time.sql
- * сами сверяют права (letopis.* — системный администратор или администраторское подключение).
- */
-import type postgres from 'postgres';
-import type { AggregateInfo, Registry } from './registry.js';
 import { type Executor, type TxContext } from './tx.js';
-type Sql = postgres.Sql<Record<string, unknown>>;
-export interface VerifyIssue {
-    id: string;
-    rev?: number;
-    class?: string;
-    problem: string;
-    [k: string]: unknown;
-}
-export interface VerifyResult {
-    ok: boolean;
-    issues: VerifyIssue[];
-    /** Один хэш текущих версий всех объектов — храните его вне базы: подмену самых свежих версий выдаст его расхождение. */
-    anchor: string;
-}
-export interface MaintainOptions {
-    /** Момент «сейчас» для прореживания — только в установке с `allowReset` (тесты). */
-    now?: string | Date;
-    /** Сколько пачек прореживания журнала самое большее сделать за один вызов; каждая пачка — своя транзакция. */
-    batches?: number;
-    /** Сколько версий самое большее удалить в одной пачке прореживания. */
-    limit?: number;
-}
-/** Внутренняя опция maintain(): остановка запуска по расписанию — текущая пачка доделывается, следующая не начинается. */
-export declare const MAINTAIN_STOP: unique symbol;
 export interface MaintainReport {
     /** Другой процесс уже обслуживает установку (держит строку-замок обслуживания): этот вызов ничего не делал. */
     skipped: boolean;
@@ -40,92 +9,24 @@ export interface MaintainReport {
      * заменённых новым и исчерпавших попытки.
      */
     codes: number;
-    /** Прорежено версий журнала. */
-    thinned: number;
-    batches: number;
-    /** Прореживание не дошло до конца журнала — следующий вызов продолжит. */
-    more: boolean;
     /** Заполнение очереди сигналов PostgreSQL (0…1); больше половины — предупреждение. */
     queue: number;
 }
-export interface ResetOptions {
-    level: 'sessions' | 'tenant' | 'all';
-    /** Подтверждение — имя схемы установки. */
-    confirm: string;
-    /** Какого арендатора сбросить при `level: 'tenant'` — его id; на других уровнях не учитывается. */
-    tenant?: string;
-}
-export interface ResetResult {
-    level: string;
-    sessions?: number;
-    tenant?: string;
-    rows?: number;
-    versions?: number;
-    /** `level: 'all'` — новый ключ сервиса: прежние сессии и ключи больше не действуют. */
-    serviceKey?: string;
-}
-/** Машинное описание модели (`db.describe()`). */
-export interface ModelDescription {
-    schema: string;
-    tenant: string | null;
-    classes: {
-        name: string;
-        kind: 'hub' | 'link';
-        alias?: string;
-        abstract: boolean;
-        parent?: string;
-        ancestors: string[];
-        system: boolean;
-        fields: Record<string, unknown>;
-        required: string[];
-        /** Условия по нескольким полям (`fields.anyOf` описания с учётом наследования): хотя бы одно должно выполняться. */
-        anyOf?: unknown[];
-        /** Условия по нескольким полям (`fields.oneOf`): ровно одно должно выполняться. */
-        oneOf?: unknown[];
-        ends: Record<string, unknown>;
-        key: string[];
-        history: unknown;
-        ownerDefault: string;
-        cache?: {
-            ttl?: number;
-        };
-        meta: Record<string, unknown>;
-        /** Производный класс: строки пишет только проектор с этим именем (план 1.1, §2.4). */
-        derivedBy?: string;
-        /** Агрегатные поля: сумма или число живых строк класса-источника, их считает база (план 1.1, §2.4). */
-        aggregate?: Record<string, AggregateInfo>;
-    }[];
-    methods: {
-        chain: readonly string[];
-        db: readonly string[];
-    };
-}
 export interface AdminCtx {
-    sql: Sql;
-    schema: string;
     /** Схема в кавычках. */
     S: string;
     txc: TxContext;
     exec: Executor;
-    registry: () => Registry;
-    tenant: () => string | null;
 }
-export declare function verify(a: AdminCtx, opts?: {
-    data?: boolean;
-}): Promise<VerifyResult>;
 /**
- * Обслуживание: истёкшие сессии и коды, прореживание журнала пачками (каждая — своя транзакция,
- * долгих блокировок нет), заполнение очереди сигналов. Из нескольких процессов работает один: пачка
- * первым делом берёт строку-замок обслуживания (lock_try в maintain() базы: for update skip locked строки
- * secret, которую посторонняя роль не займёт), и та снимается с фиксацией пачки. Сеансовая блокировка
- * за пулом в режиме транзакций (PgBouncer) оставалась бы на
- * серверном соединении, которое пул отдаёт другим клиентам, — и обслуживание молча вставало бы
- * (skipped у всех). Блокировку держит другой процесс: до первой пачки — skipped; между пачками —
- * вызов останавливается (продолжит тот процесс), отчёт — о сделанном, more: true.
+ * Обслуживание: истёкшие и погашенные сессии, одноразовые коды, строки-замки удалённых семейств и заполнение очереди
+ * сигналов — одной транзакцией. Из нескольких процессов работает один: maintain() базы первым делом берёт строку-замок
+ * обслуживания (lock_try: for update skip locked строки secret, которую посторонняя роль не займёт), и та снимается с
+ * фиксацией. Сеансовая блокировка за пулом в режиме транзакций (PgBouncer) оставалась бы на серверном соединении,
+ * которое пул отдаёт другим клиентам, — и обслуживание молча вставало бы (skipped у всех). Строку-замок держит другой
+ * процесс — skipped.
  */
-export declare function maintain(a: AdminCtx, opts?: MaintainOptions & {
-    [MAINTAIN_STOP]?: () => boolean;
-}): Promise<MaintainReport>;
+export declare function maintain(a: AdminCtx): Promise<MaintainReport>;
 /** Предупреждение о заполненной очереди сигналов (§2.12): больше половины — зависший слушатель. */
 export declare function queueWarning(queue: number): string | null;
 /**
@@ -136,39 +37,7 @@ export declare function queueWarning(queue: number): string | null;
 export declare function parseInterval(v: unknown): number;
 /**
  * Запуск maintain() по расписанию (connect({ maintain: '1h' }); ms — уже проверенный интервал): ошибки — предупреждением,
- * следующий запуск не начинается, пока идёт прежний. Возвращает остановку: она снимает таймер, просит идущий запуск не
- * начинать новых пачек и ждёт его конца — close() закрывает пул после неё, а не посреди пачки.
+ * следующий запуск не начинается, пока идёт прежний. Возвращает остановку: она снимает таймер и ждёт конца идущего
+ * запуска — close() закрывает пул после него, а не посреди транзакции.
  */
-export declare function scheduleMaintain(run: (stopped: () => boolean) => Promise<unknown>, ms: number): () => Promise<void>;
-/**
- * Сброс (этап 6, п. 6). Предохранители — в базе: флаг allowReset установки, право letopis.reset,
- * подтверждение именем схемы. tenant — пачками (длинная операция не держит горизонт подписок).
- */
-export declare function reset(a: AdminCtx, opts: ResetOptions): Promise<ResetResult>;
-/**
- * Обрезка истории (этап 6, п. 3): версии строже момента before удаляются, текущая — никогда; на место
- * версии 1 встаёт запись trim. target — имя класса (с потомками), id или список id, строка ответа.
- */
-export declare function trimHistory(a: AdminCtx, target: string | string[] | {
-    id: string;
-} | {
-    id: string;
-}[], before: string | Date): Promise<number>;
-/** Новый ключ класса (этап 6, п. 7): строки семейства переносятся на новые id. Возвращает их число. */
-export declare function rekeyClass(a: AdminCtx, cls: string, key: string[]): Promise<number>;
-/**
- * Ремонт агрегатов (план 1.1, §2.4): поля класса и его потомков во всех арендаторах — заново из живых источников,
- * под исключительными блокировками семейств целей и источников (запись в них ждёт). Версия пишется только там, где
- * значение изменилось; возвращает число исправленных строк. Функция владельца — от его роли (set local role), как
- * загрузчик; подключение проверил вызывающий (admin_required).
- */
-export declare function rebuildAggregates(env: {
-    sql: Sql;
-    S: string;
-    ownerRole: string;
-}, cls: string): Promise<number>;
-/** Машинное описание модели арендатора вместе с метаданными классов (этап 6, п. 12). */
-export declare function describe(a: AdminCtx): ModelDescription;
-/** Описание модели текстом для языковых моделей. */
-export declare function describeText(d: ModelDescription): string;
-export {};
+export declare function scheduleMaintain(run: () => Promise<unknown>, ms: number): () => Promise<void>;