letopis 1.4.1 → 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';
@@ -221,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;
@@ -234,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;
@@ -286,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 (;;) {
@@ -390,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]);
@@ -431,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)}`);
@@ -444,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) {
@@ -544,6 +561,7 @@ export class Projector {
         this.scopes = scopes;
         this.tenants = tenants;
         this.stale = false;
+        this.resolvedAt = Date.now();
     }
     /** Одна пачка журнала. */
     async step(rep) {
@@ -552,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')
@@ -560,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]);
@@ -592,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;
@@ -621,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)
@@ -902,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++;
         });
     }
@@ -944,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;
@@ -962,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';
                 }
@@ -1090,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));
@@ -1120,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];
@@ -1177,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))
@@ -1185,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/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;
@@ -63,10 +63,11 @@ export interface Hop {
  */
 export declare function resolveHop(reg: Registry, prev: Step, next: Step): Hop;
 /**
- * Курсор постраничного вывода для `after()`: `{ v, id }` — значение поля сортировки и id последней строки страницы.
- * Поле — то же, что в `sort()`; если его нет в данных строки, `v` — `null`.
+ * Курсор постраничного вывода для `after()`: значение поля сортировки, id и номер версии последней строки страницы.
+ * Поле — то же, что в `sort()`; если его нет в данных строки, `v` — `null`. Для пути из `paths()` — то же по его
+ * последнему узлу (узлу последнего шага) и id всех узлов: курсор отделяет пути с общим последним узлом.
  */
-export declare function cursorOf(row: Row, field: string): Cursor;
+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,25 +422,60 @@ function cursorParams(c, sort) {
     }
     return { v: value, id };
 }
+/** 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()`: `{ v, id }` — значение поля сортировки и id последней строки страницы.
- * Поле — то же, что в `sort()`; если его нет в данных строки, `v` — `null`.
+ * Курсор постраничного вывода для `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',
@@ -526,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)}`;
@@ -652,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;
@@ -686,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':
@@ -703,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':
@@ -741,7 +818,7 @@ export function buildRead(reg, schema, steps, mods, mode, agg, opts = {}) {
             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` : ''}}`, '');
     }

package/dist/tx.d.ts

@@ -31,6 +31,21 @@ export declare function isTransient(e: unknown): boolean;
 export declare function isLogConflict(e: unknown): boolean;
 /** Обрыв связи: сокет закрыт или серверный процесс завершён (FATAL) — исход отправленного неизвестен. */
 export declare function isConnectionError(e: unknown): boolean;
+/**
+ * Откатить транзакцию на зарезервированном соединении после ошибки: после обрыва в него не пишут (postgres.js 3.4
+ * уронил бы процесс необработанным TypeError), иначе — rollback, ошибка которого не важна (план 2.0, 7.4 №7).
+ */
+export declare function rollbackAfter(conn: {
+    unsafe(text: string): Promise<unknown>;
+}, err: unknown): Promise<void>;
+/**
+ * Вернуть зарезервированное соединение в пул. После обрыва сокета пул postgres.js уже перевёл
+ * соединение в закрытые (onclose); release() вернул бы его в открытые, и следующая операция
+ * писала бы в сокет null — необработанный TypeError роняет процесс.
+ */
+export declare function release(conn: {
+    release(): void;
+}, err: unknown): void;
 export declare const RETRIES = 3;
 export declare const retryDelay: (attempt: number) => Promise<void>;
 /** Нотификатор процесса: копит нагрузки сигналов и отправляет их пачкой раз в интервал. */

package/dist/tx.js

@@ -17,12 +17,21 @@ export function isConnectionError(e) {
     const code = String(err?.code ?? '');
     return code.startsWith('CONNECTION_') || ['ECONNRESET', 'EPIPE', 'ECONNREFUSED', 'ETIMEDOUT', 'ECONNABORTED'].includes(code);
 }
+/**
+ * Откатить транзакцию на зарезервированном соединении после ошибки: после обрыва в него не пишут (postgres.js 3.4
+ * уронил бы процесс необработанным TypeError), иначе — rollback, ошибка которого не важна (план 2.0, 7.4 №7).
+ */
+export async function rollbackAfter(conn, err) {
+    if (isConnectionError(err))
+        return;
+    await conn.unsafe('rollback').catch(() => { });
+}
 /**
  * Вернуть зарезервированное соединение в пул. После обрыва сокета пул postgres.js уже перевёл
  * соединение в закрытые (onclose); release() вернул бы его в открытые, и следующая операция
  * писала бы в сокет null — необработанный TypeError роняет процесс.
  */
-function release(conn, err) {
+export function release(conn, err) {
     const e = err;
     if (e && !e.severity && isConnectionError(e))
         return;
@@ -233,8 +242,8 @@ export class ExplicitTx {
                 ctx.passes.set(ctx, (await passSql(conn, ctx))[0]?.p);
         }
         catch (e) {
-            await conn.unsafe('rollback').catch(() => { });
-            conn.release();
+            await rollbackAfter(conn, e);
+            release(conn, e);
             throw fromDbError(e);
         }
         return new ExplicitTx(ctx, conn);

package/dist/types.d.ts

@@ -85,10 +85,17 @@ export type Filter = string | string[] | Op | {
 } | {
     [field: string]: FieldFilter | undefined;
 };
-/** Курсор постраничного вывода для `after()`: значение поля сортировки и id последней строки страницы. */
+/**
+ * Курсор постраничного вывода для `after()`: значение поля сортировки и id последней строки страницы. Равные по полю
+ * строки разводят `rev` (версии в `versions()`) и `path` (id всех узлов пути в `paths()`); `cursorOf` заполняет их сам.
+ */
 export interface Cursor {
     v: string | number | boolean | null;
     id: string;
+    /** Номер версии строки: в `versions()` отделяет версии одного объекта с равным полем сортировки. */
+    rev?: number;
+    /** Узлы пути из `paths()`: ключ узла → id; отделяет пути с общим последним узлом. */
+    path?: Record<string, string>;
 }
 /** Модификаторы выборки цепочки. */
 export interface ChainMods {

package/dist/up.js

@@ -147,6 +147,11 @@ export async function install(sql, opts) {
         // точку сохранения, а не всю транзакцию.
         await tx.savepoint((sp) => sp.unsafe(`grant ${quoteIdent(owner)} to current_user with inherit false, set true`))
             .catch((e) => {
+            // роль владельца создал кто-то другой, а у установщика нет на неё ADMIN — понятная ошибка вместо сырой 42501
+            // (план 2.0, 7.5 №3)
+            if (e.code === '42501') {
+                throw Object.assign(new Error(`letopis.up: роль ${owner} уже есть, а у установщика нет на неё ADMIN OPTION — установку ведёт роль, создавшая ${owner}, или роль с этим правом (grant ${owner} to <установщик> with admin option)`), { cause: e });
+            }
             if (e.code !== '0LP01' && e.code !== '23505')
                 throw e; // уже выдано циклом — нет; 23505 — выдал up() другой базы
         });

package/dist/watch.d.ts

@@ -31,10 +31,14 @@ export interface WatchCtx {
     exec: Executor;
     /** Классы подписки с потомками (null — все). */
     classes: string[] | null;
+    /** Классы с потомками заново — по текущему реестру: потомки, заведённые после watch(), тоже в подписке (план 2.0, 7.4 №2). */
+    classesOf?: () => string[] | null;
     /** Подписка на сигналы базы (разобранные); возвращает отписку. */
     onSignal?: (fn: (s: Signal) => void) => () => void;
     /** Токен арендатора подписки (null — процесс без ключа или режим без токенов). */
     tenant?: () => string | null;
+    /** Подписка закрылась: подключение перестаёт её учитывать (план 2.0, 7.4 №8). */
+    onClose?: (s: Subscription) => void;
 }
 /**
  * Будит ли сигнал подписку: свои классы (watched; null — все) и свой арендатор (mine — токен; null —
@@ -52,6 +56,14 @@ export declare class Subscription implements AsyncIterable<WatchEvent> {
     private closed;
     private wake;
     private dirty;
+    /** Пришёл сигнал: пустой ответ — ещё не горизонт, нужны короткие повторы. Таймер их не запускает (план 2.0, 7.4 №1). */
+    private burst;
+    /**
+     * from: 'start' — пока подписка не догнала журнал, свои чтения она шлёт без времени курсора: весь журнал, без
+     * cursor_expired на старых событиях (план 2.0, 7.4 №3). Курсоры событий и sub.cursor время хранят: продолжение с них
+     * после прореживания — cursor_expired, как обещано.
+     */
+    private catchingUp;
     private off;
     private timer;
     private failure;