letopis 1.4.2 → 3.0.0

package/dist/write.js

@@ -1,7 +1,7 @@
 /**
- * Запись планами (план, §2.5, этап 4, п. 1–7, 10): глаголы create, update, upsert, delete, anonymize
- * и reclass — звенья цепочки; терминал исполняет весь план одной транзакцией. Этап 6: restore и
- * purge — над удалёнными объектами шага, rekey — новое значение ключа (функции базы).
+ * Запись планами (план, §2.5, этап 4, п. 1–7, 10): глаголы create, update, upsert и delete — звенья
+ * цепочки; терминал исполняет весь план одной транзакцией. Этап 6: restore — над удалёнными объектами
+ * шага (функция базы).
  *
  *   await db.Org(org).Staff().create({ name: 'Вася', phone: '+7' }).rows()      // концы из пути: { Org }
  *   await db.Customer(c).booking({ notes: 'x' }).update({ notes: 'y' }).rows()
@@ -17,12 +17,11 @@
  * строка видна, но править нельзя — acl_denied; строки уже нет — target_not_found; номер версии
  * разошёлся со { rev } — conflict.
  */
-import { LetopisError, ValidationError } from './errors.js';
+import { fromDbError, issuesFromDb, lerr, lmsg, LetopisError, ValidationError } from './errors.js';
 import { isOp } from './ops.js';
-import { aggregateFields } from './registry.js';
-import { accepts, buildRead, nextNodeKey, resolveHop, stepClasses, toRow } from './sql.js';
+import { accepts, buildRead, nextNodeKey, precheckStep, resolveHop, stepClasses, toRow } from './sql.js';
 import { idOf } from './uuid.js';
-import { applyDefaults } from './validate.js';
+import { applyDefaults, leavesToDb } from './validate.js';
 // ---------------------------------------------------------------------------
 // Приращение: маркер, которого не получить из JSON (§2.5)
 // ---------------------------------------------------------------------------
@@ -37,26 +36,48 @@ export function inc(by, opts = {}) {
     return Object.freeze({ [INC]: true, by, ...(opts.start !== undefined ? { start: opts.start } : {}) });
 }
 export const isInc = (v) => typeof v === 'object' && v !== null && v[INC] === true;
+/**
+ * Данные create() и upsert() без ключей со значением undefined — как у патча update() (splitPatch): ключ undefined JSON
+ * не передаёт, а валидатор на TypeScript принимал его за поле не того типа (план 2.1, A12). Вложенные объекты — тоже;
+ * массивы, даты, маркеры и операторы — как есть.
+ */
+export function dropUndefined(data) {
+    if (!isPlain(data))
+        return data;
+    const out = {};
+    for (const [k, v] of Object.entries(data)) {
+        if (v === undefined)
+            continue;
+        out[k] = isPlain(v) ? dropUndefined(v) : v;
+    }
+    return out;
+}
+/** expect — список строк { id, rev } (и $action у превью удаления): иначе invalid_query до записи. */
+function checkExpect(expect, verb) {
+    const ok = Array.isArray(expect) && expect.every((x) => x !== null && typeof x === 'object' && typeof x.id === 'string'
+        && Number.isInteger(x.rev) && x.rev >= 1);
+    if (!ok)
+        throw lerr('write.bad_expect', { verb });
+}
 /** Причина изменения: строка до 1000 символов без NUL (её не принимает set_config). */
 export function checkReason(v, where) {
     if (typeof v !== 'string' || v.length > 1000 || v.includes('\0')) {
-        throw new LetopisError('invalid_query', `${where}: reason — строка до 1000 символов`);
+        throw lerr('write.bad_reason', { where });
     }
     return v;
 }
-const fail = (code, msg, detail) => {
-    throw new LetopisError(code, msg, detail);
-};
 const asList = (v) => (Array.isArray(v) ? v : [v]);
-const isPlain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Date) && !isInc(v) && !isOp(v);
+function isPlain(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Date) && !isInc(v) && !isOp(v);
+}
 /** Патч update → остаток для merge и список приращений. Недопустимое — invalid_data до отправки. */
 export function splitPatch(patch) {
     const incs = [];
     const noMarkers = (v, path) => {
         if (isInc(v))
-            fail('invalid_data', `inc() внутри массива (${path.join('.')}) не поддерживается`);
+            throw lerr('write.inc_in_array', { path: path.join('.') });
         if (isOp(v))
-            fail('invalid_data', `оператор фильтра в данных (${path.join('.')}) — данные записываются значениями`);
+            throw lerr('write.op_in_data', { path: path.join('.') });
         if (Array.isArray(v))
             v.forEach((x, i) => noMarkers(x, [...path, String(i)]));
         else if (isPlain(v))
@@ -71,13 +92,13 @@ export function splitPatch(patch) {
             const p = [...path, k];
             if (isInc(v)) {
                 if (!Number.isFinite(v.by))
-                    fail('invalid_data', `inc(${v.by}) по пути ${p.join('.')}: величина — конечное число`);
+                    throw lerr('write.inc_by_not_finite', { by: v.by, path: p.join('.') });
                 if (v.start !== undefined && !Number.isFinite(v.start))
-                    fail('invalid_data', `inc: start по пути ${p.join('.')} — конечное число`);
+                    throw lerr('write.inc_start_not_finite', { path: p.join('.') });
                 incs.push({ path: p, by: v.by, ...(v.start !== undefined ? { start: v.start } : {}) });
             }
             else if (isOp(v)) {
-                fail('invalid_data', `оператор фильтра в патче (${p.join('.')}) — update записывает значения`);
+                throw lerr('write.op_in_patch', { path: p.join('.') });
             }
             else if (Array.isArray(v)) {
                 noMarkers(v, p);
@@ -101,15 +122,60 @@ export function splitPatch(patch) {
 // ---------------------------------------------------------------------------
 // Проверки до отправки (precheckPlan)
 // ---------------------------------------------------------------------------
-/** Данные create/upsert: объект без маркеров; ранняя проверка валидатором на TypeScript (full — объект целиком). */
-function checkFullData(cls, data, verb, full = true) {
+/**
+ * Нарушения, найденные валидатором на TypeScript у класса с правилами только для базы (`pattern`): полный список даст
+ * база (completeIssues). Ключ — сама ошибка.
+ */
+const PENDING = new WeakMap();
+/**
+ * Ключи данных, которые не поля класса, а его концы (связи): имя роли конца или имя класса на конце (у роли с другим
+ * именем). Пары [ключ, роль] — для текста «задайте .Роль.set(id)» (write.link_in_data, 3.0): подсказка в самом тексте
+ * ошибки, а не только в err.hint.
+ */
+function endsAsFields(cls, data, skip) {
+    const props = (cls.schema.properties ?? {});
+    const out = [];
+    for (const k of Object.keys(data)) {
+        if (data[k] === undefined || k in props || k === skip)
+            continue;
+        if (cls.ends[k] !== undefined) {
+            out.push([k, k]);
+            continue;
+        }
+        const role = Object.entries(cls.ends).find(([, e]) => (Array.isArray(e.class) ? e.class : [e.class]).includes(k))?.[0];
+        if (role !== undefined)
+            out.push([k, role]);
+    }
+    return out;
+}
+/** Ключ и параметры ошибки «конец передан полем данных» (write.link_in_data). */
+function linkInData(cls, verb, found) {
+    return { key: 'write.link_in_data', params: { verb, cls: cls.name, keys: found.map(([k]) => k).join(', '), role: found[0][1] } };
+}
+/**
+ * Патч update() с ключом — именем конца класса, которого нет среди полей: база отклонила бы его (лишний ключ верхнего
+ * уровня) — отказ до записи с подсказкой «конец — из пути или .Роль.set()» (план 2.1, A8). data.id цели — не данные.
+ */
+function checkPatchEnds(s, patch) {
+    const cls = s.cls;
+    if (cls.name === 'Class' || cls.abstract || cls.schema.additionalProperties !== false)
+        return;
+    const useDataId = s.filter === undefined && typeof patch.id === 'string';
+    const found = endsAsFields(cls, patch, useDataId ? 'id' : undefined);
+    if (!found.length)
+        return;
+    const issue = { path: [], keyword: 'additionalProperties', message: lmsg('model.issue_additional', { keys: found.map(([k]) => k).join(', ') }) };
+    throw new ValidationError(cls.name, [issue], linkInData(cls, 'update', found));
+}
+/** Данные create/upsert: объект без маркеров; ранняя проверка валидатором на TypeScript. */
+function checkFullData(cls, data, verb) {
     if (!isPlain(data))
-        fail('invalid_data', `${verb}(): данные — объект`);
+        throw lerr('write.data_not_object', { verb });
     const scan = (v, path) => {
         if (isInc(v))
-            fail('invalid_data', `inc() работает только в update(): ${verb}() по пути ${path.join('.')}`);
+            throw lerr('write.inc_outside_update', { verb, path: path.join('.') });
         if (isOp(v))
-            fail('invalid_data', `оператор фильтра в данных ${verb}() (${path.join('.')}) — данные записываются значениями`);
+            throw lerr('write.op_in_verb_data', { verb, path: path.join('.') });
         if (Array.isArray(v))
             v.forEach((x, i) => scan(x, [...path, String(i)]));
         else if (isPlain(v))
@@ -117,33 +183,100 @@ function checkFullData(cls, data, verb, full = true) {
                 scan(x, [...path, k]);
     };
     scan(data, []);
-    // агрегатные поля считает база (план 1.1, §2.4): переданное значение — aggregate_field до отправки, а для ранней
-    // проверки поле — 0, как его поставит база
-    const obj = data;
-    const agg = aggregateFields(cls);
-    const given = agg.filter((f) => f in obj);
-    if (given.length)
-        fail('aggregate_field', `поля ${given.join(', ')} класса ${cls.name} считает база (aggregate) — их не передают`);
     // описания системных классов проверяет только база (метасхема Class, class_admit)
-    if (!full || cls.name === 'Class' || cls.abstract)
+    if (cls.name === 'Class' || cls.abstract)
         return;
-    const issues = cls.validator()(applyDefaults(cls.schema, agg.length ? { ...obj, ...Object.fromEntries(agg.map((f) => [f, 0])) } : obj));
-    if (issues.length)
-        throw new ValidationError(cls.name, issues);
-}
-/** Патч update не трогает агрегатные поля класса шага (план 1.1, §2.4): их считает база. */
-function checkAggregatePatch(cls, patch) {
-    const given = aggregateFields(cls).filter((f) => f in patch);
-    if (given.length)
-        fail('aggregate_field', `поля ${given.join(', ')} класса ${cls.name} считает база (aggregate) — update их не меняет`);
-}
-/** Всё, что проверяется без базы, — до отправки первого оператора (§2.5). */
-export function precheckPlan(reg, steps) {
+    const v = cls.validator();
+    const full = applyDefaults(cls.schema, data);
+    const issues = v(full);
+    if (!issues.length)
+        return;
+    const found = endsAsFields(cls, data);
+    const e = new ValidationError(cls.name, issues, found.length ? linkInData(cls, verb, found) : undefined);
+    if (leavesToDb(v))
+        PENDING.set(e, { cls: cls.name, data: full });
+    throw e;
+}
+/**
+ * Ошибка данных до записи у класса с правилами только для базы (`pattern`): валидатор на TypeScript нашёл не всё — полный
+ * список нарушений даёт база одним запросом (`validate_row`, план 2.1, A8), под точкой сохранения: неудача запроса
+ * (схема прежней ревизии) не ломает db.begin(), остаётся прежняя ошибка. Прочие ошибки — как есть.
+ */
+export async function completeIssues(ctx, e) {
+    const p = e instanceof ValidationError ? PENDING.get(e) : undefined;
+    if (!p)
+        return e;
+    const S = quoteId(ctx.schema);
+    let raw;
+    try {
+        raw = await ctx.exec.run(async (q) => {
+            await q.unsafe('savepoint letopis_issues');
+            try {
+                const [r] = (await q.unsafe(`select ${S}.validate_row($1::text, $2::jsonb) as v`, [p.cls, p.data]));
+                await q.unsafe('release savepoint letopis_issues');
+                return r?.v;
+            }
+            catch {
+                await q.unsafe('rollback to savepoint letopis_issues');
+                return null;
+            }
+        }, { read: true });
+    }
+    catch {
+        return e;
+    }
+    if (!Array.isArray(raw) || !raw.length)
+        return e;
+    const v = e;
+    return Object.assign(new ValidationError(p.cls, issuesFromDb(raw), v.key ? { key: v.key, params: v.params } : undefined), { cause: e });
+}
+/**
+ * Блокировка строк в порядке id (lockedRead, updateOp — for no key update; deleteOp с expect — for update): id, которые
+ * удалось заблокировать.
+ */
+export async function lockIds(q, S, ids, mode = 'no key update') {
+    const rows = (await q.unsafe(`select id from ${S}.entity where id = any ($1::uuid[]) order by id for ${mode}`, [ids], { prepare: true }));
+    return new Set(rows.map((r) => r.id));
+}
+/** Фильтр шага сужает цели: id, список id, оператор, строка ответа, объект хотя бы с одним заданным полем. */
+const narrowingFilter = (f) => f !== undefined && f !== null && (typeof f !== 'object' || Array.isArray(f) || isOp(f) || Object.values(f).some((v) => v !== undefined));
+/**
+ * Цели глагола шага i сужены (план 2.0, этап 4, п. 2; 7.10 №2): у него или у шага до него есть фильтр, id, tags()
+ * (пустой список подходит любой строке), owner() или limit(), либо до него был create() или upsert() — дальше путь
+ * идёт от записанных строк.
+ */
+function narrowed(steps, i) {
+    for (let j = 0; j <= i; j++) {
+        const s = steps[j];
+        if (narrowingFilter(s.filter) || s.ownerFilter !== undefined || s.opMods?.limit !== undefined)
+            return true;
+        if (s.tagsFilter !== undefined && s.tagsFilter !== null && !(Array.isArray(s.tagsFilter) && !s.tagsFilter.length))
+            return true;
+        if (j < i && (s.op?.kind === 'create' || s.op?.kind === 'upsert'))
+            return true;
+    }
+    return false;
+}
+/** Шаги сегмента глагола шага i: от шага после прежнего глагола до него самого. */
+function segmentOf(steps, i) {
+    let j = i - 1;
+    while (j >= 0 && !steps[j].op)
+        j--;
+    return steps.slice(j + 1, i + 1);
+}
+/**
+ * Всё, что проверяется без базы, — до отправки первого оператора (§2.5). Фильтры шагов и поля sort() и агрегатов
+ * (неизвестное поле — invalid_query, план 2.0, этап 3, п. 3) — precheckStep построителя; order и agg — модификатор и
+ * агрегат чтения за последним глаголом (терминал цепочки).
+ */
+export function precheckPlan(reg, steps, order, agg) {
     let prevOp;
     for (let i = 0; i < steps.length; i++) {
         const s = steps[i];
         const op = s.op;
+        const tail = i === steps.length - 1;
         if (!op) {
+            precheckStep(reg, s, tail ? order : undefined, tail ? agg : undefined);
             prevOp = undefined;
             continue;
         }
@@ -152,67 +285,73 @@ export function precheckPlan(reg, steps) {
             checkReason(op.reason, `${verb}()`);
         const m = s.opMods ?? {};
         if (m.asOf !== undefined)
-            fail('invalid_query', `${verb}(): asOf описывает прошлое — записывать в него нельзя`);
-        // restore и purge сами ищут удалённые объекты шага
-        if (m.withDeleted && verb !== 'restore' && verb !== 'purge')
-            fail('invalid_query', `${verb}(): withDeleted описывает удалённые — записывать в них нельзя`);
+            throw lerr('write.as_of_write', { verb });
+        // restore сам ищет удалённые объекты шага; withDeleted() — модификатор шага (план 2.1, A9): у шага глагола или шага
+        // до него в сегменте — отказ, как прежде у модификатора цепочки
+        if (verb !== 'restore' && segmentOf(steps, i).some((x) => x.withDeleted))
+            throw lerr('write.with_deleted_write', { verb });
         switch (op.kind) {
             case 'create':
             case 'upsert':
                 if (s.self)
-                    fail('invalid_query', `${verb}() сразу после ${prevOp?.kind}() — между глаголами нужен шаг`);
+                    throw lerr('write.verb_after_verb', { verb, prev: prevOp?.kind });
                 if (s.pivotKey !== undefined)
-                    fail('invalid_query', `${verb}() на возврате к узлу — он ведёт к существующей сущности, используйте update()`);
+                    throw lerr('write.create_on_pivot', { verb });
                 if (s.filter !== undefined && typeof s.filter !== 'string') {
-                    fail('invalid_query', `${verb}() не ищет: ${s.name}(id).${verb}(…) задаёт id, поиск — это update()`);
+                    throw lerr('write.create_with_filter', { verb, step: s.name });
                 }
                 if (op.kind === 'upsert' && !s.cls.key.length)
-                    fail('no_key', `upsert(): у класса ${s.cls.name} нет ключа — сравнивать не с чем, используйте create()`);
+                    throw lerr('write.upsert_no_key', { cls: s.cls.name });
                 checkFullData(s.cls, op.data, verb);
                 if (s.tagsFilter !== undefined && typeof s.tagsFilter !== 'string' && !Array.isArray(s.tagsFilter)) {
-                    fail('invalid_query', `.tags() перед ${verb}() — строка или список`);
+                    throw lerr('write.bad_tags', { verb });
                 }
                 break;
             case 'update':
                 if (!isPlain(op.data))
-                    fail('invalid_data', 'update(): патч — объект');
+                    throw lerr('write.patch_not_object');
                 splitPatch(op.data);
-                checkAggregatePatch(s.cls, op.data);
+                checkPatchEnds(s, op.data);
                 if (op.rev !== undefined && (!Number.isInteger(op.rev) || op.rev < 1))
-                    fail('invalid_query', 'update(patch, { rev }): rev — номер версии строки');
-                break;
-            case 'anonymize': {
-                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}`);
+                    throw lerr('write.bad_rev');
+                // строгий режим (план 2.0, этап 4, п. 2; 7.10 №2): правка без сужения целей — отказ до записи, все строки —
+                // { all: true }; data.id у шага без фильтра — тоже цель (updateOp)
+                if (!op.all && !(s.filter === undefined && typeof op.data.id === 'string') && !narrowed(steps, i)) {
+                    throw lerr('write.no_filter', { call: 'update()', cls: s.cls.name });
                 }
                 break;
-            }
-            case 'reclass':
-                reg.resolve(op.cls);
-                if (op.data !== undefined)
-                    checkFullData(reg.resolve(op.cls), op.data, 'reclass');
-                break;
             case 'delete':
-            case 'restore':
-            case 'purge':
+                // превью (без confirm) ничего не удаляет — его не сужают и не сверяют
+                if (op.expect !== undefined) {
+                    if (!op.confirm)
+                        throw lerr('write.expect_without_confirm');
+                    checkExpect(op.expect, verb);
+                }
+                // 3.0: удаление сверяется с превью, которое видел пользователь (expect); без сверки — только осознанно, { all: true }
+                if (op.confirm && op.expect === undefined && !op.all)
+                    throw lerr('write.confirm_without_expect');
+                if (op.confirm && !op.all && !narrowed(steps, i))
+                    throw lerr('write.no_filter', { call: 'delete({ confirm: true, expect })', cls: s.cls.name });
                 break;
-            case 'rekey':
-                if (!s.cls.key.length)
-                    fail('no_key', `rekey(): у класса ${s.cls.name} нет ключа — id выдаёт база, менять нечего`);
-                checkFullData(s.cls, op.data, 'rekey', false);
+            case 'restore':
+                // partial (второй раунд 2.1, A3) — только с expect: пропуск считается по показанным надгробиям
+                if (op.partial && op.expect === undefined)
+                    throw lerr('write.partial_without_expect');
+                if (op.expect !== undefined)
+                    checkExpect(op.expect, verb);
+                // 3.0: без expect — отказ, и для явных id тоже: restore вернул бы последнее надгробие, а не то, что видел
+                // пользователь (объект могли восстановить, поменять и удалить снова); вернуть всё без сверки — { all: true }
+                else if (!op.all)
+                    throw lerr('write.restore_without_expect');
                 break;
         }
         for (const sl of s.slots ?? []) {
             if (op.kind !== 'create' && op.kind !== 'update' && op.kind !== 'upsert')
-                fail('invalid_query', `слот .${sl.role} после ${verb}() — слоты у create(), update() и upsert()`);
+                throw lerr('write.slot_bad_verb', { role: sl.role, verb });
         }
+        precheckStep(reg, s, s.opMods?.order);
+        if (tail && (order !== undefined || agg !== undefined))
+            precheckStep(reg, s, order, agg);
         prevOp = op;
     }
 }
@@ -228,7 +367,7 @@ const quoteId = (name) => `"${name.replace(/"/g, '""')}"`;
 /** Строка ответа в том же виде, что у чтения (to_jsonb колонок узла). */
 const rowJson = (a) => `jsonb_build_object('id', ${a}.id, 'rev', ${a}.rev, 'class', ${a}.class, 'tenant', ${a}.tenant, 'owner', ${a}.owner, `
     + `'links', ${a}.links, 'data', ${a}.data, 'tags', ${a}.tags, 'at', ${a}.at, 'author', ${a}.author, 'agent', ${a}.agent, `
-    + `'op', ${a}.op, 'reason', ${a}.reason, 'moved', ${a}.moved)`;
+    + `'op', ${a}.op, 'reason', ${a}.reason)`;
 async function query(w, text, params) {
     return (await w.q.unsafe(text, params, { prepare: true }));
 }
@@ -254,16 +393,18 @@ export function slotRole(reg, owner, name) {
         return name;
     const c = reg.find(name);
     if (!c)
-        fail('invalid_class', `класс или роль ${name} не найдены`);
+        throw lerr('write.slot_unknown', { name });
     const roles = rolesAccepting(reg, owner, c.name);
     if (roles.length === 1)
         return roles[0];
     if (!roles.length)
-        fail('invalid_query', `${name} — не конец класса ${owner.name} (концы: ${Object.keys(owner.ends).join(', ') || '—'})`);
-    return fail('invalid_query', `слот ${name} у класса ${owner.name} неоднозначен: роли ${roles.join(', ')} — назовите роль`);
+        throw lerr('write.slot_not_end', { name, cls: owner.name, ends: Object.keys(owner.ends).join(', ') || '—' });
+    throw lerr('write.slot_ambiguous', { name, cls: owner.name, roles: roles.join(', ') });
 }
 /** Неоднозначная роль конца из пути. */
-const ambiguous = (step, target, roles) => fail('invalid_query', `конец класса ${target.name} для шага ${step.name} неоднозначен: роли ${roles.join(', ')} — назовите шаг ролью или задайте слот`);
+const ambiguous = (step, target, roles) => {
+    throw lerr('write.end_ambiguous', { cls: target.name, step: step.name, roles: roles.join(', ') });
+};
 /**
  * Роль из нескольких кандидатов: роли, заданные слотами, не участвуют; из оставшихся — роль с именем
  * класса шага (duty.Member для шага Member, а Backup — слотом). Иначе — неоднозначно.
@@ -317,7 +458,7 @@ async function pathEnds(w, steps, taken) {
         else {
             const rows = await readRows(w, steps.slice(0, k + 1).map(bare), { limit: 2 });
             if (rows.length !== 1)
-                fail('invalid_query', `шаг ${s.name} должен дать ровно одну сущность для конца ${tcls.name} (найдено ${rows.length})`);
+                throw lerr('write.end_not_single', { step: s.name, cls: tcls.name, count: rows.length });
             id = rows[0].id;
             if (!roles) {
                 roles = pickRole(s, tcls, rolesAccepting(w.reg, tcls, rows[0].class), taken, rows[0].class);
@@ -352,7 +493,8 @@ async function slotIds(w, v) {
             // отдаёт строки чтения (план 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;
+            // чтение хвоста отдаёт строки в обёртке { row } (readIn, режим 'rows') — как в батче, распаковать
+            rows = r.kind === 'rows' ? r.rows : r.res.map((x) => toRow(x.row));
         }
         else {
             rows = await readRows(w, v.plan, v.mods);
@@ -368,7 +510,7 @@ async function resolveSlots(w, cls, slots) {
         const end = cls.ends[sl.role];
         const ids = sl.op === 'unset' ? [] : await slotIds(w, sl.value);
         if (sl.op === 'set' && sl.value !== null && !end.many && ids.length !== 1) {
-            fail('invalid_query', `слот .${sl.role}.set(): конец одиночный, а значение дало ${ids.length} сущностей`);
+            throw lerr('write.slot_single_many', { role: sl.role, count: ids.length });
         }
         out.push({ role: sl.role, op: sl.op, value: sl.op === 'unset' || sl.value === null ? null : end.many ? ids : ids[0] });
     }
@@ -405,7 +547,8 @@ function existsError(w, cls, data, links, given, cause) {
             id = undefined;
         }
     }
-    return Object.assign(new LetopisError('exists', `объект класса ${cls.name} уже существует${id ? ` (id ${id})` : ''}`, { id: id ?? null }), { cause });
+    const detail = { id: id ?? null };
+    return id ? lerr('write.exists_id', { cls: cls.name, id }, { detail, cause }) : lerr('write.exists', { cls: cls.name }, { detail, cause });
 }
 const isPkConflict = (e) => {
     const err = e;
@@ -419,16 +562,11 @@ async function createOp(w, steps, opStep, upsert) {
     const links = applySlotsLocal(await pathEnds(w, steps, new Set(slots.map((x) => x.role))), slots);
     const given = typeof opStep.filter === 'string' ? opStep.filter : undefined;
     const owner = opStep.ownerFilter ?? w.owner ?? null;
-    // агрегатные поля (план 1.1, §2.4): в excluded их поставил триггер вставки (0) — замена данных идёт без них, и
-    // триггер правки возвращает прежние значения
-    const agg = aggregateFields(cls);
-    const conflict = upsert
-        ? ` on conflict (id) do update set data = excluded.data${agg.length ? ' - $7::text[]' : ''}, links = excluded.links, tags = excluded.tags`
-        : '';
+    const conflict = upsert ? ' on conflict (id) do update set data = excluded.data, links = excluded.links, tags = excluded.tags' : '';
     const text = `insert into ${S}.entity (id, class, links, data, tags, owner) values ($1::uuid, $2::text, $3::jsonb, $4::jsonb, $5::text[], $6::uuid)`
         + `${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`;
     try {
-        const res = await query(w, text, [given ?? null, cls.name, links, op.data, tagsValue(opStep), owner, ...(upsert && agg.length ? [agg] : [])]);
+        const res = await query(w, text, [given ?? null, cls.name, links, op.data, tagsValue(opStep), owner]);
         return res.map((r) => {
             const row = toRow(r.row);
             if (upsert)
@@ -449,12 +587,17 @@ async function createOp(w, steps, opStep, upsert) {
 async function explainMissing(w, missing, rev) {
     const S = quoteId(w.schema);
     const seen = await query(w, `select id, rev from ${S}.entity where id = any ($1::uuid[])`, [missing]);
-    if (!seen.length)
-        return fail('target_not_found', missing.length === 1 ? `цель ${missing[0]} не найдена` : `цели не найдены: ${missing.join(', ')}`, { ids: missing });
+    if (!seen.length) {
+        throw missing.length === 1
+            ? lerr('write.target_missing', { id: missing[0] }, { detail: { ids: missing } })
+            : lerr('write.targets_missing', { ids: missing.join(', ') }, { detail: { ids: missing } });
+    }
     if (rev !== undefined && seen.some((r) => r.rev !== rev)) {
-        return fail('conflict', `строку ${seen[0].id} успели изменить: версия ${seen[0].rev}, а не ${rev} — перечитайте и повторите`, { id: seen[0].id, rev: seen[0].rev, expected: rev });
+        const detail = { id: seen[0].id, rev: seen[0].rev, expected: rev };
+        throw lerr('write.rev_conflict', detail, { detail });
     }
-    return fail('acl_denied', `строки видны, но изменить их нельзя: ${seen.map((r) => r.id).join(', ')}`, { ids: seen.map((r) => r.id) });
+    const ids = seen.map((r) => r.id);
+    throw lerr('write.rows_denied', { ids: ids.join(', ') }, { detail: { ids } });
 }
 /**
  * Строки ответа глагола — в порядке целей (`targetIds`: по `sort()` до глагола, иначе по id). `update … returning`
@@ -464,14 +607,19 @@ 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 — если у шага нет фильтра. */
+/** Шаги сужены только по id: фильтр — id или список id, без tags(), owner() и обхода deep(). */
+function idsOnly(steps) {
+    return steps.every((s) => (s.filter === undefined || typeof s.filter === 'string' || (Array.isArray(s.filter) && s.filter.every((x) => typeof x === 'string')))
+        && s.tagsFilter === undefined && s.ownerFilter === undefined);
+}
+/** Цели update и delete: 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 };
     const ids = await readIds(w, path, opStep.opMods ?? {});
-    // без явного порядка — по id: глаголы по списку целей (reclass, rekey и др.) пишут журнал по очереди, и порядок
-    // записей не должен зависеть от плана чтения
+    // без явного порядка — по id: глаголы по списку целей пишут журнал по очереди, и порядок записей не должен
+    // зависеть от плана чтения
     return opStep.opMods?.order ? ids : [...ids].sort();
 }
 async function updateOp(w, steps, opStep) {
@@ -480,12 +628,20 @@ async function updateOp(w, steps, opStep) {
     // data.id — цель, только если у шага нет своего фильтра (write.ts:461-466 в 0.21); тогда id не данные
     const useDataId = opStep.filter === undefined && typeof op.data.id === 'string';
     const { id: dataId, ...data } = op.data;
-    const ids = await targetIds(w, steps, opStep, useDataId ? dataId : undefined);
+    let ids = await targetIds(w, steps, opStep, useDataId ? dataId : undefined);
+    // цели сужены не только по id (данные, концы, tags(), owner()): как lockedRead — блокировка целей и то же чтение заново;
+    // правятся только строки, которые и после ожидания блокировки подходят под условия (план 2.1, A4). Без гонки — те же
+    // цели; строка, которую не дала заблокировать RLS, остаётся в целях — её объяснит explainMissing
+    if (ids.length && !idsOnly(steps)) {
+        const locked = await lockIds(w.q, S, ids);
+        const fresh = new Set(await targetIds(w, steps, opStep, useDataId ? dataId : undefined));
+        ids = ids.filter((id) => fresh.has(id) || !locked.has(id));
+    }
     if (op.rev !== undefined) {
         if (ids.length > 1)
-            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — проверить версию { rev } можно только у одной цели`);
+            throw lerr('write.rev_many_targets', { step: opStep.name, count: ids.length });
         if (!ids.length)
-            fail('target_not_found', `update(patch, { rev }): у шага ${opStep.name} нет цели`);
+            throw lerr('write.rev_no_target', { step: opStep.name });
     }
     if (!ids.length)
         return [];
@@ -510,24 +666,53 @@ async function updateOp(w, steps, opStep) {
     }
     return inTargetOrder(ids, res.map((r) => toRow(r.row)));
 }
+/** Превью удаления целей: то же замыкание, что у триггера удаления (ref_action), база не меняется. */
+async function previewOf(w, ids) {
+    const S = quoteId(w.schema);
+    const res = await query(w, `select ${rowJson('e')} as row, p.action, p.depth from ${S}.delete_preview($1::uuid[]) p `
+        + `join ${S}.entity e on e.id = p.id order by p.depth nulls last, p.action, e.id`, [ids]);
+    return res.map((r) => {
+        const row = toRow(r.row);
+        row.$action = r.action;
+        if (r.depth !== null)
+            row.$depth = r.depth;
+        return row;
+    });
+}
+/** Превью совпадает с показанным: те же строки по id, с теми же rev и $action (порядок не важен). */
+function samePreview(now, expect) {
+    if (now.length !== expect.length)
+        return false;
+    const want = new Map(expect.map((x) => [x.id.toLowerCase(), x]));
+    return now.every((r) => {
+        const x = want.get(r.id.toLowerCase());
+        return x !== undefined && x.rev === r.rev && (x.$action === undefined || x.$action === r.$action);
+    });
+}
 async function deleteOp(w, steps, opStep) {
     const op = opStep.op;
     const S = quoteId(w.schema);
     const ids = await targetIds(w, steps, opStep);
+    if (!op.confirm)
+        return ids.length ? previewOf(w, ids) : [];
+    // delete({ confirm: true, expect }): удалить ровно показанное (план 2.1, A2) — превью заново в той же транзакции.
+    // Атомарно (второй раунд 2.1, A1): всё замыкание каскада (строки превью с $action 'delete') блокируется for update в
+    // порядке id, и превью строится ещё раз уже под блокировкой. Вставка связи берёт на своих концах for key share
+    // (60-write.sql, targets_bad): с for update она конфликтует, с for no key update — нет. Вставщик успел первым —
+    // пересчёт видит его строку (preview_changed); мы первые — он получает end_target_missing. Взаимоблокировку при росте
+    // замыкания повторяет runTx (40P01)
+    if (op.expect !== undefined) {
+        let now = ids.length ? await previewOf(w, ids) : [];
+        const closure = now.filter((r) => r.$action === 'delete').map((r) => r.id);
+        if (closure.length) {
+            await lockIds(w.q, S, closure, 'update');
+            now = await previewOf(w, ids);
+        }
+        if (!samePreview(now, op.expect))
+            throw lerr('write.preview_changed', undefined, { detail: { preview: now } });
+    }
     if (!ids.length)
         return [];
-    if (!op.confirm) {
-        // превью: то же замыкание, что у триггера удаления (ref_action), база не меняется
-        const res = await query(w, `select ${rowJson('e')} as row, p.action, p.depth from ${S}.delete_preview($1::uuid[]) p `
-            + `join ${S}.entity e on e.id = p.id order by p.depth nulls last, p.action, e.id`, [ids]);
-        return res.map((r) => {
-            const row = toRow(r.row);
-            row.$action = r.action;
-            if (r.depth !== null)
-                row.$depth = r.depth;
-            return row;
-        });
-    }
     // результат — надгробия этой транзакции после метки: delete … returning не видит каскад триггера
     const [{ mark }] = await query(w, `select coalesce(max(seq), 0)::text as mark from ${S}.log where tx = pg_current_xact_id()`, []);
     const gone = await query(w, `delete from ${S}.entity e where e.id = any ($1::uuid[]) returning ${rowJson('e')} as row`, [ids]);
@@ -550,99 +735,155 @@ async function deleteOp(w, steps, opStep) {
     }
     return out;
 }
-async function anonymizeOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
+/** Причины отказа для строк шага restore (живых или надгробий не той версии): одним запросом к журналу. */
+async function refusals(w, rows, want) {
+    if (!rows.length)
         return [];
-    const res = await query(w, `update ${S}.entity e set data = e.data || coalesce((select jsonb_object_agg(f, '[erased]'::text) from unnest($2::text[]) f where e.data ? f), '{}'::jsonb), `
-        + `tags = (select array_agg(distinct t order by t) from unnest(e.tags || array['anonymized']) t) `
-        + `where e.id = any ($1::uuid[]) returning ${rowJson('new')} as row`, [ids, op.fields]);
-    if (res.length < ids.length) {
-        const got = new Set(res.map((r) => r.row.id));
-        await explainMissing(w, ids.filter((x) => !got.has(x)));
-    }
-    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
-}
-async function reclassOp(w, steps, opStep) {
-    const op = opStep.op;
     const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
-        return [];
-    const cls = w.reg.resolve(op.cls).name;
-    // у класса без ключа 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)]);
-    // строки ответа — в порядке целей (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) {
-    const rows = await readRows(w, steps.map(bare), { ...(opStep.opMods ?? {}), withDeleted: true });
-    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) });
-    // без явного порядка — по id: restore и purge пишут журнал по очереди целей
-    return opStep.opMods?.order ? dead : [...dead].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const exp = rows.map((r) => want?.get(r.id.toLowerCase()) ?? null);
+    const log = await query(w, `select x.id::text as id, `
+        + `(select l.op from ${S}.log l where l.id = x.id and l.rev > x.exp order by l.rev limit 1) as after, `
+        + `(select l.op from ${S}.log l where l.id = x.id and l.rev > (select max(t.rev) from ${S}.log t where t.id = x.id and t.op = 'delete') `
+        + `order by l.rev limit 1) as after_last from unnest($1::uuid[], $2::int[]) as x(id, exp)`, [rows.map((r) => r.id), exp]);
+    const by = new Map(log.map((r) => [r.id.toLowerCase(), r]));
+    return rows.map((r, i) => {
+        const l = by.get(r.id.toLowerCase());
+        const live = r.$deleted !== true;
+        const last = l?.after_last ?? null;
+        const why = live && last === 'restore' ? 'restored' : live && last === 'create' ? 'reissued' : 'changed';
+        return { id: r.id, rev: r.rev, expected: exp[i], after: l?.after ?? null, deleted: !live, live, why };
+    });
 }
-/** Восстановление (этап 6, п. 2): последний снимок новой версией; база перепроверяет его по текущему описанию. */
-async function restoreOp(w, steps, opStep) {
-    const S = quoteId(w.schema);
-    const dead = await deletedTargets(w, steps, opStep, 'restore');
-    if (!dead.length)
-        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[])`, [ids]);
-    return inTargetOrder(ids, res.map((r) => toRow(r.row)));
+/**
+ * Отказ restore по смыслу (второй раунд 2.1, A2): есть `changed` — restore_stale (conflict), иначе есть `reissued` —
+ * restore_id_taken, иначе restore_already (оба — not_deleted). detail.ids — цели этого ключа; с expect (и всегда у
+ * restore_stale) detail.stale — все цели, которые не восстановить, с причиной.
+ */
+function restoreRefusal(verb, list, withExpect, cause) {
+    const of = (why) => list.filter((x) => x.why === why).map((x) => x.id);
+    const extra = (detail) => ({ detail, ...(cause !== undefined ? { cause } : {}) });
+    const stale = withExpect ? { stale: list } : {};
+    const changed = of('changed');
+    if (changed.length)
+        return lerr('write.restore_stale', { ids: changed.join(', ') }, extra({ ids: changed, stale: list }));
+    const taken = of('reissued');
+    if (taken.length)
+        return lerr('write.restore_id_taken', { verb, ids: taken.join(', ') }, extra({ ids: taken, ...stale }));
+    const done = of('restored');
+    return lerr('write.restore_already', { verb, ids: done.join(', ') }, extra({ ids: done, ...stale }));
 }
+/** Строка ответа restore({ expect, partial: true }) для цели, которую не восстановить (второй раунд 2.1, A3). */
+const skipRow = (r, why) => ({ ...r, $action: 'skip', $why: why });
+const byIdOrder = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
 /**
- * Стирание истории удалённых (этап 6, п. 3): без { confirm: true } — превью (надгробия и число
- * версий $versions), с ним — версии стёрты, на месте версии 1 — запись purge ($purged).
+ * Удалённые объекты шага (restore). Шаг цели читается с надгробиями; у шагов до него withDeleted() — свой (план 2.1, A9).
+ * Без expect: восстанавливаются удалённые цели; если удалённых нет, а живые есть — отказ по смыслу (restoreRefusal: уже
+ * восстановлен, id занят новым объектом) или not_deleted (не удалялся). С expect — только цели из expect, и последняя
+ * версия каждой — то же надгробие; иначе отказ по смыслу и ничего не восстановлено, а с partial — строка-пропуск.
  */
-async function purgeOp(w, steps, opStep) {
-    const op = opStep.op;
-    const S = quoteId(w.schema);
-    const dead = await deletedTargets(w, steps, opStep, 'purge');
-    const out = [];
-    for (const row of dead) {
-        const [{ r }] = await query(w, `select ${S}.purge($1::uuid, $2::boolean) as r`, [row.id, op.confirm]);
-        out.push({ ...row, $versions: r.versions, ...(r.purged ? { $purged: true } : {}) });
+async function deletedTargets(w, steps, opStep, verb, expect, partial) {
+    const path = steps.map(bare);
+    path[path.length - 1] = { ...path[path.length - 1], withDeleted: true };
+    const rows = await readRows(w, path, opStep.opMods ?? {});
+    // без явного порядка — по id: restore пишет журнал по очереди целей
+    const ordered = (xs) => (opStep.opMods?.order ? xs : [...xs].sort(byIdOrder));
+    if (expect !== undefined) {
+        const want = new Map(expect.map((x) => [x.id.toLowerCase(), x.rev]));
+        const mine = rows.filter((r) => want.has(r.id.toLowerCase()));
+        const good = (r) => r.$deleted === true && r.rev === want.get(r.id.toLowerCase());
+        const bad = await refusals(w, mine.filter((r) => !good(r)), want);
+        if (bad.length && !partial)
+            throw restoreRefusal(verb, bad, true);
+        const why = new Map(bad.map((x) => [x.id, x.why]));
+        const all = ordered(mine);
+        return { dead: all.filter(good), skip: all.filter((r) => !good(r)).map((r) => skipRow(r, why.get(r.id) ?? 'changed')), order: all.map((r) => r.id) };
     }
-    return out;
+    const dead = rows.filter((r) => r.$deleted);
+    if (!dead.length && rows.length) {
+        const live = await refusals(w, rows, null);
+        if (live.some((x) => x.why !== 'changed'))
+            throw restoreRefusal(verb, live.filter((x) => x.why !== 'changed'), false);
+        throw lerr('write.not_deleted', { verb }, { detail: { ids: rows.map((r) => r.id) } });
+    }
+    const all = ordered(dead);
+    return { dead: all, skip: [], order: all.map((r) => r.id) };
 }
-/** Новое значение ключа (этап 6, п. 7): строка с новым id, ссылки переведены, журнал связывает id. */
-async function rekeyOp(w, steps, opStep) {
-    const op = opStep.op;
+/** Отказ функции базы restore() по смыслу (уже восстановлен, id занят, версия не та) — причина и подробности; иначе null. */
+function dbRefusal(e) {
+    const le = fromDbError(e);
+    if (!(le instanceof LetopisError))
+        return null;
+    const why = le.key === 'sql-time.restore_already' ? 'restored' : le.key === 'sql-time.restore_id_taken' ? 'reissued'
+        : le.key === 'sql-time.restore_stale' ? 'changed' : undefined;
+    if (!why)
+        return null;
+    const d = (le.detail ?? {});
+    const p = le.params ?? {};
+    return {
+        id: String(d.id ?? p.id ?? ''), rev: Number(d.rev ?? p.rev ?? 0), expected: d.expected ?? (typeof p.expected === 'number' ? p.expected : null),
+        after: d.after ?? null, deleted: d.deleted ?? false, live: d.live ?? why !== 'changed', why,
+    };
+}
+/**
+ * Восстановление (этап 6, п. 2): последний снимок новой версией; база перепроверяет его по текущему описанию. С expect
+ * база ещё раз сверяет номер последней версии под блокировкой записи журнала (restore(id, rev), план 2.1, A1): гонку
+ * между чтением и восстановлением ловит она, и её отказ — по смыслу, как у проверки до записи (второй раунд 2.1, A2).
+ * partial (A3): цели, которые не восстановить, — строки-пропуски { …строка, $action: 'skip', $why }, остальные
+ * восстанавливаются; каждая цель — под своей точкой сохранения, проигранная гонка тоже становится пропуском.
+ */
+async function restoreOp(w, steps, opStep) {
     const S = quoteId(w.schema);
-    const ids = await targetIds(w, steps, opStep);
-    if (!ids.length)
-        return [];
-    // поля — в данные, роли концов — в концы
-    const data = {};
-    const links = {};
-    for (const [k, v] of Object.entries(op.data)) {
-        if (opStep.cls.ends[k])
-            links[k] = typeof v === 'object' && v !== null && !Array.isArray(v) ? v.id : v;
-        else
-            data[k] = v;
-    }
-    const moved = [];
-    for (const id of ids) {
+    const { expect, partial } = opStep.op;
+    const { dead, skip, order } = await deletedTargets(w, steps, opStep, 'restore', expect, partial);
+    if (!dead.length)
+        return inTargetOrder(order, skip);
+    let ids = dead.map((r) => r.id);
+    if (expect === undefined) {
+        // прежний вызов restore(id): работает и со схемой прежней ревизии
+        try {
+            await query(w, `select ${S}.restore(x) from unnest($1::uuid[]) with ordinality as u(x, i) order by u.i`, [ids]);
+        }
+        catch (e) {
+            const r = dbRefusal(e);
+            if (r && r.why !== 'changed')
+                throw restoreRefusal('restore', [r], false, e);
+            throw e;
+        }
+    }
+    else if (!partial) {
         try {
-            const [{ id: nid }] = await query(w, `select ${S}.rekey($1::uuid, $2::jsonb, $3::jsonb) as id`, [id, data, links]);
-            moved.push(nid);
+            await query(w, `select ${S}.restore(u.x, u.r) from unnest($1::uuid[], $2::int[]) with ordinality as u(x, r, i) order by u.i`, [ids, dead.map((r) => r.rev)]);
         }
         catch (e) {
-            if (isPkConflict(e))
-                throw Object.assign(new LetopisError('exists', `rekey(): объект класса ${opStep.cls.name} с таким ключом уже существует`, { id }), { cause: e });
+            const r = dbRefusal(e);
+            if (r)
+                throw restoreRefusal('restore', [r], true, e);
             throw e;
         }
     }
-    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)));
+    else {
+        const lost = new Set();
+        for (const r of dead) {
+            await w.q.unsafe('savepoint letopis_restore');
+            try {
+                await query(w, `select ${S}.restore($1::uuid, $2::int)`, [r.id, r.rev]);
+                await w.q.unsafe('release savepoint letopis_restore');
+            }
+            catch (e) {
+                await w.q.unsafe('rollback to savepoint letopis_restore');
+                const why = dbRefusal(e)?.why;
+                if (!why)
+                    throw e;
+                lost.add(r.id);
+                skip.push(skipRow(r, why));
+            }
+        }
+        ids = ids.filter((id) => !lost.has(id));
+    }
+    const res = ids.length
+        ? await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[])`, [ids])
+        : [];
+    return inTargetOrder(order, [...res.map((r) => toRow(r.row)), ...skip]);
 }
 async function opCall(w, steps, opStep) {
     await useReason(w, reasonFor(w, opStep));
@@ -651,11 +892,7 @@ async function opCall(w, steps, opStep) {
         case 'upsert': return createOp(w, steps, opStep, true);
         case 'update': return updateOp(w, steps, opStep);
         case 'delete': return deleteOp(w, steps, opStep);
-        case 'anonymize': return anonymizeOp(w, steps, opStep);
-        case 'reclass': return reclassOp(w, steps, opStep);
         case 'restore': return restoreOp(w, steps, opStep);
-        case 'purge': return purgeOp(w, steps, opStep);
-        case 'rekey': return rekeyOp(w, steps, opStep);
     }
 }
 /** Разрезать план: сегменты (…шаги + шаг с глаголом) и читающий хвост после последнего глагола. */
@@ -712,18 +949,18 @@ export async function execPlan(w, steps, mods, mode, agg) {
         else {
             last = await opCall(w, [fromRows(prevOp, start.map((r) => r.id)), ...seg.steps], opStep);
         }
-        // после удаления продолжение — от удалённых строк класса цели (замыкание каскада шире); после
-        // стирания истории продолжать не от чего
+        // после удаления продолжение — от удалённых строк класса цели (замыкание каскада шире); после restore — от
+        // восстановленных, без строк-пропусков partial
         start = kind === 'delete' && opStep.op.confirm
             ? last.filter((r) => stepClasses(w.reg, opStep).includes(r.class))
-            : kind === 'purge' ? [] : last;
+            : kind === 'restore' ? last.filter((r) => r.$action !== 'skip') : last;
         prevOp = opStep;
     }
     // причина глагола не переходит на следующие операторы транзакции
     await useReason(w, w.reason ?? '');
     const opStep = segments[segments.length - 1].steps.at(-1);
     const key = opStep.aliasKey ?? opStep.name;
-    if (tail.length || mode === 'versions' || mode === 'agg' || mode === 'diff' || mode === 'blame') {
+    if (tail.length || mode === 'versions' || mode === 'agg') {
         if (!start.length)
             return { kind: 'read', q: null, res: [] };
         const { q, res } = await readIn(w, [fromRows(opStep, start.map((r) => r.id)), ...tail], mods, mode, agg);
@@ -793,13 +1030,11 @@ export async function execBatch(w, plans) {
             }
             await useReason(w, why);
             const input = group.map((g) => ({ d: g.s.op.data, t: tagsValue(g.s), o: g.s.ownerFilter ?? w.owner ?? null }));
-            // агрегатные поля — без них, как у одиночного upsert (план 1.1, §2.4)
-            const agg = aggregateFields(head.cls);
             const conflict = verb === 'upsert'
-                ? `on conflict (id) do update set data = excluded.data${agg.length ? ' - $3::text[]' : ''}, links = excluded.links, tags = excluded.tags`
+                ? 'on conflict (id) do update set data = excluded.data, links = excluded.links, tags = excluded.tags'
                 : 'on conflict (id) do nothing';
             const res = await query(w, `insert into ${S}.entity (class, data, tags, owner) select $1::text, x.d, x.t, x.o `
-                + `from jsonb_to_recordset($2::jsonb) as x(d jsonb, t text[], o uuid) ${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`, [head.cls.name, input, ...(verb === 'upsert' && agg.length ? [agg] : [])]);
+                + `from jsonb_to_recordset($2::jsonb) as x(d jsonb, t text[], o uuid) ${conflict} returning old.rev as old_rev, ${rowJson('new')} as row`, [head.cls.name, input]);
             const byId = new Map(res.map((r) => [r.row.id, r]));
             for (const g of group) {
                 const r = byId.get(g.id);