letopis 1.4.2 → 2.0.0

package/dist/admin.js

@@ -1,60 +1,25 @@
-import { LetopisError, fromDbError } from './errors.js';
+/**
+ * Эксплуатация (план, этап 6, п. 7, 8): maintain и его запуск по расписанию. Всё проверяет база: функция владельца
+ * 90-time.sql сама сверяет права (letopis.maintain — системный администратор или администраторское подключение).
+ */
+import { lerr, lmsg, lwarn } from './errors.js';
 import { runTx } from './tx.js';
-import { CHAIN_METHODS, DB_METHODS } from './types.js';
-/** Внутренняя опция maintain(): остановка запуска по расписанию — текущая пачка доделывается, следующая не начинается. */
-export const MAINTAIN_STOP = Symbol('letopis.maintain.stop');
-const SYSTEM_CLASSES = new Set(['Class', 'Account', 'member', 'Resource', 'rule']);
-const one = async (a, text, params = []) => a.exec.run(async (q) => (await q.unsafe(text, params))[0]);
-export async function verify(a, opts = {}) {
-    const r = await one(a, `select ${a.S}.verify($1::boolean) as v`, [opts.data === true]);
-    return r.v;
-}
 /**
- * Обслуживание: истёкшие сессии и коды, прореживание журнала пачками (каждая — своя транзакция,
- * долгих блокировок нет), заполнение очереди сигналов. Из нескольких процессов работает один: пачка
- * первым делом берёт строку-замок обслуживания (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 async function maintain(a, opts = {}) {
+export async function maintain(a) {
     if (a.exec.explicit)
-        throw new LetopisError('invalid_query', 'maintain() — пачками в своих транзакциях, не внутри db.begin()');
-    const now = opts.now === undefined ? null : opts.now instanceof Date ? opts.now.toISOString() : opts.now;
-    const report = { skipped: false, sessions: 0, codes: 0, thinned: 0, batches: 0, more: false, queue: 0 };
-    const max = opts.batches ?? 100;
-    for (let i = 0; i < max; i++) {
-        // запуск по расписанию остановлен (close()): следующая пачка не начинается, отчёт — с more: true
-        if (i > 0 && opts[MAINTAIN_STOP]?.())
-            break;
-        // блокировку берёт сама maintain() базы — строку-замок, которую посторонняя роль не займёт; занята — null.
-        // Истёкшие сессии и коды — только в первой пачке (план 2.0, 7.3 №4); схема, функции которой ещё не обновил up()
-        // (нет третьего аргумента, 42883), — прежний вызов: он чистит в каждой пачке
-        const call = (cleanup) => runTx(a.txc, (q) => q.unsafe(cleanup === null
-            ? `select ${a.S}.maintain($1::text::timestamptz, $2::int) as r`
-            : `select ${a.S}.maintain($1::text::timestamptz, $2::int, $3::boolean) as r`, (cleanup === null ? [now, opts.limit ?? 10_000] : [now, opts.limit ?? 10_000, cleanup])));
-        const [{ r }] = await call(i === 0).catch((e) => {
-            if (e.code === '42883')
-                return call(null);
-            throw e;
-        });
-        if (r === null) {
-            if (i === 0)
-                return { ...report, skipped: true };
-            break;
-        }
-        const b = r;
-        report.sessions += b.sessions;
-        report.codes += b.codes;
-        report.thinned += b.thinned;
-        report.queue = Number(b.queue);
-        report.more = b.more;
-        report.batches++;
-        if (!b.more)
-            break;
-    }
+        throw lerr('time.maintain_in_tx');
+    const [{ r }] = await runTx(a.txc, (q) => q.unsafe(`select ${a.S}.maintain() as r`));
+    if (r === null)
+        return { skipped: true, sessions: 0, codes: 0, queue: 0 };
+    const b = r;
+    const report = { skipped: false, sessions: b.sessions, codes: b.codes, queue: Number(b.queue) };
     const warn = queueWarning(report.queue);
     if (warn)
         console.warn(warn);
@@ -62,7 +27,7 @@ export async function maintain(a, opts = {}) {
 }
 /** Предупреждение о заполненной очереди сигналов (§2.12): больше половины — зависший слушатель. */
 export function queueWarning(queue) {
-    return queue > 0.5 ? `letopis: очередь сигналов PostgreSQL заполнена на ${(queue * 100).toFixed(0)} % — проверьте зависших слушателей` : null;
+    return queue > 0.5 ? `letopis: ${lmsg('time.signal_queue', { pct: (queue * 100).toFixed(0) })}` : null;
 }
 /** Самый длинный интервал таймера Node.js — 2³¹−1 мс (около 24,8 суток): дольше таймер не ждёт и срабатывает сразу. */
 const MAX_TIMER_MS = 2 ** 31 - 1;
@@ -82,14 +47,14 @@ export function parseInterval(v) {
     }
     if (!Number.isFinite(ms) || ms < 1 || ms > MAX_TIMER_MS) {
         const shown = typeof v === 'string' ? `'${v}'` : typeof v === 'number' || typeof v === 'boolean' || v == null ? String(v) : typeof v;
-        throw new LetopisError('invalid_data', `интервал ${shown}: число мс или строка '30s', '15m', '1h', '1d' — от 1 мс до 2³¹−1 мс (около 24 суток)`);
+        throw lerr('time.bad_interval', { value: shown });
     }
     return ms;
 }
 /**
  * Запуск maintain() по расписанию (connect({ maintain: '1h' }); ms — уже проверенный интервал): ошибки — предупреждением,
- * следующий запуск не начинается, пока идёт прежний. Возвращает остановку: она снимает таймер, просит идущий запуск не
- * начинать новых пачек и ждёт его конца — close() закрывает пул после неё, а не посреди пачки.
+ * следующий запуск не начинается, пока идёт прежний. Возвращает остановку: она снимает таймер и ждёт конца идущего
+ * запуска — close() закрывает пул после него, а не посреди транзакции.
  */
 export function scheduleMaintain(run, ms) {
     let stopped = false;
@@ -97,8 +62,8 @@ export function scheduleMaintain(run, ms) {
     const timer = setInterval(() => {
         if (current || stopped)
             return;
-        current = run(() => stopped)
-            .then(() => { }, (e) => console.warn(`letopis: maintain по расписанию: ${e.message}`))
+        current = run()
+            .then(() => { }, (e) => lwarn('time.maintain_failed', { message: e.message }))
             .finally(() => (current = null));
     }, ms);
     timer.unref?.();
@@ -108,128 +73,3 @@ export function scheduleMaintain(run, ms) {
         await current;
     };
 }
-/**
- * Сброс (этап 6, п. 6). Предохранители — в базе: флаг allowReset установки, право letopis.reset,
- * подтверждение именем схемы. tenant — пачками (длинная операция не держит горизонт подписок).
- */
-export async function reset(a, opts) {
-    if (opts.level === 'tenant') {
-        if (a.exec.explicit)
-            throw new LetopisError('invalid_query', "reset({ level: 'tenant' }) — пачками в своих транзакциях, не внутри db.begin()");
-        let rows = 0;
-        let versions = 0;
-        for (;;) {
-            const [{ r }] = await runTx(a.txc, (q) => q.unsafe(`select ${a.S}.reset($1, $2, $3::uuid, 10000) as r`, [opts.level, opts.confirm, opts.tenant ?? null]));
-            const b = r;
-            rows += b.rows;
-            versions += b.versions;
-            if (b.done)
-                return { level: opts.level, tenant: b.tenant, rows, versions };
-        }
-    }
-    const r = await one(a, `select ${a.S}.reset($1, $2, $3::uuid) as r`, [opts.level, opts.confirm, opts.tenant ?? null]);
-    return r.r;
-}
-/**
- * Обрезка истории (этап 6, п. 3): версии строже момента before удаляются, текущая — никогда; на место
- * версии 1 встаёт запись trim. target — имя класса (с потомками), id или список id, строка ответа.
- */
-export async function trimHistory(a, target, before) {
-    const at = before instanceof Date ? before.toISOString() : before;
-    let ids = null;
-    let classes = null;
-    if (typeof target === 'string' && a.registry().has(target)) {
-        classes = a.registry().family(target).map((c) => c.name);
-    }
-    else {
-        const list = Array.isArray(target) ? target : [target];
-        ids = list.map((x) => (typeof x === 'string' ? x : x.id));
-    }
-    const r = await one(a, `select ${a.S}.trim_history($1::uuid[], $2::text[], $3::text::timestamptz) as n`, [ids, classes, at]);
-    return r.n;
-}
-/** Новый ключ класса (этап 6, п. 7): строки семейства переносятся на новые id. Возвращает их число. */
-export async function rekeyClass(a, cls, key) {
-    const name = a.registry().resolve(cls).name;
-    const r = await one(a, `select ${a.S}.rekey_class($1, $2::jsonb) as n`, [name, key]);
-    return r.n;
-}
-/**
- * Ремонт агрегатов (план 1.1, §2.4): поля класса и его потомков во всех арендаторах — заново из живых источников,
- * под исключительными блокировками семейств целей и источников (запись в них ждёт). Версия пишется только там, где
- * значение изменилось; возвращает число исправленных строк. Функция владельца — от его роли (set local role), как
- * загрузчик; подключение проверил вызывающий (admin_required).
- */
-export async function rebuildAggregates(env, cls) {
-    if (typeof cls !== 'string' || !cls)
-        throw new LetopisError('invalid_data', 'rebuildAggregates(класс): имя класса');
-    const role = `"${env.ownerRole.replace(/"/g, '""')}"`;
-    return env.sql.begin(async (q) => {
-        await q.unsafe(`set local role ${role}`);
-        await q.unsafe(`select set_config('letopis.reason', 'rebuildAggregates', true)`);
-        const [{ n }] = await q.unsafe(`select ${env.S}.rebuild_aggregates($1) as n`, [cls]);
-        return n;
-    }).catch((e) => {
-        throw fromDbError(e);
-    });
-}
-/** Машинное описание модели арендатора вместе с метаданными классов (этап 6, п. 12). */
-export function describe(a) {
-    const classes = a.registry().all().map((c) => ({
-        name: c.name,
-        kind: c.kind,
-        ...(c.alias ? { alias: c.alias } : {}),
-        abstract: c.abstract,
-        ...(c.ancestors[1] ? { parent: c.ancestors[1] } : {}),
-        ancestors: c.ancestors,
-        system: SYSTEM_CLASSES.has(c.name),
-        fields: (c.schema.properties ?? {}),
-        required: (c.schema.required ?? []),
-        ...(Array.isArray(c.schema.anyOf) ? { anyOf: c.schema.anyOf } : {}),
-        ...(Array.isArray(c.schema.oneOf) ? { oneOf: c.schema.oneOf } : {}),
-        ends: c.ends,
-        key: c.key,
-        history: c.history,
-        ownerDefault: c.ownerDefault,
-        ...(c.cache ? { cache: c.cache } : {}),
-        meta: c.meta,
-        ...(c.derivedBy ? { derivedBy: c.derivedBy } : {}),
-        ...(c.aggregate ? { aggregate: c.aggregate } : {}),
-    })).sort((x, y) => Number(x.system) - Number(y.system) || x.name.localeCompare(y.name));
-    return { schema: a.schema, tenant: a.tenant(), classes, methods: { chain: CHAIN_METHODS, db: DB_METHODS } };
-}
-/** Описание модели текстом для языковых моделей. */
-export function describeText(d) {
-    const out = [`# letopis: модель схемы ${d.schema}`, '',
-        'Цепочка: db.Класс(фильтр).Связь().Класс().rows(); запись — create, update, upsert, delete; история — versions(), asOf(), withDeleted().', ''];
-    for (const c of d.classes) {
-        const title = typeof c.meta.title === 'string' ? ` — ${c.meta.title}` : '';
-        out.push(`## ${c.name}${c.alias ? ` (${c.alias})` : ''}${title}`);
-        out.push(`- вид: ${c.kind === 'hub' ? 'хаб (объект)' : 'связь'}${c.abstract ? ', абстрактный' : ''}${c.parent ? `, предок ${c.parent}` : ''}${c.system ? ', системный' : ''}`);
-        out.push(`- ключ: ${c.key.length ? c.key.join(', ') : 'нет (id выдаёт база)'}`);
-        const fields = Object.entries(c.fields).map(([k, v]) => {
-            const t = v.type;
-            return `${k}${c.required.includes(k) ? '*' : ''}: ${Array.isArray(t) ? t.join('|') : t ?? 'any'}`;
-        });
-        if (fields.length)
-            out.push(`- поля: ${fields.join(', ')}`);
-        if (c.anyOf)
-            out.push(`- условия anyOf (хотя бы одно): ${JSON.stringify(c.anyOf)}`);
-        if (c.oneOf)
-            out.push(`- условия oneOf (ровно одно): ${JSON.stringify(c.oneOf)}`);
-        const ends = Object.entries(c.ends).map(([k, v]) => {
-            const e = v;
-            return `${k}${e.required ? '*' : ''} → ${Array.isArray(e.class) ? e.class.join('|') : e.class}${e.many ? '[]' : ''}`;
-        });
-        if (ends.length)
-            out.push(`- концы: ${ends.join(', ')}`);
-        if (c.derivedBy)
-            out.push(`- производный: строки пишет проектор ${c.derivedBy}, приложение только читает`);
-        for (const [field, a] of Object.entries(c.aggregate ?? {})) {
-            const what = a.sum !== undefined ? `сумма ${a.sum}` : 'число';
-            out.push(`- агрегат ${field} = ${what} строк ${a.of} по концу ${a.via}${a.where ? `, условие ${JSON.stringify(a.where)}` : ''}; поле считает база, приложение его не пишет`);
-        }
-        out.push('');
-    }
-    return out.join('\n');
-}

package/dist/auth.d.ts

@@ -1,5 +1,5 @@
 import type { Executor } from './tx.js';
-/** Хэш пароля scrypt: `scrypt$N$r$p$соль$хэш` (формат 0.21). */
+/** Хэш пароля scrypt: `scrypt$N$r$p$соль$хэш`. */
 export declare function hashPassword(password: string): Promise<string>;
 /** Проверка пароля по хэшу scrypt; другие форматы не проверяются. */
 export declare function verifyHash(password: string, stored: string): Promise<boolean>;
@@ -196,7 +196,7 @@ export interface AuthApi {
         roles: string[];
     }[]>;
     /**
-     * Удалить аккаунт (этап 6; accounts.purge 0.21): системный администратор или владелец его
+     * Удалить аккаунт: системный администратор или владелец его
      * арендатора; себя и последнего владельца арендатора — нельзя. Данные арендатора стираются,
      * владение строками в чужих арендаторах переходит им, сессии гаснут, креды удаляются. Владелец стирает
      * и арендатора, в котором работает: его сессия возвращается в личный арендатор.

package/dist/auth.js

@@ -11,11 +11,11 @@
  */
 import { createHmac, randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
 import { promisify } from 'node:util';
-import { LetopisError, removed } from './errors.js';
+import { lerr } from './errors.js';
 const scryptAsync = promisify(scrypt);
 const SCRYPT = { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 };
 const KEYLEN = 32;
-/** Хэш пароля scrypt: `scrypt$N$r$p$соль$хэш` (формат 0.21). */
+/** Хэш пароля scrypt: `scrypt$N$r$p$соль$хэш`. */
 export async function hashPassword(password) {
     const salt = randomBytes(16);
     const hash = await scryptAsync(password, salt, KEYLEN, SCRYPT);
@@ -31,7 +31,7 @@ export async function verifyHash(password, stored) {
     // которому нужно больше, или с недопустимыми параметрами scrypt Node.js отвергает — это понятная ошибка, а не «неверный
     // пароль» (false). Текст Node.js в сообщение не идёт: он зависит от сборки OpenSSL
     const got = await scryptAsync(password, Buffer.from(saltB64, 'base64'), want.length, { N: Number(N), r: Number(r), p: Number(p), maxmem: SCRYPT.maxmem }).catch(() => {
-        throw new LetopisError('invalid_data', `хэш пароля: параметры scrypt N=${N}, r=${r}, p=${p} недопустимы или требуют больше 64 МБ памяти`);
+        throw lerr('access.bad_scrypt_params', { N, r, p });
     });
     return got.length === want.length && timingSafeEqual(got, want);
 }
@@ -61,7 +61,7 @@ export function base32Decode(s) {
     for (const ch of s.replace(/=+$/, '').toUpperCase()) {
         const idx = B32.indexOf(ch);
         if (idx < 0)
-            throw new LetopisError('invalid_data', 'секрет TOTP — не base32');
+            throw lerr('access.bad_totp_secret');
         value = (value << 5) | idx;
         bits += 5;
         if (bits >= 8) {
@@ -86,16 +86,6 @@ const accId = (a) => (typeof a === 'object' ? a.id : a);
 const ttlOf = (sec) => (sec === undefined ? null : `${Math.round(sec)} seconds`);
 /** Фасад db.auth. onSwitch — подключение перечитывает арендатора, реестр и пропуска прав. */
 export function makeAuth(S, exec, onSwitch, canSwitch) {
-    const api = makeAuthCore(S, exec, onSwitch, canSwitch);
-    return new Proxy(api, {
-        get(t, p, r) {
-            if (p === 'sessions')
-                throw removed('db.auth.sessions(store)', 'сессии хранятся в базе: sessionFor, refresh, revoke, revokeAll');
-            return Reflect.get(t, p, r);
-        },
-    });
-}
-function makeAuthCore(S, exec, onSwitch, canSwitch) {
     const one = async (text, params = []) => {
         const rows = await exec.run((q) => q.unsafe(text, params));
         return rows[0];
@@ -199,7 +189,7 @@ function makeAuthCore(S, exec, onSwitch, canSwitch) {
         },
         async switch(tenant) {
             if (!canSwitch)
-                throw new LetopisError('invalid_query', 'auth.switch() — от корня подключения: при имперсонации арендатора задаёт db.as(…, { tenant })');
+                throw lerr('access.switch_not_root');
             await one(`select ${S}.auth_switch($1::uuid)`, [tenant]);
             await onSwitch();
         },

package/dist/cache.d.ts

@@ -68,6 +68,13 @@ export declare class ResultCache {
     }): string;
     /** Снимок счётчиков классов, пар с арендатором запроса (id) и сессии — до запроса. */
     token(classes: readonly string[], session: string, tenantId?: string | null): CacheToken;
+    /**
+     * Счётчик сессии заводит снимок запроса (token), а сигнал о гашении меняет только заведённые: снимок в полёте бывает
+     * лишь у сессии, которая читала через этот кэш. Гасят же в основном чужие сессии — вход и выход пользователей
+     * сервиса, — и счётчик на каждый тег копил бы карту до предела EPOCH_MAX (долгий прогон: вход и выход раз в секунду —
+     * 0,7–0,9 МБ/ч на подключение). Заведённый счётчик не удаляется: иначе снимок, взятый до гашения, сошёлся бы с нулём.
+     */
+    private watchSession;
     private pairCount;
     get(key: string): unknown[] | undefined;
     /** Положить ответ, если с момента снимка не было сигналов о его классах и сессии. */
@@ -76,7 +83,7 @@ export declare class ResultCache {
     invalidate(classes: Iterable<string>): void;
     /** Сбросить ответы класса в арендаторе (токен) и ответы без арендатора; null — во всех. */
     private invalidateIn;
-    /** Сбросить ответы сессии (тег — начало sha256 токена). */
+    /** Сбросить ответы сессии (тег — начало sha256 токена); счётчик — только у заведённой снимком (watchSession). */
     invalidateSession(tag: string): void;
     /**
      * Счётчик сигналов по ключу (класс, пара «класс, арендатор», сессия). Ключи приходят в нагрузке сигнала, а её

package/dist/cache.js

@@ -5,13 +5,14 @@
  * Ключ — текст запроса, параметры и тот, кто спрашивает (токен, актор, арендатор): под RLS один
  * запрос разным пользователям отдаёт разные строки. Сброс:
  *   - свои записи — сразу после фиксации, по классам из letopis.changed (туда попадают и классы
- *     каскада, unset, смены класса и ключа); запись через db.sql — весь кэш;
+ *     каскада и unset); запись через db.sql — весь кэш;
  *   - чужие записи — по сигналу базы (нагрузка по режиму установки, signals.ts): класс в арендаторе
  *     сигнала (ответ помнит токен арендатора запроса; сигнал System и процесс без ключа — во всех), в режиме
- *     opaque без ключа — весь кэш; классы прав и схемы (rule, Resource, member, Account, Class) и «*» —
- *     весь кэш; `session:<16 hex>` — ответы погашенной сессии, `session:*` — все;
+ *     opaque без ключа — весь кэш; классы прав и схемы (rule, Resource, member, Account, Class) — весь кэш;
+ *     `session:<16 hex>` — ответы погашенной сессии;
  *   - гонка запроса и сигнала: счётчики сигналов по классам, парам «класс, арендатор» и сессиям
- *     снимаются до запроса, ответ кладётся, только если они не изменились;
+ *     снимаются до запроса, ответ кладётся, только если они не изменились; счётчик сессии заводит сам
+ *     снимок — гашение сессии, которая через кэш не читала, следа в картах не оставляет;
  *   - (пере)подключение слушателя сигналов — весь кэш: сигналы за время обрыва потеряны; без слушателя
  *     кэш выключен (с ttlOnly — работает только по сроку);
  *   - срок (по умолчанию 60 с) — предохранитель; ответы истёкшей сессии не используются.
@@ -63,13 +64,32 @@ export class ResultCache {
     /** Снимок счётчиков классов, пар с арендатором запроса (id) и сессии — до запроса. */
     token(classes, session, tenantId) {
         const tenant = this.allTenants ? null : this.sig.tenantToken(tenantId);
+        // счётчик сессии — до снимка epoch: переполнение карты сдвигает epoch
+        const sessionCount = this.watchSession(session);
         return {
             epoch: this.epoch,
             classes: classes.map((c) => [c, this.classEpoch.get(c) ?? 0, this.pairCount(c, tenant)]),
-            session: this.sessionEpoch.get(session) ?? 0,
+            session: sessionCount,
             tenant,
         };
     }
+    /**
+     * Счётчик сессии заводит снимок запроса (token), а сигнал о гашении меняет только заведённые: снимок в полёте бывает
+     * лишь у сессии, которая читала через этот кэш. Гасят же в основном чужие сессии — вход и выход пользователей
+     * сервиса, — и счётчик на каждый тег копил бы карту до предела EPOCH_MAX (долгий прогон: вход и выход раз в секунду —
+     * 0,7–0,9 МБ/ч на подключение). Заведённый счётчик не удаляется: иначе снимок, взятый до гашения, сошёлся бы с нулём.
+     */
+    watchSession(tag) {
+        const n = this.sessionEpoch.get(tag);
+        if (n !== undefined)
+            return n;
+        if (this.sessionEpoch.size >= EPOCH_MAX) {
+            this.sessionEpoch.clear();
+            this.epoch++;
+        }
+        this.sessionEpoch.set(tag, 0);
+        return 0;
+    }
     pairCount(cls, tenant) {
         return (tenant === null ? this.anyEpoch.get(cls) : this.pairEpoch.get(`${cls}@${tenant}`)) ?? 0;
     }
@@ -126,9 +146,11 @@ export class ResultCache {
             if ((e.tenant === null || e.tenant === tenant) && e.classes.includes(cls))
                 this.map.delete(key);
     }
-    /** Сбросить ответы сессии (тег — начало sha256 токена). */
+    /** Сбросить ответы сессии (тег — начало sha256 токена); счётчик — только у заведённой снимком (watchSession). */
     invalidateSession(tag) {
-        this.bump(this.sessionEpoch, tag);
+        const n = this.sessionEpoch.get(tag);
+        if (n !== undefined)
+            this.sessionEpoch.set(tag, n + 1);
         for (const [k, e] of this.map)
             if (e.session === tag)
                 this.map.delete(k);
@@ -161,7 +183,7 @@ export class ResultCache {
                 // класса нет в реестрах процесса — и ответов с ним нет
                 return;
             default:
-                // *, session:*, opaque без ключа, нагрузка не по режиму
+                // переподключение слушателя, opaque без ключа, нагрузка не по режиму
                 return this.clear();
         }
     }

package/dist/chain.d.ts

@@ -2,7 +2,7 @@ import { type ResultCache } from './cache.js';
 import type { ClassInfo, Registry } from './registry.js';
 import { type Step } from './sql.js';
 import type { Executor } from './tx.js';
-import type { BlameOptions, BlameResult, ChainMods, Cursor, DiffOptions, DiffResult, Filter, Path, QueryEvent, Row } from './types.js';
+import type { ChainMods, Cursor, Filter, Path, QueryEvent, Row } from './types.js';
 export interface ChainCtx {
     readonly reg: Registry;
     readonly schema: string;
@@ -69,17 +69,8 @@ export interface ChainCore {
     count(opts?: {
         paths?: boolean;
     }): Promise<number>;
-    /**
-     * Все версии сущностей последнего шага (надгробия — $deleted), по id и номеру версии;
-     * { follow: true } — и через смену id при reclass и rekey, по времени.
-     */
-    versions(opts?: {
-        follow?: boolean;
-    }): Promise<Row[]>;
-    /** Что изменилось между двумя версиями или моментами (по умолчанию — предыдущая версия → последняя), план 1.1. */
-    diff(opts?: DiffOptions): Promise<DiffResult[]>;
-    /** Кто, когда и почему последним изменил каждое поле версии (по умолчанию текущей), план 1.1. */
-    blame(opts?: BlameOptions): Promise<BlameResult[]>;
+    /** Все версии сущностей последнего шага (надгробия — $deleted), по id и номеру версии. */
+    versions(): Promise<Row[]>;
     /**
      * Сумма поля `'data.<путь>'` по объектам последнего шага: значения приводятся к числу, складывает база. `limit()` и
      * `offset()` на итог не влияют; нет ни одного значения — `null`.
@@ -123,7 +114,7 @@ export interface ChainCore {
      * Постраничный вывод по курсору: ответ начинается строго после строки, на которой кончилась прошлая страница, в
      * порядке `sort()` (без `sort()` — ошибка `invalid_query`). Курсор этой строки даёт `cursorOf(строка, поле)` с тем же
      * полем, что в `sort()`. Листает `rows()`, `ids()`, `versions()` и `paths()` (курсор пути — `cursorOf(путь, поле)`);
-     * `count()`, агрегаты, `diff()` и `blame()` курсор не учитывают.
+     * перед `count()` и агрегатами (`sum`, `avg`, `min`, `max`, `countBy`) — `invalid_query`: они считают по всем объектам.
      */
     after(cursor: Cursor): Chain;
     /**
@@ -161,14 +152,19 @@ export interface ChainCore {
      * же цепочка (та же переменная) второй раз в одном пути шагов не добавляет, а возвращает к своему последнему шагу:
      * следующий шаг пойдёт от него.
      */
-    entity(x: Chain | Row): Chain;
+    entity(x: ChainRef | Row): Chain;
     /** Создать объект: концы — из пути и слотов; занятый ключ — ошибка exists с id. */
     create(data?: Record<string, unknown>, opts?: {
         reason?: string;
     }): Chain;
-    /** Новая версия каждой цели шага: слияние патча в базе; inc(n) — приращение; { rev } — с проверкой версии. */
+    /**
+     * Новая версия каждой цели шага: слияние патча в базе; inc(n) — приращение; { rev } — с проверкой версии. Цели сужают
+     * фильтр, id, `tags()`, `owner()` или `limit()` хотя бы у одного шага, иначе `invalid_query`; правка всех строк —
+     * `{ all: true }`.
+     */
     update(patch?: Record<string, unknown>, opts?: {
         rev?: number;
+        all?: boolean;
         reason?: string;
     }): Chain;
     /** Создать или заменить целиком (класс с ключом); строка ответа несёт $upsert. */
@@ -178,18 +174,13 @@ export interface ChainCore {
     /**
      * Удаляет цели шага; строки, которые на них ссылаются, база удаляет вместе с ними, отвязывает или не даёт удалить цель —
      * как задано в `onDelete` их ссылок. Без `{ confirm: true }` — предпросмотр удаления: ничего не удаляется, терминал
-     * вернёт все строки, которых оно коснулось бы, у каждой `$action` — что с ней будет.
+     * вернёт все строки, которых оно коснулось бы, у каждой `$action` — что с ней будет. С `{ confirm: true }` цели сужают
+     * фильтр, id, `tags()`, `owner()` или `limit()` хотя бы у одного шага, иначе `invalid_query`; удаление всех строк —
+     * `{ confirm: true, all: true }`.
      */
     delete(opts?: {
         confirm?: boolean;
-        reason?: string;
-    }): Chain;
-    /** Затереть строковые поля ('[erased]') и пометить тегом anonymized. */
-    anonymize(fields: string[], opts?: {
-        reason?: string;
-    }): Chain;
-    /** Сменить класс: у класса с ключом — новый id и перевод ссылок. */
-    reclass(cls: string, data?: Record<string, unknown>, opts?: {
+        all?: boolean;
         reason?: string;
     }): Chain;
     /** Чтение с блокировкой строк последнего шага до конца db.begin() (rows, first, ids). */
@@ -198,22 +189,6 @@ export interface ChainCore {
     restore(opts?: {
         reason?: string;
     }): Chain;
-    /**
-     * Стирает историю удалённых объектов шага: все их версии в журнале, от каждого остаётся одна запись `purge`. Удалённые
-     * объекты шаг находит сам, без `withDeleted()`. Без `{ confirm: true }` — предпросмотр: ничего не стирается, терминал
-     * вернёт надгробия с `$versions` — сколько версий сотрётся.
-     */
-    purge(opts?: {
-        confirm?: boolean;
-        reason?: string;
-    }): Chain;
-    /**
-     * Новое значение ключа объектов шага. id вычисляется из ключа, поэтому объект получает новый id: ссылки других строк
-     * на него переводятся на новый id, а журнал связывает старый id с новым.
-     */
-    rekey(patch: Record<string, unknown>, opts?: {
-        reason?: string;
-    }): Chain;
     /** Кэш результатов (§2.12): ответ хранится в памяти процесса ttl секунд (по умолчанию 60). */
     cache(opts?: {
         ttl?: number;
@@ -234,6 +209,8 @@ export type StepFn = ((filter?: Filter) => Chain) & {
 export type Chain = ChainCore & {
     [className: string]: StepFn;
 };
+/** Любая цепочка — с типами по моделям (`TypedChain`) или без них (`Chain`): аргумент `entity()` и значение слота. */
+export type ChainRef = Pick<ChainCore, 'ids'>;
 /** Внутренний канал: план чужой ленивой цепочки (entity()). */
 export declare const PLAN: unique symbol;
 /** entity-идентичность: переменная-цепочка → nodeKey её узла в этом пути. */
@@ -253,5 +230,5 @@ export declare function makeBatch(ctx: ChainCtx, queue: BatchEntry[]): Batch;
 /** Старт пути от корня db: класс, алиас или роль. */
 export declare function startStep(ctx: ChainCtx, name: string): StepFn;
 /** Старт пути с готового узла: db.entity(row | цепочка). */
-export declare function startEntity(ctx: ChainCtx, x: Chain | Row): Chain;
+export declare function startEntity(ctx: ChainCtx, x: ChainRef | Row): Chain;
 export {};