letopis 1.4.0 → 1.4.2

package/dist/project.js

@@ -1,4 +1,5 @@
 import { LetopisError, fromDbError } from './errors.js';
+import { release, rollbackAfter } from './tx.js';
 import { toRow } from './sql.js';
 import { wakes } from './watch.js';
 import { schemaRevision, SYSTEM_ID } from './up.js';
@@ -67,6 +68,10 @@ function change(row, cursor, rebuild = false) {
  * значениями (22…) и пределами размера (54…). Сбой окружения (блокировки, отмена запроса, связь) — не причина
  * выводить арендатора: пачка откатывается целиком, повтор начнётся с того же курсора.
  */
+/** «1 прохода», «2 проходов», «21 прохода» — число проходов в родительном падеже («в течение …»). */
+function passesGen(n) {
+    return `${n} ${n % 10 === 1 && n % 100 !== 11 ? 'прохода' : 'проходов'}`;
+}
 /** Ожидание чужой блокировки строки дольше lock_timeout (55P03): сбой окружения, проход повторяется. */
 function lockWait(e) {
     return e?.code === '55P03';
@@ -161,17 +166,32 @@ class Out {
         if (key !== null)
             this.folds.set(key, d);
     }
+    /**
+     * Строка для delete и get. У класса с ключом её называют полями ключа: id такой строки — v5 от ключа, и по одному id
+     * (строкой или { $id }) база искала бы строку с пустым ключом — get отвечал бы null, а delete выводил арендатора с
+     * id_mismatch. Это ошибка кода handle, а не данных: invalid_data сразу, пачка откатывается целиком.
+     */
+    target(cls, tenant, keyOrId) {
+        const row = this.rowOf(keyOrId);
+        const key = this.p.keyOf(tenant, cls);
+        if (key.length && Object.keys(row).every((n) => n === '$id')) {
+            throw new LetopisError('invalid_data', `проектор ${this.p.name}: у класса ${cls} есть ключ (${key.join(', ')}) — строку называют полями ключа, например { ${key.map((k) => `${k}: …`).join(', ')} }, а не id`);
+        }
+        return row;
+    }
     delete(cls, keyOrId, opts) {
         const tenant = this.check(cls, opts?.tenant);
+        const row = this.target(cls, tenant, keyOrId);
         this.folds.clear();
-        this.ops.push({ op: 'delete', class: cls, tenant, row: this.rowOf(keyOrId) });
+        this.ops.push({ op: 'delete', class: cls, tenant, row });
     }
     async get(cls, keyOrId, opts) {
         const tenant = this.check(cls, opts?.tenant);
+        const row = this.target(cls, tenant, keyOrId);
         await this.flush();
         const S = this.p.env.S;
         const [r] = await this.db(() => this.q.unsafe(`select ${rowJson('e')} as row from ${S}.entity e
-      where e.id = ${S}.derived_id($1, $2::uuid, $3::text::jsonb) and e.class = $1 and e.tenant = $2::uuid`, [cls, tenant, JSON.stringify(this.rowOf(keyOrId))]));
+      where e.id = ${S}.derived_id($1, $2::uuid, $3::text::jsonb) and e.class = $1 and e.tenant = $2::uuid`, [cls, tenant, JSON.stringify(row)]));
         return r ? toRow(r.row) : null;
     }
     async flush() {
@@ -202,6 +222,10 @@ export class Projector {
     /** Источники арендатора без журнала (history: false): их изменений проектор не увидит — арендатор выбывает. */
     blind = new Map();
     stale = true;
+    /** Когда состав читался в последний раз: без LISTEN сигнала о новых классах нет (план 2.0, 7.4 №6). */
+    resolvedAt = 0;
+    /** Участники, которых чекпоинт ещё не знает: им начальная перестройка пачками (tenantWork). */
+    newcomers = [];
     /** В чекпоинте есть начатая перестройка арендатора пачками (по последней пачке; до первой — проверить). */
     tenantsPending = true;
     running = false;
@@ -215,6 +239,13 @@ export class Projector {
     /** Проходов подряд, в которых запись арендатора упиралась в lockTimeout (lockRetries). */
     lockHits = new Map();
     only;
+    /**
+     * Перечитать состав: по сигналу классов, а без LISTEN (сигналов нет) — не реже раза в 5 с, как реестр подключения в
+     * режиме none, и в начале run() (план 2.0, 7.4 №6): иначе арендатор, вступивший после запуска, не участвовал бы.
+     */
+    due() {
+        return this.stale || (!this.env.onSignal && Date.now() - this.resolvedAt >= 5000);
+    }
     constructor(env, name, def) {
         this.env = env;
         this.def = def;
@@ -267,6 +298,8 @@ export class Projector {
             throw new LetopisError('invalid_query', `проектор ${this.name} уже запущен в этом процессе`);
         this.running = true;
         this.stopped = false;
+        if (!this.env.onSignal)
+            this.stale = true;
         const rep = emptyReport();
         try {
             for (;;) {
@@ -371,7 +404,7 @@ export class Projector {
     }
     async status() {
         return this.tx(async (q) => {
-            if (this.stale)
+            if (this.due())
                 await this.resolve(q);
             const [r] = await q.unsafe(`select s.meta from ${this.env.S}.secret s
         where s.kind = 'PROJECTOR' and s.ident = $1 and s.account = $2::uuid and s.deleted_at is null`, [this.name, SYSTEM_ID]);
@@ -412,6 +445,7 @@ export class Projector {
     /** Транзакция под ролью владельца на отдельном соединении пула. */
     async tx(fn) {
         const q = await this.env.sql.reserve();
+        let failure = null;
         try {
             await q.unsafe('begin isolation level read committed');
             await q.unsafe(`set local role ${ident(this.env.ownerRole)}`);
@@ -425,11 +459,13 @@ export class Projector {
             return out;
         }
         catch (e) {
-            await q.unsafe('rollback').catch(() => { });
+            // обрыв: rollback и возврат мёртвого соединения в пул роняли процесс (план 2.0, 7.4 №7)
+            failure = e;
+            await rollbackAfter(q, e);
             throw fromDbError(e);
         }
         finally {
-            q.release();
+            release(q, failure);
         }
     }
     async lock(q) {
@@ -525,6 +561,7 @@ export class Projector {
         this.scopes = scopes;
         this.tenants = tenants;
         this.stale = false;
+        this.resolvedAt = Date.now();
     }
     /** Одна пачка журнала. */
     async step(rep) {
@@ -533,7 +570,7 @@ export class Projector {
                 rep.skipped++;
                 return 'busy';
             }
-            if (this.stale)
+            if (this.due())
                 await this.resolve(q);
             const meta = await this.state(q);
             if (!meta.cursor || meta.state === 'rebuilding')
@@ -541,6 +578,12 @@ export class Projector {
             if (meta.version !== this.def.version)
                 throw this.versionError(meta);
             this.tenantsPending = Object.values(meta.retenant ?? {}).some((v) => !v.done);
+            // участники, которых чекпоинт не знает (вступили после проекции): начальную перестройку пачками начнёт tenantWork,
+            // их изменения до неё учтёт она же (план 2.0, 7.4 №5)
+            const known = new Set(meta.tenants ?? this.tenants);
+            this.newcomers = this.tenants.filter((x) => !known.has(x) && !meta.failed?.[x] && !meta.retenant?.[x]);
+            if (this.newcomers.length)
+                this.tenantsPending = true;
             const cur = dec(meta.cursor);
             const rows = await q.unsafe(`select l.tx::text as tx, l.seq::text as seq, ${rowJson('l')} as row
         from ${this.env.S}.watch_read($1::text::xid8, $2::bigint, null, $3::text[], $4::int, $5::text::pg_snapshot, true) l`, [cur.tx, cur.seq, [...this.from, '#reset'], this.batch, cur.snap ?? null]);
@@ -573,6 +616,8 @@ export class Projector {
                 const snap = keepSnap(cur.snap, r.tx);
                 pos = { tx: r.tx, seq: r.seq, ...(snap ? { snap } : {}) };
                 const row = toRow(r.row);
+                if (this.newcomers.includes(row.tenant))
+                    continue;
                 const leaves = this.leaves(row, failed);
                 if (!leaves && !this.ours(row, failed))
                     continue;
@@ -602,7 +647,8 @@ export class Projector {
                 await this.apply(q, changes, rep, failed);
             }
             const caught = rows.length < this.batch;
-            const next = withFailed({ ...meta, cursor: enc(pos) }, failed);
+            // состав — известные нынешние участники: выбывший из участников, вернувшись, снова новичок
+            const next = withFailed({ ...meta, cursor: enc(pos), tenants: this.tenants.filter((x) => known.has(x)) }, failed);
             if (!rows.length) {
                 // пусто: отметить время прохода, но не чаще раза в минуту — иначе каждый опрос писал бы чекпоинт
                 if (meta.at && Date.now() - Date.parse(meta.at) < 60_000)
@@ -751,7 +797,7 @@ export class Projector {
                     failed[tenant] = {
                         cursor: list[0].cursor || start,
                         code: '55P03',
-                        message: `проектор ${this.name}: строку арендатора ${tenant} держит чужая транзакция — ${hits} проходов подряд дольше lockTimeout`,
+                        message: `проектор ${this.name}: строку арендатора ${tenant} держит чужая транзакция — в течение ${passesGen(hits)} подряд дольше lockTimeout`,
                     };
                     continue;
                 }
@@ -808,10 +854,17 @@ export class Projector {
         const sc = this.scopes.get(row.tenant);
         return sc !== undefined && !failed?.[row.tenant] && row.op === 'reclass' && !row.moved && !sc.from.has(row.class) && row.class !== '#reset';
     }
-    /** Класс результата в арендаторе — из его семейства into. */
+    /**
+     * Входит ли класс `cls` в классы `into` проектора у арендатора `tenant` — сами эти классы или их потомки. Служебный
+     * метод: им `out` проверяет, что `handle` пишет только в эти классы.
+     */
     intoOf(tenant, cls) {
         return this.scopes.get(tenant)?.into.has(cls) ?? false;
     }
+    /** Поля ключа класса into арендатора (пусто — класс без ключа). */
+    keyOf(tenant, cls) {
+        return this.scopes.get(tenant)?.keys.get(cls) ?? [];
+    }
     /**
      * Ключ свёртки inc: класс и строка из одних полей ключа класса или одного $id; иначе null. Строку с другими полями
      * (данные, $tags, $owner) inc не складывает: её поля правят строку, и порядок таких правок важен.
@@ -876,7 +929,8 @@ export class Projector {
             // выбывший посреди перестройки — без производных строк: прежние пачки построили их лишь частично
             if (Object.keys(failed).length)
                 await this.clear(q, Object.keys(failed));
-            await this.advance(q, meta.cursor, withFailed({ cursor: enc(head), at: await this.now(q), version: this.def.version, state: 'running' }, failed));
+            await this.advance(q, meta.cursor, withFailed({ cursor: enc(head), at: await this.now(q), version: this.def.version, state: 'running',
+                tenants: [...this.tenants] }, failed));
             rep.rebuilds++;
         });
     }
@@ -918,7 +972,7 @@ export class Projector {
             const r = await this.tx(async (q) => {
                 if (!(await this.lock(q)))
                     return busy();
-                if (this.stale)
+                if (this.due())
                     await this.resolve(q);
                 const meta = await this.state(q);
                 const rb = meta.rebuild;
@@ -936,7 +990,7 @@ export class Projector {
                 const real = rows.filter((r) => r.row);
                 if (!real.length) {
                     await this.advance(q, meta.cursor, withFailed({ cursor: rb.start, at: await this.now(q), version: this.def.version, state: 'running',
-                        chunks: [...rb.chunks, { upto: LAST_ID, snap: rows[0].snap }] }, failed));
+                        chunks: [...rb.chunks, { upto: LAST_ID, snap: rows[0].snap }], tenants: [...this.tenants] }, failed));
                     rep.rebuilds++;
                     return 'done';
                 }
@@ -1064,7 +1118,7 @@ export class Projector {
                 const resync = { ...(meta.resync ?? {}) };
                 delete resync[tenant];
                 const next = { ...meta, retenant: { ...(meta.retenant ?? {}), [tenant]: { last: null, chunks: [] } },
-                    since: { ...(meta.since ?? {}), [tenant]: now }, resync };
+                    since: { ...(meta.since ?? {}), [tenant]: now }, resync, tenants: [...new Set([...(meta.tenants ?? this.tenants), tenant])] };
                 if (!Object.keys(resync).length)
                     delete next.resync;
                 await this.advance(q, meta.cursor, withFailed(next, failed));
@@ -1094,7 +1148,7 @@ export class Projector {
                 rep.skipped++;
                 return 'busy';
             }
-            if (this.stale)
+            if (this.due())
                 await this.resolve(q);
             const meta = await this.state(q);
             const rt = meta.retenant?.[tenant];
@@ -1151,6 +1205,12 @@ export class Projector {
         if (!meta.cursor || meta.state === 'rebuilding' || meta.version !== this.def.version)
             return false;
         let more = false;
+        // новые участники — начальная перестройка пачками и без onExpired (план 2.0, 7.4 №5)
+        const newcomers = this.newcomers;
+        this.newcomers = [];
+        for (const t of newcomers)
+            if ((await this.startTenant(rep, t, true)) === 'ok')
+                more = true;
         if (start) {
             for (const [t, f] of Object.entries(meta.failed ?? {})) {
                 if (f.code !== 'cursor_expired' || this.blind.has(t) || !this.scopes.has(t))
@@ -1159,7 +1219,7 @@ export class Projector {
                     more = true;
             }
         }
-        const fresh = start ? await this.tx(async (q) => this.state(q)) : meta;
+        const fresh = start || newcomers.length ? await this.tx(async (q) => this.state(q)) : meta;
         for (const [t, v] of Object.entries(fresh.retenant ?? {})) {
             if (v.done)
                 continue;

package/dist/registry.d.ts

@@ -68,7 +68,10 @@ export declare class Registry {
     all(): ClassInfo[];
     /** Класс и все его потомки (семейство). */
     family(name: string): ClassInfo[];
-    /** Тип листа по пути полей класса: по JSON Schema (type и format). */
+    /**
+     * Тип листа — поля в конце пути `path` — у класса `cls`, по его JSON Schema (`type` и `format`). По этому типу
+     * библиотека сравнивает значения поля в фильтрах, сортировке и итогах.
+     */
     leafType(cls: string, path: readonly string[]): LeafType;
 }
 export {};

package/dist/registry.js

@@ -70,7 +70,10 @@ export class Registry {
         const root = this.resolve(name).name;
         return this.all().filter((c) => c.ancestors.includes(root));
     }
-    /** Тип листа по пути полей класса: по JSON Schema (type и format). */
+    /**
+     * Тип листа — поля в конце пути `path` — у класса `cls`, по его JSON Schema (`type` и `format`). По этому типу
+     * библиотека сравнивает значения поля в фильтрах, сортировке и итогах.
+     */
     leafType(cls, path) {
         let node = this.resolve(cls).schema;
         for (const p of path) {

package/dist/signals.d.ts

@@ -57,10 +57,6 @@ export declare class Signals {
     /** Разобрать нагрузку сигнала или элемент letopis.changed своей транзакции. */
     parse(p: string): Signal;
 }
-/**
- * Не чаще раза в ms: первый вызов — сразу, вызовы внутри окна — один раз в его конце. Так заливка
- * канала сигналами (в том числе поддельными) не превращается в поток перечитываний реестра.
- */
 /**
  * Ведро жетонов: count вызовов подряд — сразу, дальше не чаще раза в ms (жетон возвращается раз в ms); вызовы
  * в ожидании сливаются в один. Короткая серия проходит без задержки, заливка — с заданной частотой.
@@ -68,6 +64,10 @@ export declare class Signals {
 export declare function bucket(fn: () => void, count: number, ms: number): (() => void) & {
     stop(): void;
 };
+/**
+ * Не чаще раза в ms: первый вызов — сразу, вызовы внутри окна — один раз в его конце. Так заливка
+ * канала сигналами (в том числе поддельными) не превращается в поток перечитываний реестра.
+ */
 export declare function throttle(fn: () => void, ms: number): (() => void) & {
     stop(): void;
 };

package/dist/signals.js

@@ -104,10 +104,6 @@ export class Signals {
         return cls ? { kind: 'class', cls, tenant } : { kind: 'unknown', tenant };
     }
 }
-/**
- * Не чаще раза в ms: первый вызов — сразу, вызовы внутри окна — один раз в его конце. Так заливка
- * канала сигналами (в том числе поддельными) не превращается в поток перечитываний реестра.
- */
 /**
  * Ведро жетонов: count вызовов подряд — сразу, дальше не чаще раза в ms (жетон возвращается раз в ms); вызовы
  * в ожидании сливаются в один. Короткая серия проходит без задержки, заливка — с заданной частотой.
@@ -140,6 +136,10 @@ export function bucket(fn, count, ms) {
         },
     });
 }
+/**
+ * Не чаще раза в ms: первый вызов — сразу, вызовы внутри окна — один раз в его конце. Так заливка
+ * канала сигналами (в том числе поддельными) не превращается в поток перечитываний реестра.
+ */
 export function throttle(fn, ms) {
     let last = -Infinity;
     let timer = null;

package/dist/sql.d.ts

@@ -1,5 +1,5 @@
 import type { ClassInfo, LeafType, Registry } from './registry.js';
-import { type ChainMods, type Cursor, type Filter, type Row } from './types.js';
+import { type ChainMods, type Cursor, type Filter, type Path, type Row } from './types.js';
 export interface Step {
     /** Имя, как вызвано в цепочке (класс, алиас или роль). */
     name: string;
@@ -37,7 +37,7 @@ export interface AggSpec {
 export interface BuiltQuery {
     text: string;
     params: unknown[];
-    /** Ключи шагов в путях (алиасы, повторы — _2, _3). */
+    /** Ключи шагов в путях (алиасы, повторы — _2, _3) в порядке шагов; ключ узла последнего шага — последний. */
     keys: string[];
     /** Тип листа агрегата (min/max числового поля приводятся к числу). */
     aggLeaf?: LeafType;
@@ -62,8 +62,12 @@ export interface Hop {
  *    хаб → связь — назад; связь → хаб и хаб → хаб — вперёд; нет нужного — другое направление.
  */
 export declare function resolveHop(reg: Registry, prev: Step, next: Step): Hop;
-/** Курсор keyset-пагинации из последней строки страницы. */
-export declare function cursorOf(row: Row, field: string): Cursor;
+/**
+ * Курсор постраничного вывода для `after()`: значение поля сортировки, id и номер версии последней строки страницы.
+ * Поле — то же, что в `sort()`; если его нет в данных строки, `v` — `null`. Для пути из `paths()` — то же по его
+ * последнему узлу (узлу последнего шага) и id всех узлов: курсор отделяет пути с общим последним узлом.
+ */
+export declare function cursorOf(row: Row | Path, field: string): Cursor;
 export interface BuildOptions {
     /**
      * Режим сверки (тест find-ids-parity): вместо функций владельца find_* — те же запросы прямо

package/dist/sql.js

@@ -295,7 +295,7 @@ function compileFilter(reg, classes, filter, p) {
             const id = idOfValue(value) ?? fail(`конец ${key}: ожидался id, строка ответа или null`);
             out.ends.push(id);
             const ph = p.push(id);
-            out.frags.push((a) => `@S@.role_has(${a}.links, array[${role}], ${ph}::uuid)`);
+            out.frags.push((a) => `${SCHEMA_MARK}.role_has(${a}.links, array[${role}], ${ph}::uuid)`);
             continue;
         }
         if (isOp(value)) {
@@ -422,22 +422,60 @@ function cursorParams(c, sort) {
     }
     return { v: value, id };
 }
-/** Курсор keyset-пагинации из последней строки страницы. */
+/** rev курсора: в versions() отделяет версии одного объекта с равным полем сортировки (план 2.0, 7.1 №4). */
+function cursorRev(c) {
+    const rev = c.rev;
+    if (rev === undefined)
+        return undefined;
+    if (!Number.isInteger(rev) || rev < 1)
+        return fail(`after(cursor): rev курсора — номер версии (целое ≥ 1), а не ${shown(rev)}`);
+    return rev;
+}
+/** id узлов пути из курсора paths() по ключам узлов (план 2.0, 7.1 №3); курсор без path — undefined. */
+function cursorPath(c, keys) {
+    const path = c.path;
+    if (path === undefined)
+        return undefined;
+    return keys.map((k) => {
+        const id = typeof path === 'object' && path !== null ? path[k] : undefined;
+        if (typeof id !== 'string' || !UUID_RE.test(id))
+            return fail(`after(cursor): в курсоре пути нет id узла ${k} — нужен cursorOf(путь, поле) из paths() этой же цепочки`);
+        return id;
+    });
+}
+const isPath = (x) => typeof x.id !== 'string'
+    && Object.values(x).length > 0 && Object.values(x).every((n) => typeof n === 'object' && n !== null && typeof n.id === 'string');
+/**
+ * Курсор постраничного вывода для `after()`: значение поля сортировки, id и номер версии последней строки страницы.
+ * Поле — то же, что в `sort()`; если его нет в данных строки, `v` — `null`. Для пути из `paths()` — то же по его
+ * последнему узлу (узлу последнего шага) и id всех узлов: курсор отделяет пути с общим последним узлом.
+ */
 export function cursorOf(row, field) {
+    if (isPath(row)) {
+        const keys = Object.keys(row);
+        const { v, id } = cursorOf(row[keys[keys.length - 1]], field);
+        return { v, id, path: Object.fromEntries(keys.map((k) => [k, row[k].id])) };
+    }
     const f = field === 'updated' ? 'at' : field;
+    const rev = typeof row.rev === 'number' ? { rev: row.rev } : {};
     if (f === 'at' || f === 'rev' || f === 'id')
-        return { v: row[f], id: row.id };
+        return { v: row[f], id: row.id, ...rev };
     if (f.startsWith('data.')) {
         let v = row.data;
         for (const k of f.slice(5).split('.'))
             v = v?.[k];
-        return { v: (v ?? null), id: row.id };
+        return { v: (v ?? null), id: row.id, ...rev };
     }
     return fail(`cursorOf: поле 'at', 'rev', 'id' или 'data.<путь>', а не '${field}'`);
 }
 // ---------------------------------------------------------------------------
 // Построение запроса
 // ---------------------------------------------------------------------------
+/**
+ * Метка схемы во фрагментах, собранных до имени схемы: символ NUL не бывает в тексте PostgreSQL, поэтому замена не
+ * заденет литералы — имя поля вида a@S@b прежде портилось (план 2.0, 7.1 №5).
+ */
+const SCHEMA_MARK = '\u0000S\u0000';
 const COLS = ['id', 'rev', 'class', 'tenant', 'owner', 'links', 'data', 'tags', 'at', 'author', 'agent', 'op', 'reason', 'moved'];
 /** Колонки журнала, выданные приложению: все, кроме changed (ревью №1 точки А плана 1.1, 10-core.sql). */
 const LOG_COLS = ['seq', 'tx', 'id', 'rev', 'class', 'cv', 'tenant', 'owner', 'links', 'data', 'tags', 'at', 'author', 'agent', 'op', 'reason',
@@ -523,7 +561,8 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
                 return `(select v.id, v.rev from ${S}.entity v where v.class = any (${clsPh})${dataCond('v')}${endsCond('v.ends')}`
                     + `${ids ? ` and v.id = any (${ids})` : ''})`;
             }
-            return `(select v.id, v.rev from ${versionsAt(at, ids ? `l.id = any (${ids})` : `l.class = any (${clsPh})`)} v `
+            // по классу: id-кандидаты классов шага, последняя версия — любого класса (как find_ids, план 2.0, 7.1 №1)
+            return `(select v.id, v.rev from ${versionsAt(at, ids ? `l.id = any (${ids})` : `l.id in (select c.id from ${S}.log c where c.class = any (${clsPh}))`)} v `
                 + `where v.class = any (${clsPh}) and (v.op = 'delete') = ${isDead} and v.op not in ('purge', 'trim', 'reset')${dataCond('v')}${endsCond(`${S}.link_ids(v.links)`)})`;
         };
         const entityPart = (src, depth = 'null::int', from = `${S}.entity x`) => `select ${colsOf('x')}, ${depth} as depth from ${from} where ${where('x', src)}`;
@@ -609,10 +648,13 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
                     + `where (v.op = 'delete') = ${isDead} and v.op not in ('purge', 'trim', 'reset')${dataCond('v')}${endsCond(`${S}.link_ids(v.links)`)}${rolesCond('v', 's.src')})`;
             };
             ctes.push(`p${i}a as (select q.src, q.id, q.rev from ${hopCall(atPh, false)} q)`);
-            parts.push(cur ? entityByIds(`select q.id from p${i}a q`) : logPart(`select q.id, q.rev from p${i}a q`));
+            // пары переходов — по одной на (источник, цель): объект, который ссылается на несколько объектов прошлого шага,
+            // встречается в них несколько раз; строка узла — одна на id, иначе rows(), count() и агрегаты его удваивали
+            // (entityByIds повторы отбрасывает сам, срез asOf() и надгробия withDeleted() — через distinct здесь)
+            parts.push(cur ? entityByIds(`select q.id from p${i}a q`) : logPart(`select distinct q.id, q.rev from p${i}a q`));
             if (dead) {
                 ctes.push(`p${i}d as (select q.src, q.id, q.rev from ${hopCall(atPh, true)} q)`);
-                parts.push(logPart(`select q.id, q.rev from p${i}d q`));
+                parts.push(logPart(`select distinct q.id, q.rev from p${i}d q`));
                 ctes.push(`p${i} as (select src, id from p${i}a union all select src, id from p${i}d)`);
             }
             else {
@@ -646,32 +688,62 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
     const leaf = (path) => leafOf(reg, rowsNode(lastNode), path);
     const sort = mods.order ? sortSpec(mods.order, leaf) : undefined;
     const dir = mods.desc ? ' desc' : '';
-    const orderBy = (a) => (sort ? ` order by ${sort.expr(a)}${dir}, ${a}.id${dir}` : '');
-    const after = (a) => {
+    /** Порядок: поле sort, id строки и разделители равных (id прочих узлов пути). */
+    const orderBy = (a, more = []) => (sort ? ` order by ${[sort.expr(a), `${a}.id`, ...more].map((x) => `${x}${dir}`).join(', ')}` : '');
+    /**
+     * «Строго после курсора» в порядке order by: поле sort, id строки и разделители равных из курсора — rev версии
+     * (versions()) или id прочих узлов пути (paths()). Без них страница начиналась бы после всех строк с тем же полем
+     * и id: терялись бы другие версии объекта и другие пути к тому же узлу. Курсор без rev или path сравнивается по
+     * началу порядка, как прежде.
+     */
+    const after = (a, ties = () => []) => {
         if (!mods.after)
             return undefined;
         if (!sort)
             fail('after(cursor) требует sort(поле)');
         const c = cursorParams(mods.after, sort);
-        if (!sort.nullable)
-            return `(${sort.expr(a)}, ${a}.id) ${mods.desc ? '<' : '>'} (${p.push(c.v)}${sort.pcast}, ${p.push(c.id)}::uuid)`;
+        const t = ties(mods.after);
+        const lt = mods.desc ? '<' : '>';
         // Поле данных бывает null (или его нет): order by ставит такие строки в конец при возрастании и в
         // начало при убывании, а сравнение строк с null даёт null — одно сравнение их теряло, курсор null
         // давал пустую страницу. Здесь null — значение после всех прочих (asc) или перед ними (desc); текст
         // один на оба вида курсора (параметр — с явным приведением: он стоит и в is null).
+        const v = `${p.push(c.v)}${sort.nullable ? sort.pcast || '::text' : sort.pcast}`;
+        const cols = [`${a}.id`, ...t.map((x) => x.col)];
+        const vals = [`${p.push(c.id)}::uuid`, ...t.map((x) => `${p.push(x.val)}${x.cast}`)];
+        if (!sort.nullable)
+            return `(${sort.expr(a)}, ${cols.join(', ')}) ${lt} (${v}, ${vals.join(', ')})`;
         const e = `(${sort.expr(a)})`;
-        const v = `${p.push(c.v)}${sort.pcast || '::text'}`;
-        const id = `${p.push(c.id)}::uuid`;
+        const rest = cols.length === 1 ? `${cols[0]} ${lt} ${vals[0]}` : `(${cols.join(', ')}) ${lt} (${vals.join(', ')})`;
         return mods.desc
-            ? `((${e}, ${a}.id) < (${v}, ${id}) or (${v} is null and (${e} is not null or ${a}.id < ${id})))`
-            : `((${e}, ${a}.id) > (${v}, ${id}) or (${e} is null and (${v} is not null or ${a}.id > ${id})))`;
+            ? `((${e}, ${cols.join(', ')}) < (${v}, ${vals.join(', ')}) or (${v} is null and (${e} is not null or ${rest})))`
+            : `((${e}, ${cols.join(', ')}) > (${v}, ${vals.join(', ')}) or (${e} is null and (${v} is not null or ${rest})))`;
     };
+    // ключи пути — в порядке шагов, узел последнего шага (его строки отдают rows()) — последним: по нему cursorOf(путь)
+    // берёт поле и id курсора, по прочим — разделители путей к одному узлу (план 2.0, 7.1 №3)
+    const others = keyed.filter((k) => k.node !== lastNode);
+    const pathKeys = [...others, ...keyed.filter((k) => k.node === lastNode)].map((k) => k.key);
     const limitOffset = () => (mods.limit !== undefined ? ` limit ${p.push(mods.limit)}::bigint` : '') + (mods.offset !== undefined ? ` offset ${p.push(mods.offset)}::bigint` : '');
-    // versions({ follow: true }): id, связанные колонкой moved (reclass, rekey), в обе стороны
+    // versions({ follow: true }): отрезки истории объектов шага по переносам id (reclass, rekey) в обе стороны — версии
+    // id с номерами (lo, hi]. Надгробие переноса кончает отрезок, первая версия на новом id начинает: объект, заведённый
+    // на прежнем id после переноса, в историю не попадает (план 2.0, 7.1 №2). Тот же обход — history_segments в
+    // lib/sql/75-history.sql (diff и blame); здесь он в самом запросе, чтобы работал и на схеме до up() этой версии.
     if (mode === 'versions' && mods.follow) {
-        ctes.push(`f(id) as (select z.id from ${ents} z union select x.id from f cross join lateral (`
-            + `select l.moved as id from ${S}.log l where l.id = f.id and l.moved is not null `
-            + `union select l.id from ${S}.log l where l.moved = f.id) x)`);
+        // границы отрезка с версией r: строки переноса id — через парную строку по индексу log_moved (moved друг на друга),
+        // без прохода по версиям id
+        const bounds = (i, r) => `cross join lateral (select greatest(coalesce(max(x.rev) filter (where x.op = 'delete' and x.rev < ${r}), 0), `
+            + `coalesce(max(x.rev - 1) filter (where x.op <> 'delete' and x.rev <= ${r}), 0)) as lo, `
+            + `least(min(x.rev) filter (where x.op = 'delete' and x.rev >= ${r}), min(x.rev - 1) filter (where x.op <> 'delete' and x.rev > ${r})) as hi `
+            + `from ${S}.log m join ${S}.log x on x.moved = m.id and x.id = ${i} where m.moved = ${i}) b`;
+        ctes.push(`f(id, lo, hi, n) as (select z.id, b.lo, b.hi, 0 from ${ents} z ${bounds('z.id', 'z.rev')} `
+            + `union select g.id, b.lo, b.hi, g.n from f cross join lateral (`
+            + `select a.moved as id, (select t.rev from ${S}.log t where t.id = a.moved and t.op = 'delete' and t.moved = f.id `
+            + `order by abs(t.seq - a.seq) limit 1) as r, f.n - 1 as n from ${S}.log a `
+            + `where f.n <= 0 and a.id = f.id and a.rev = f.lo + 1 and a.moved is not null and a.op <> 'delete' `
+            + `union all select t.moved, (select a.rev from ${S}.log a where a.id = t.moved and a.op <> 'delete' and a.moved = f.id `
+            + `order by abs(a.seq - t.seq) limit 1), f.n + 1 from ${S}.log t `
+            + `where f.n >= 0 and t.id = f.id and t.rev = f.hi and t.op = 'delete' and t.moved is not null) g ${bounds('g.id', 'g.r')} `
+            + `where g.r is not null and abs(g.n) <= 1000)`);
     }
     const withClause = `with ${mode === 'versions' && mods.follow ? 'recursive ' : ''}${ctes.join(',\n')}\n`;
     let text;
@@ -680,7 +752,12 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
         case 'paths': {
             const obj = keyed.map(({ key, node }) => `${lit(key)}::text, to_jsonb(h${node})`).join(', ');
             const h = `h${lastNode}`;
-            text = `${withClause}select jsonb_build_object(${obj}) as path ${from}${whereOf([...tail, after(h)])}${orderBy(h)}${limitOffset()}`;
+            const ties = (c) => {
+                const ids = cursorPath(c, others.map((k) => k.key));
+                return ids ? others.map((k, j) => ({ col: `h${k.node}.id`, val: ids[j], cast: '::uuid' })) : [];
+            };
+            text = `${withClause}select jsonb_build_object(${obj}) as path ${from}${whereOf([...tail, after(h, ties)])}`
+                + `${orderBy(h, others.map((k) => `h${k.node}.id`))}${limitOffset()}`;
             break;
         }
         case 'rows':
@@ -697,11 +774,17 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
             // с sort — по полю и направлению (последние версии первыми — sort('at', 'desc'), с limit — в самом запросе);
             // без sort: с follow — по времени через все связанные id, без follow — по id и номеру версии
             const order = sort ? `${sort.expr('v')}${dir}, v.id${dir}, v.rev${dir}` : mods.follow ? 'v.at, v.id, v.rev' : 'v.id, v.rev';
+            // курсор — поле sort, id и номер версии: версии одного объекта с равным полем не теряются (план 2.0, 7.1 №4)
+            const cond = whereOf([after('v', (c) => {
+                    const rev = cursorRev(c);
+                    return rev === undefined ? [] : [{ col: 'v.rev', val: rev, cast: '::int' }];
+                })]);
             text = mods.follow
-                ? `${withClause}select to_jsonb(v) as row from (select ${colsOf('l')}, null::int as depth from ${S}.log l `
-                    + `where l.id in (select f.id from f)) v order by ${order}${limitOffset()}`
+                ? `${withClause}select to_jsonb(v) as row from (select ${colsOf('l')}, null::int as depth from (select distinct f.id, f.lo, f.hi from f) s `
+                    + `cross join lateral (select ${colsOf('l')} from ${S}.log l where l.id = s.id and l.rev > s.lo and l.rev <= coalesce(s.hi, 2147483647)) l) v`
+                    + `${cond} order by ${order}${limitOffset()}`
                 : `${withClause}select to_jsonb(v) as row from (select ${colsOf('l')}, null::int as depth from ${S}.log l `
-                    + `where l.id in (select z.id from ${ents} z)) v order by ${order}${limitOffset()}`;
+                    + `where l.id in (select z.id from ${ents} z)) v${cond} order by ${order}${limitOffset()}`;
             break;
         }
         case 'diff':
@@ -728,12 +811,14 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
             }
             else {
                 const cast = agg.fn === 'sum' || agg.fn === 'avg' ? '::numeric' : CAST[aggLeaf];
-                text = `${withClause}select ${agg.fn}((${acc})${cast}) as v from ${ents} z`;
+                // у boolean в PostgreSQL нет min и max; false меньше true: наименьшее — «все ли true», наибольшее — «есть ли true»
+                const fn = aggLeaf === 'boolean' && agg.fn === 'min' ? 'bool_and' : aggLeaf === 'boolean' && agg.fn === 'max' ? 'bool_or' : agg.fn;
+                text = `${withClause}select ${fn}((${acc})${cast}) as v from ${ents} z`;
             }
             break;
         }
     }
-    return { text: text.replaceAll('@S@', S), params: p.list, keys: keyed.map((k) => k.key), aggLeaf };
+    return { text: text.replaceAll(SCHEMA_MARK, S), params: p.list, keys: pathKeys, aggLeaf };
 }
 /** Строка из to_jsonb(узла): служебные поля в $deleted / $depth, пустые необязательные — без ключа. */
 export function toRow(raw) {

package/dist/sync.js

@@ -77,8 +77,12 @@ export function schemaToTs(s, indent = '') {
         return JSON.stringify(s.const);
     if (Array.isArray(s.enum))
         return s.enum.map((v) => JSON.stringify(v)).join(' | ');
-    if (Array.isArray(s.anyOf) || Array.isArray(s.oneOf))
-        return (s.anyOf ?? s.oneOf).map((b) => schemaToTs(b, indent)).join(' | ');
+    const branches = (s.anyOf ?? s.oneOf);
+    // ветки из одних required у объекта с полями — условие, а не форма: тип — сам объект (план 2.0, 7.5 №1)
+    const onlyRequired = Array.isArray(branches) && s.properties !== undefined
+        && branches.every((b) => Object.keys(b).every((k) => k === 'required'));
+    if (Array.isArray(branches) && !onlyRequired)
+        return branches.map((b) => schemaToTs(b, indent)).join(' | ');
     const types = Array.isArray(s.type) ? s.type : [s.type];
     return types.map((t) => {
         switch (t) {
@@ -110,12 +114,15 @@ export function generateTypes(registry, opts = {}) {
     for (const c of registry.all().sort((a, b) => a.name.localeCompare(b.name))) {
         if (!opts.includeSystem && c.tenant === '2eba6d0a-1edd-4bb6-a85a-a703dab49035')
             continue;
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(c.name))
+        // идентификатор TypeScript — буквы Unicode, цифры, _ и $: кириллические имена классов допустимы (план 2.0, 7.5 №1)
+        if (!/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(c.name))
             throw new LetopisError('invalid_class', `types: имя класса ${c.name} не годится для идентификатора TypeScript`);
         // additionalProperties: false верхнего уровня в тип не переносится — лишние ключи и так ошибка типов
         const { additionalProperties: _closed, ...open } = c.schema;
         void _closed;
-        out.push(`export interface ${c.name}Data ${schemaToTs(open)}`);
+        // объектный литерал — интерфейс; класс без полей, union и открытая схема — псевдоним типа (иначе неверный TypeScript)
+        const data = schemaToTs(open);
+        out.push(/^\{[\s\S]*\}$/.test(data) && !/\}\s*&/.test(data) ? `export interface ${c.name}Data ${data}` : `export type ${c.name}Data = ${data};`);
         const ends = Object.entries(c.ends).map(([role, e]) => `  ${JSON.stringify(role)}${e.required || (e.min ?? 0) > 0 ? '' : '?'}: ${e.many ? 'string[]' : 'string'};`);
         out.push(`export interface ${c.name}Links {${ends.length ? `\n${ends.join('\n')}\n` : ''}}`, '');
     }