letopis 1.4.0 → 1.4.2

package/dist/validate.js

@@ -136,7 +136,16 @@ function compileNode(s, sel, path, inAny, out) {
     if (sch.multipleOf !== undefined)
         out.push({ path, keyword: 'multipleOf', select: sel, test: num((v, b) => isMultiple(v, b), sch.multipleOf) });
     if (sch.pattern !== undefined) {
-        const re = new RegExp(translatePattern(sch.pattern));
+        const src = translatePattern(sch.pattern); // то, чего база не понимает, — своя ошибка invalid_class
+        let re;
+        try {
+            re = new RegExp(src);
+        }
+        catch {
+            // шаблон, неверный уже для JavaScript (незакрытая скобка и т. п.): translatePattern его пропускает, RegExp — нет.
+            // Текст V8 в сообщение не идёт: он зависит от версии движка
+            fail(path, `pattern ${JSON.stringify(sch.pattern)} — неверное регулярное выражение`);
+        }
         out.push({ path, keyword: 'pattern', select: sel, test: (v) => typeof v !== 'string' || re.test(v) });
     }
     if (sch.format !== undefined) {
@@ -211,7 +220,10 @@ function compileNode(s, sel, path, inAny, out) {
                 : (v) => branches.filter((b) => b(v)).length === 1 });
     }
 }
-/** Компилирует JSON Schema (разворот resolved.schema класса) в функцию проверки. */
+/**
+ * Превращает JSON Schema данных класса в функцию проверки — ту же проверку, что выполняет база при записи. Схема
+ * класса — `db.registry.resolve(имя).schema`.
+ */
 export function compileValidator(schema) {
     const rules = [];
     compileNode(schema, (root) => [root], [], false, rules);
@@ -233,7 +245,11 @@ export function compileValidator(schema) {
         return issues;
     };
 }
-/** Умолчания, как apply_defaults в базе: на каждом уровне, во вложенные объекты — только если они есть. */
+/**
+ * Подставляет в данные значения по умолчанию (`default`) из JSON Schema класса, как база перед проверкой при каждой
+ * записи: только в отсутствующие поля, а во вложенный объект — только если он в данных уже есть. Исходные данные не
+ * меняются.
+ */
 export function applyDefaults(schema, data) {
     if (!isObj(data) || !isObj(schema.properties))
         return data;

package/dist/watch.d.ts

@@ -2,13 +2,17 @@ import type { Executor } from './tx.js';
 import type { Row } from './types.js';
 import type { Signal } from './signals.js';
 export interface WatchOptions {
-    /** Откуда: курсор события, 'now' (по умолчанию — изменения после подписки) или 'start' (весь журнал). */
+    /** Откуда: курсор (sub.cursor или курсор события), 'now' (по умолчанию — изменения после подписки) или 'start' (весь журнал). */
     from?: string;
     /** Только эти классы (с потомками). */
     classes?: string[];
     /** Событий за запрос (по умолчанию 500). */
     batch?: number;
-    /** Запасной опрос, мс (по умолчанию 1000; без LISTEN — единственный способ узнать о событиях). */
+    /**
+     * Как часто подписка сама проверяет журнал, мс (по умолчанию 1000): так она находит события, даже если сигнал базы не
+     * пришёл. Без сигналов (`connect({ listen: false })` или установка с `up({ signals: 'none' })`) новые события она
+     * узнаёт только так.
+     */
     pollMs?: number;
 }
 export interface WatchEvent {
@@ -27,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 —
@@ -43,9 +51,19 @@ export declare class Subscription implements AsyncIterable<WatchEvent> {
     private opts;
     private pos;
     private buf;
+    /** Курсор после последнего выданного события, пока в буфере есть невыданные (pos — уже после всей пачки). */
+    private given;
     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;
@@ -56,11 +74,17 @@ export declare class Subscription implements AsyncIterable<WatchEvent> {
     /** Вызовы next() — по очереди: параллельные получают разные события (доработки после точки Б). */
     private queue;
     constructor(ctx: WatchCtx, opts: WatchOptions);
-    /** Курсор последнего выданного события (или начальной точки). */
+    /**
+     * Курсор подписки: позиция после последнего выданного события (или начальная точка). Догнав журнал, подписка обновляет
+     * в нём время и на пустых опросах, поэтому его, а не курсор события, сохраняют, чтобы продолжить после перезапуска:
+     * курсор события хранит время события, и когда оно выйдет за ярус all политики хранения, продолжение с него —
+     * cursor_expired.
+     */
     get cursor(): string | null;
     /**
-     * Начальная точка взята (доработки после точки Б): у from: 'now' — горизонт и снимок момента подписки (watch_head());
-     * у 'start' и курсора — сразу. Запись после await sub.ready() придёт в поток; ошибка начальной точки — отказ.
+     * Промис выполняется, когда подписка запомнила начальную точку: запись, сделанная после этого, придёт в поток
+     * (доработки после точки Б). У `from: 'now'` точку запоминает отдельный запрос к базе, у `'start'` и курсора промис
+     * выполняется сразу; если запрос не удался, промис отклоняется с его ошибкой.
      */
     ready(): Promise<void>;
     private head;

package/dist/watch.js

@@ -13,7 +13,9 @@
  * без LISTEN и на случай потери сигнала — запасной опрос.
  *
  * Курсор подписчика старше яруса all политики хранения его классов — cursor_expired: события могли
- * проредиться, нужно перечитать текущее состояние и подписаться заново.
+ * проредиться, нужно перечитать текущее состояние и подписаться заново. Время курсора подписки — время последнего
+ * события, а догнавшей журнал подписки — время опроса (не позже самой старой ещё не отданной записи): подписка без
+ * событий не стареет. Курсор события хранит время события.
  */
 import { LetopisError } from './errors.js';
 import { toRow } from './sql.js';
@@ -54,9 +56,19 @@ export class Subscription {
     opts;
     pos = null;
     buf = [];
+    /** Курсор после последнего выданного события, пока в буфере есть невыданные (pos — уже после всей пачки). */
+    given = null;
     closed = false;
     wake = null;
     dirty = true;
+    /** Пришёл сигнал: пустой ответ — ещё не горизонт, нужны короткие повторы. Таймер их не запускает (план 2.0, 7.4 №1). */
+    burst = false;
+    /**
+     * from: 'start' — пока подписка не догнала журнал, свои чтения она шлёт без времени курсора: весь журнал, без
+     * cursor_expired на старых событиях (план 2.0, 7.4 №3). Курсоры событий и sub.cursor время хранят: продолжение с них
+     * после прореживания — cursor_expired, как обещано.
+     */
+    catchingUp = false;
     off = null;
     timer = null;
     failure = null;
@@ -72,8 +84,10 @@ export class Subscription {
         this.batch = opts.batch ?? 500;
         this.pollMs = opts.pollMs ?? 1000;
         const from = opts.from ?? 'now';
-        if (from === 'start')
+        if (from === 'start') {
             this.pos = { tx: '0', seq: '0', at: null };
+            this.catchingUp = true;
+        }
         else if (from !== 'now')
             this.pos = decode(from);
         else {
@@ -81,11 +95,12 @@ export class Subscription {
             this.start.catch(() => { });
         }
         if (ctx.onSignal) {
-            const watched = ctx.classes ? new Set(ctx.classes) : null;
             this.off = ctx.onSignal((s) => {
-                if (!wakes(s, watched, ctx.tenant?.() ?? null))
+                const cls = ctx.classesOf?.() ?? ctx.classes;
+                if (!wakes(s, cls ? new Set(cls) : null, ctx.tenant?.() ?? null))
                     return;
                 this.dirty = true;
+                this.burst = true;
                 this.wake?.();
             });
         }
@@ -95,13 +110,21 @@ export class Subscription {
         }, this.pollMs);
         this.timer.unref?.();
     }
-    /** Курсор последнего выданного события (или начальной точки). */
+    /**
+     * Курсор подписки: позиция после последнего выданного события (или начальная точка). Догнав журнал, подписка обновляет
+     * в нём время и на пустых опросах, поэтому его, а не курсор события, сохраняют, чтобы продолжить после перезапуска:
+     * курсор события хранит время события, и когда оно выйдет за ярус all политики хранения, продолжение с него —
+     * cursor_expired.
+     */
     get cursor() {
+        if (this.buf.length)
+            return this.given;
         return this.pos ? encode(this.pos) : null;
     }
     /**
-     * Начальная точка взята (доработки после точки Б): у from: 'now' — горизонт и снимок момента подписки (watch_head());
-     * у 'start' и курсора — сразу. Запись после await sub.ready() придёт в поток; ошибка начальной точки — отказ.
+     * Промис выполняется, когда подписка запомнила начальную точку: запись, сделанная после этого, придёт в поток
+     * (доработки после точки Б). У `from: 'now'` точку запоминает отдельный запрос к базе, у `'start'` и курсора промис
+     * выполняется сразу; если запрос не удался, промис отклоняется с его ошибкой.
      */
     async ready() {
         if (!this.pos && this.start)
@@ -122,18 +145,28 @@ export class Subscription {
         // уход строки из классов подписки сменой класса без смены id (хвост ревью безопасности №3) — надгробием прежней
         // версии в том же окне: полная пачка watch_read ограничивает окно своей последней строкой. Оба потока — одним
         // оператором: общий снимок и горизонт, иначе курсор перескочил бы событие, зафиксированное между запросами
-        // (автоматическое ревью). Потоки сливаются по (tx, seq) до границы — последней строки потока, обрезанного лимитом
+        // (автоматическое ревью). Потоки сливаются по (tx, seq) до границы — последней строки потока, обрезанного лимитом.
+        // Третья строка (src 2) — время курсора, когда пачка неполная (подписка догнала журнал): «сейчас», но не позже самой
+        // старой записи подписки, которая уже зафиксирована, а горизонт ещё не прошла (её держит более старая транзакция;
+        // снимок «now» — без записей, которые подписка не отдаёт). Тот же снимок, что у watch_read
         const S = this.ctx.S;
         const both = await this.ctx.exec.run((q) => q.unsafe(`with r as (select l.* from ${S}.watch_read($1::text::xid8, $2::bigint, $3::text::timestamptz, $4::text[], $5::int, $6::text::pg_snapshot) l),
             u as (select r.tx, r.seq from r where (select count(*) from r) = $5 order by r.tx desc, r.seq desc limit 1)
        select 0 as src, ${cols} from r l
        union all
        select 1 as src, ${cols} from ${S}.watch_leaving($1::text::xid8, $2::bigint, $4::text[], $5::int, $6::text::pg_snapshot,
-         (select tx from u), (select seq from u)) l`, [p.tx, p.seq, p.at, this.ctx.classes, this.batch, p.snap ?? null]), { read: true });
+         (select tx from u), (select seq from u)) l
+       union all
+       select 2 as src, null, null, jsonb_build_object('at', least(statement_timestamp(), min(l.at))) from ${S}.log l
+       where (select count(*) from r) < $5 and (l.tx, l.seq) > ($1::text::xid8, $2::bigint)
+         and l.tx >= pg_snapshot_xmin(pg_current_snapshot()) and ($4::text[] is null or l.class = any ($4::text[]))
+         and ($6::text::pg_snapshot is null or not pg_visible_in_snapshot(l.tx, $6::text::pg_snapshot))
+       having (select count(*) from r) < $5`, [p.tx, p.seq, this.catchingUp ? null : p.at, this.ctx.classesOf?.() ?? this.ctx.classes, this.batch, p.snap ?? null]), { read: true });
         const before = (a, b) => BigInt(a.tx) < BigInt(b.tx) || (a.tx === b.tx && BigInt(a.seq) < BigInt(b.seq));
         const order = (a, b) => (before(a, b) ? -1 : before(b, a) ? 1 : 0);
         const read = both.filter((r) => r.src === 0).sort(order);
         const away = both.filter((r) => r.src === 1).sort(order);
+        const caught = both.find((r) => r.src === 2);
         let rows = read;
         {
             const upto = read.length === this.batch ? read[read.length - 1] : null;
@@ -145,12 +178,21 @@ export class Subscription {
                 rows = [...read, ...away].sort(order).filter((r) => !bound || !before(bound, r));
             }
         }
+        // пока события пачки не выданы, курсор подписки — позиция до пачки
+        if (rows.length)
+            this.given = encode(p);
         for (const r of rows) {
             const row = toRow(r.row);
             const snap = keepSnap(p.snap, r.tx);
             this.pos = { tx: r.tx, seq: r.seq, at: row.at, ...(snap ? { snap } : {}) };
             this.buf.push({ cursor: encode(this.pos), row, id: row.id, class: row.class, op: row.op, rev: row.rev, at: row.at });
         }
+        // догнала журнал — время курсора подписки (sub.cursor) обновляется и на пустых опросах: прореживать после него нечего,
+        // и подписка, к которой долго не было событий, не получает ложный cursor_expired. Курсоры событий хранят время события
+        if (caught && away.length < this.batch) {
+            this.pos = { ...(this.pos ?? p), at: String(caught.row.at) };
+            this.catchingUp = false;
+        }
         return rows.length;
     }
     /**
@@ -167,8 +209,11 @@ export class Subscription {
         for (;;) {
             if (this.failure)
                 throw this.failure;
-            if (this.buf.length)
-                return { value: this.buf.shift(), done: false };
+            if (this.buf.length) {
+                const ev = this.buf.shift();
+                this.given = ev.cursor;
+                return { value: ev, done: false };
+            }
             if (this.closed)
                 return { value: undefined, done: true };
             if (this.dirty) {
@@ -184,12 +229,15 @@ export class Subscription {
                     this.close();
                     throw e;
                 }
-                // сигнал был, а событий ниже горизонта ещё нет: короткие повторы, затем — запасной опрос
-                if (++empty < 40) {
+                // сигнал был, а событий ниже горизонта ещё нет: короткие повторы, затем — запасной опрос. Опрос по таймеру —
+                // один запрос: серия повторов на каждый тик давала около 4 запросов в секунду на молчащую подписку (план 2.0,
+                // 7.4 №1)
+                if (this.burst && ++empty < 40) {
                     await sleep(Math.min(25 * empty, 250));
                     continue;
                 }
                 this.dirty = false;
+                this.burst = false;
                 empty = 0;
             }
             await new Promise((r) => {
@@ -216,6 +264,7 @@ export class Subscription {
             return;
         this.closed = true;
         this.off?.();
+        this.ctx.onClose?.(this);
         if (this.timer)
             clearInterval(this.timer);
         this.wake?.();

package/dist/write.d.ts

@@ -10,8 +10,9 @@ export interface IncMarker {
     readonly start?: number;
 }
 /**
- * Приращение в update: `update({ balance: inc(-300) })` — величина прибавляется в базе, внутри
- * оператора, над свежей строкой (функция inc). Поля нет — ошибка; `{ start }` — начать с него.
+ * Приращение числового поля в `update()`: `db.Wallet(w).update({ balance: inc(-300) })`. Сложение делает база над
+ * текущим значением поля в момент записи, поэтому одновременные приращения не теряются. Если поля ещё нет, `{ start }`
+ * задаёт, с чего начать (поле получит `start + by`), а без него — ошибка `invalid_data`.
  */
 export declare function inc(by: number, opts?: {
     start?: number;

package/dist/write.js

@@ -29,8 +29,9 @@ import { applyDefaults } from './validate.js';
 /** Метка приращения; Symbol.for — маркер узнаёт и вторая копия пакета в процессе. */
 export const INC = Symbol.for('letopis.inc');
 /**
- * Приращение в update: `update({ balance: inc(-300) })` — величина прибавляется в базе, внутри
- * оператора, над свежей строкой (функция inc). Поля нет — ошибка; `{ start }` — начать с него.
+ * Приращение числового поля в `update()`: `db.Wallet(w).update({ balance: inc(-300) })`. Сложение делает база над
+ * текущим значением поля в момент записи, поэтому одновременные приращения не теряются. Если поля ещё нет, `{ start }`
+ * задаёт, с чего начать (поле получит `start + by`), а без него — ошибка `invalid_data`.
  */
 export function inc(by, opts = {}) {
     return Object.freeze({ [INC]: true, by, ...(opts.start !== undefined ? { start: opts.start } : {}) });
@@ -184,6 +185,9 @@ export function precheckPlan(reg, steps) {
                 if (!Array.isArray(op.fields) || !op.fields.length)
                     fail('invalid_query', 'anonymize(поля): нужен список полей');
                 for (const f of op.fields) {
+                    // поля нет в классе — так и сказано, а не «поле jsonb» (план 2.0, 7.5 №3)
+                    if (!(f in (s.cls.schema.properties ?? {})))
+                        fail('invalid_query', `anonymize(): поля ${f} нет в классе ${s.cls.name}`);
                     const t = reg.leafType(s.cls.name, [f]);
                     if (t !== 'text')
                         fail('invalid_query', `anonymize() затирает только строковые поля; ${f} — ${t}`);
@@ -342,9 +346,17 @@ async function slotIds(w, v) {
     if (Array.isArray(v))
         return v;
     if ('plan' in v) {
-        const rows = v.plan.some((s) => s.op)
-            ? (await execPlan(w, v.plan, v.mods, 'rows')).rows
-            : await readRows(w, v.plan, v.mods);
+        let rows;
+        if (v.plan.some((s) => s.op)) {
+            // вложенный план — те же проверки до базы, что у плана терминала; с читающим хвостом после глагола execPlan
+            // отдаёт строки чтения (план 2.0, 7.2 №3: раньше — TypeError)
+            precheckPlan(w.reg, v.plan);
+            const r = await execPlan(w, v.plan, v.mods, 'rows');
+            rows = r.kind === 'rows' ? r.rows : r.res;
+        }
+        else {
+            rows = await readRows(w, v.plan, v.mods);
+        }
         return rows.map((r) => r.id);
     }
     return [v.id];
@@ -377,7 +389,11 @@ function applySlotsLocal(links, ops) {
     }
     return out;
 }
-const tagsValue = (s) => s.tagsFilter === undefined ? null : typeof s.tagsFilter === 'string' ? [s.tagsFilter] : s.tagsFilter;
+/**
+ * Теги, которые пишет глагол: строка или список из `.tags(…)` (перед update они же и отбирают цели). Оператор
+ * (has, hasAny, hasAll) только отбирает — теги целей не меняются; create и upsert его не принимают (precheck).
+ */
+const tagsValue = (s) => typeof s.tagsFilter === 'string' ? [s.tagsFilter] : Array.isArray(s.tagsFilter) ? s.tagsFilter : null;
 /** «Уже существует»: id вычисляет библиотека (idOf), а не разбирает текст ошибки сервера (§2.5). */
 function existsError(w, cls, data, links, given, cause) {
     let id = given;
@@ -440,12 +456,23 @@ async function explainMissing(w, missing, rev) {
     }
     return fail('acl_denied', `строки видны, но изменить их нельзя: ${seen.map((r) => r.id).join(', ')}`, { ids: seen.map((r) => r.id) });
 }
+/**
+ * Строки ответа глагола — в порядке целей (`targetIds`: по `sort()` до глагола, иначе по id). `update … returning`
+ * отдаёт их в порядке обхода таблицы, и `first()` после глагола брал бы случайную из исправленных строк.
+ */
+function inTargetOrder(ids, rows) {
+    const pos = new Map(ids.map((id, i) => [id, i]));
+    return rows.sort((a, b) => (pos.get(a.id) ?? 0) - (pos.get(b.id) ?? 0));
+}
 /** Цели update/delete/anonymize/reclass: id из пути (limit и sort сужают); data.id — если у шага нет фильтра. */
 async function targetIds(w, steps, opStep, dataId) {
     const path = steps.map(bare);
     if (opStep.filter === undefined && dataId !== undefined)
         path[path.length - 1] = { ...path[path.length - 1], filter: dataId };
-    return readIds(w, path, opStep.opMods ?? {});
+    const ids = await readIds(w, path, opStep.opMods ?? {});
+    // без явного порядка — по id: глаголы по списку целей (reclass, rekey и др.) пишут журнал по очереди, и порядок
+    // записей не должен зависеть от плана чтения
+    return opStep.opMods?.order ? ids : [...ids].sort();
 }
 async function updateOp(w, steps, opStep) {
     const op = opStep.op;
@@ -456,7 +483,7 @@ async function updateOp(w, steps, opStep) {
     const ids = await targetIds(w, steps, opStep, useDataId ? dataId : undefined);
     if (op.rev !== undefined) {
         if (ids.length > 1)
-            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — строгий режим только для одной`);
+            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — проверить версию { rev } можно только у одной цели`);
         if (!ids.length)
             fail('target_not_found', `update(patch, { rev }): у шага ${opStep.name} нет цели`);
     }
@@ -481,7 +508,7 @@ async function updateOp(w, steps, opStep) {
         const got = new Set(res.map((r) => r.row.id));
         await explainMissing(w, ids.filter((x) => !got.has(x)), op.rev);
     }
-    return res.map((r) => toRow(r.row));
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 async function deleteOp(w, steps, opStep) {
     const op = opStep.op;
@@ -510,9 +537,11 @@ async function deleteOp(w, steps, opStep) {
     }
     const tombs = await query(w, `select ${rowJson('l')} as row from ${S}.log l where l.tx = pg_current_xact_id() and l.seq > $1::bigint and l.op = 'delete' order by l.seq`, [mark]);
     const out = tombs.map((r) => toRow(r.row));
-    // строки классов без журнала (history: false) надгробий не оставляют — берём их из returning
+    // строки классов без журнала (history: false) надгробий не оставляют — берём их из returning, по id (порядок
+    // returning зависит от плана, а итог delete() — нет: надгробия идут по seq, триггер пишет их в порядке id)
     const have = new Set(out.map((r) => r.id));
-    for (const g of gone) {
+    const byId = (a, b) => String(a.row.id) < String(b.row.id) ? -1 : String(a.row.id) > String(b.row.id) ? 1 : 0;
+    for (const g of [...gone].sort(byId)) {
         if (have.has(g.row.id))
             continue;
         const row = toRow(g.row);
@@ -534,7 +563,7 @@ async function anonymizeOp(w, steps, opStep) {
         const got = new Set(res.map((r) => r.row.id));
         await explainMissing(w, ids.filter((x) => !got.has(x)));
     }
-    return res.map((r) => toRow(r.row));
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 async function reclassOp(w, steps, opStep) {
     const op = opStep.op;
@@ -546,7 +575,8 @@ async function reclassOp(w, steps, opStep) {
     // у класса без ключа id сохраняется, у класса с ключом — новый id и перевод ссылок (reclass() в базе)
     const moved = await query(w, `select ${S}.reclass(x, $2::text, $3::jsonb) as id from unnest($1::uuid[]) with ordinality as u(x, i) order by u.i`, [ids, cls, op.data ?? null]);
     const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [moved.map((m) => m.id)]);
-    return res.map((r) => toRow(r.row));
+    // строки ответа — в порядке целей (moved — по порядку целей, план 2.0, 7.2 №2)
+    return inTargetOrder(moved.map((m) => m.id), res.map((r) => toRow(r.row)));
 }
 /** Удалённые объекты шага (restore, purge): живые цели без удалённых — not_deleted. */
 async function deletedTargets(w, steps, opStep, verb) {
@@ -554,7 +584,8 @@ async function deletedTargets(w, steps, opStep, verb) {
     const dead = rows.filter((r) => r.$deleted);
     if (!dead.length && rows.length)
         fail('not_deleted', `объект не удалён: ${verb}() — только для удалённых${verb === 'purge' ? ', сначала delete()' : ''}`, { ids: rows.map((r) => r.id) });
-    return dead;
+    // без явного порядка — по id: restore и purge пишут журнал по очереди целей
+    return opStep.opMods?.order ? dead : [...dead].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
 }
 /** Восстановление (этап 6, п. 2): последний снимок новой версией; база перепроверяет его по текущему описанию. */
 async function restoreOp(w, steps, opStep) {
@@ -564,8 +595,8 @@ async function restoreOp(w, steps, opStep) {
         return [];
     const ids = dead.map((r) => r.id);
     await query(w, `select ${S}.restore(x) from unnest($1::uuid[]) with ordinality as u(x, i) order by u.i`, [ids]);
-    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[]) order by e.id`, [ids]);
-    return res.map((r) => toRow(r.row));
+    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [ids]);
+    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
 /**
  * Стирание истории удалённых (этап 6, п. 3): без { confirm: true } — превью (надгробия и число
@@ -610,8 +641,8 @@ async function rekeyOp(w, steps, opStep) {
             throw e;
         }
     }
-    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[]) order by e.id`, [moved]);
-    return res.map((r) => toRow(r.row));
+    const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [moved]);
+    return inTargetOrder(moved, res.map((r) => toRow(r.row)));
 }
 async function opCall(w, steps, opStep) {
     await useReason(w, reasonFor(w, opStep));
@@ -752,7 +783,9 @@ export async function execBatch(w, plans) {
                 && reasonFor(w, plans[j][0]) === why) {
                 const s = plans[j][0];
                 const id = idFor(s);
-                if (!id || (verb === 'upsert' && seen.has(id)))
+                // повтор id режет группу и у create: иначе вторая строка «находила» строку первой, и батч проходил молча
+                // (план 2.0, 7.2 №1); повтор уходит следующим оператором и получает exists
+                if (!id || seen.has(id))
                     break;
                 seen.add(id);
                 group.push({ at: j, s, id });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letopis",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Letopis (летопись): versioned entity store on PostgreSQL 18 — integrity, history, tenants and access control enforced by the database itself, dot-notation chains on top",
   "keywords": [
     "postgres",
@@ -68,16 +68,19 @@
     "seed:booking": "tsx scripts/gen-seed-booking.mjs",
     "test:import-salon": "tsx bench/import-salon.mjs",
     "api:contract": "node scripts/gen-api-contract.mjs",
-    "prepublishOnly": "npm run typecheck && npm run check:docs && npm run build"
+    "prepublishOnly": "npm run typecheck && npm run check:docs && npm run build",
+    "check:semver": "node scripts/check-semver.mjs",
+    "prerelease": "node scripts/prerelease.mjs",
+    "soak": "tsx bench/soak.mjs"
   },
   "dependencies": {
     "postgres": "^3.4.9"
   },
   "peerDependencies": {
-    "zod": "^4",
     "@electric-sql/pglite": "^0.5.8",
     "@electric-sql/pglite-socket": "^0.2.11",
-    "@modelcontextprotocol/server": "^2.4.0"
+    "@modelcontextprotocol/server": "^2.4.0",
+    "zod": "^4"
   },
   "peerDependenciesMeta": {
     "zod": {
@@ -102,6 +105,7 @@
     "letopis-0": "npm:letopis@0.21.0",
     "letopis-1": "npm:letopis@1.0.1",
     "letopis-11": "npm:letopis@1.1.0",
+    "letopis-141": "npm:letopis@1.4.1",
     "tsx": "^4.23.15",
     "typescript": "~5.9.3",
     "zod": "4.6.5"

package/sql/10-core.sql

@@ -107,9 +107,12 @@ create index if not exists log_ends on @SCHEMA@.log using gin (@SCHEMA@.link_ids
 -- журнал часто прореживается (§2.11): чаще чистим
 alter table @SCHEMA@.log set (autovacuum_vacuum_scale_factor = 0.02, autovacuum_analyze_scale_factor = 0.02);
 
+-- account — строка entity (аккаунт; у служебных строк KEY, LOCK, PROJECTOR — System): удалённый аккаунт уносит свои строки
+-- каскадом внешнего ключа — сессии, хэши паролей и ключей, секреты TOTP, внешние учётные записи (ревизия 7; в схему
+-- прежней ревизии ключ добавляет миграция 0007). Строка Account у System не удаляется (trg_entity_bd_account, 60-write.sql)
 create table if not exists @SCHEMA@.secret (
   id          uuid primary key default gen_random_uuid(),
-  account     uuid not null,
+  account     uuid not null constraint secret_account_fkey references @SCHEMA@.entity (id) on delete cascade,
   kind        text not null,       -- PASSWORD, APIKEY, KEYSECRET, OTP, TOTP, IDENTITY, SESSION
   ident       text,                -- email, телефон, префикс ключа, внешний id
   material    bytea,               -- хэш пароля, ключа, кода или токена; секрет TOTP
@@ -121,6 +124,8 @@ create table if not exists @SCHEMA@.secret (
 create unique index if not exists secret_kind_ident on @SCHEMA@.secret (kind, casefold(ident) collate pg_unicode_fast)
   where deleted_at is null and ident is not null;
 create index if not exists secret_material on @SCHEMA@.secret (material) where kind = 'SESSION' and deleted_at is null;
+-- строки аккаунта: каскад внешнего ключа при удалении аккаунта и гашение его сессий (auth_kill) — без перебора таблицы
+create index if not exists secret_account on @SCHEMA@.secret (account);
 
 alter table @SCHEMA@.entity owner to @OWNER@;
 alter table @SCHEMA@.log owner to @OWNER@;