letopis 0.20.3 → 1.0.0

package/dist/write.js

@@ -1,817 +1,755 @@
 /**
- * Запись: операции .create(data) / .update(data) / .delete(opts) / .anonymize(fields) —
- * ЗВЕНЬЯ цепочки; терминал (rows/first/ids/count/run/versions/агрегации) исполняет весь
- * план ОДНОЙ транзакцией (runPlan) — любой отказ (валидация/ACL) откатывает всё.
+ * Запись планами (план, §2.5, этап 4, п. 1–7, 10): глаголы create, update, upsert, delete, anonymize
+ * и reclass — звенья цепочки; терминал исполняет весь план одной транзакцией. Этап 6: restore и
+ * purge — над удалёнными объектами шага, rekey — новое значение ключа (функции базы).
  *
- * Связи задаются dot-цепочкой: шаги до операции (контекст) резолвятся в ровно одну
- * сущность каждый и дают:
- *   - containment-фильтр целей при update/delete (links ⊇ {Класс: id}),
- *   - links создаваемой строки при create.
+ *   await db.Org(org).Staff().create({ name: 'Вася', phone: '+7' }).rows()      // концы из пути: { Org }
+ *   await db.Customer(c).booking({ notes: 'x' }).update({ notes: 'y' }).rows()
+ *   await db.Wallet(w).update({ balance: inc(-300) }).first()                     // приращение в базе
+ *   await db.Staff(s).booking().create({ … }).Customer.set(c).Item.set(svc).rows() // слоты концов
  *
- *   await db.Организация(org).Сотрудник().create({ name: 'Вася' }).rows()  // INSERT + links {Org}
- *   await db.Клиент(c).Запись({ status: 'created' }).update({ status: 'confirmed' }).rows()
- *   await db.Клиент({ vip: true }).update({ bonus: 500 })     // сегмент 1: версия каждого vip
- *           .Запись().delete({ confirm: true }).rows()        // сегмент 2: снести записи каждого
- * Продолжение после операции идёт ОТ ЕЁ РЕЗУЛЬТАТА (fan-out по записанным строкам).
+ * Библиотека пишет обычными операторами SQL — теми же, что выполнил бы человек в консоли:
+ * insert, update … set data = merge(data, $patch), insert … on conflict do update, delete; всё
+ * проверяют триггеры базы. Продолжение после глагола идёт от его результата (fan-out по строкам),
+ * глагол сразу после глагола пишет в те же сущности. Всё, что проверяется без базы, проверяется
+ * до отправки первого оператора (precheckPlan): такая ошибка не ломает явную транзакцию.
+ * Если update или delete затронул меньше строк, чем шаг нашёл, план откатывается:
+ * строка видна, но править нельзя — acl_denied; строки уже нет — target_not_found; номер версии
+ * разошёлся со { rev } — conflict.
  */
-//
-// FILE: lib/src/write.ts
-// VERSION: 1.1.0
-// START_MODULE_CONTRACT
-//   PURPOSE: Write-side движок: валидация, резолв концов/слотов, вычисление id (v5/v7), вставка новых версий, каскадное удаление, анонимизация, исполнение планов и батчей в транзакции.
-//   SCOPE: ValidationError, runPlan, executeBatch, createOp/updateOp/delOp/anonymizeOp, toRow/readRows/deepMerge, BatchPlan.
-//   DEPENDS: M-UUID, M-TYPES, M-SQL, M-ACL
-//   LINKS: M-WRITE, V-M-WRITE
-//   ROLE: RUNTIME
-//   MAP_MODE: EXPORTS
-// END_MODULE_CONTRACT
-//
-// START_MODULE_MAP
-//   ValidationError - ошибка валидации с полями issues
-//   toRow/readRows/deepMerge - нормализация строки, чтение, deep-merge патча
-//   createOp/updateOp/anonymizeOp/delOp - операции записи (create/update/anonymize/delete)
-//   runPlan - исполнить план (сегменты op + читающий хвост) одной транзакцией
-//   executeBatch - исполнить очередь планов (fast-path multi-insert для чистых INSERT)
-//   BatchPlan/PlanMode - модель плана батча и режимы чтения
-// END_MODULE_MAP
-//
-// START_CHANGE_SUMMARY
-//   LAST_CHANGE: [v1.1.0 - resolveAccount зовёт guardScoped: при enforceAccount без scope (db.as)
-//     запись запрещена с внятной подсказкой; ctx.account теперь приходит из scope, не из connect.
-//     Ранее: Documented existing module: reverse-engineered contract + markup]
-// END_CHANGE_SUMMARY
-import { randomUUID } from 'node:crypto';
-import { uuidv5, uuidv7 } from './uuid.js';
-import { buildRead, guardScoped, runQuery, insertSql, multiInsertSql, deleteSql, closureSql, purgeCallSql, isTransient, retryDelay, RETRIES, } from './sql.js';
-import { aclDenied } from './acl.js';
-// START_CONTRACT: ValidationError
-//   PURPOSE: Ошибка валидации класса, несущая список проблемных полей (issues).
-//   INPUTS: { cls: string; issues: {field, message?}[] }
-//   OUTPUTS: { Error - message с перечнем «поле — сообщение» }
-//   SIDE_EFFECTS: none
-//   LINKS: M-WRITE, V-M-WRITE
-// END_CONTRACT: ValidationError
-export class ValidationError extends Error {
-    issues;
-    constructor(cls, issues) {
-        super(`letopis: validation failed for "${cls}": ${issues.map((i) => `${i.field} — ${i.message ?? 'invalid'}`).join('; ')}`);
-        this.issues = issues;
-    }
-}
-export function toRow(r) {
-    return {
-        id: r.id,
-        class: r.class,
-        data: r.data ?? {},
-        links: r.links ?? {},
-        tags: r.tags ?? [],
-        account: r.account,
-        owner: r.owner,
-        updated: r.updated instanceof Date ? r.updated.toISOString() : r.updated,
-    };
-}
-/** Прочитать актуальные строки по цепочке. */
-export async function readRows(ctx, steps, mods = {}) {
-    const q = buildRead(ctx, steps, mods, 'rows');
-    const res = await runQuery(ctx, q.text, q.params, 'rows', steps.map((s) => s.cls.id));
-    return res.map((r) => toRow(r.row));
-}
-const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Date);
+import { LetopisError, ValidationError } from './errors.js';
+import { isOp } from './ops.js';
+import { accepts, buildRead, nextNodeKey, resolveHop, stepClasses, toRow } from './sql.js';
+import { idOf } from './uuid.js';
+import { applyDefaults } from './validate.js';
+// ---------------------------------------------------------------------------
+// Приращение: маркер, которого не получить из JSON (§2.5)
+// ---------------------------------------------------------------------------
+/** Метка приращения; Symbol.for — маркер узнаёт и вторая копия пакета в процессе. */
+export const INC = Symbol.for('letopis.inc');
 /**
- * Deep-merge патча в базу: меняются ТОЛЬКО указанные листья.
- * Вложенные plain-объекты сливаются рекурсивно; массивы/скаляры/null — заменяются.
+ * Приращение в update: `update({ balance: inc(-300) })` — величина прибавляется в базе, внутри
+ * оператора, над свежей строкой (функция inc). Поля нет — ошибка; `{ start }` — начать с него.
  */
-export function deepMerge(base, patch) {
-    const out = { ...base };
-    for (const [k, v] of Object.entries(patch)) {
-        if (v === undefined)
-            continue;
-        out[k] = isPlainObject(v) && isPlainObject(out[k])
-            ? deepMerge(out[k], v)
-            : v;
-    }
-    return out;
+export function inc(by, opts = {}) {
+    return Object.freeze({ [INC]: true, by, ...(opts.start !== undefined ? { start: opts.start } : {}) });
 }
-// START_CONTRACT: validate
-//   PURPOSE: Проверить данные по fastest-validator (строго, + id) и концы LINK; вернуть очищенные данные.
-//   INPUTS: { cls: ClassDef; id: string; data: object; links: object }
-//   OUTPUTS: { object - валидные данные (без id) }
-//   SIDE_EFFECTS: none
-//   ERRORS: class is abstract; ValidationError; link requires end; stray link(s)
-//   LINKS: M-WRITE, V-M-WRITE, M-SCHEMA
-// END_CONTRACT: validate
-/** Валидация данных по fastest-validator (строгая, + id) и концов LINK. */
-function validate(cls, id, data, links) {
-    if (cls.abstract)
-        throw new Error(`letopis: class "${cls.id}" is abstract`);
-    const merged = { ...data, id };
-    const res = cls.check(merged);
-    if (res !== true)
-        throw new ValidationError(cls.id, res);
-    delete merged.id;
-    // START_BLOCK_VALIDATE_LINK_ENDS
-    if (cls.category === 'LINK') {
-        const present = new Set(Object.keys(links));
-        if (cls.strictEnds) {
-            // схема v2: жадный матчинг по порядку объявления концов; союз занимает один ключ;
-            // обязательный конец без ключа и ключ вне концов — ошибки
-            for (const end of cls.links) {
-                const hit = end.classes.find((c) => present.has(c));
-                if (hit)
-                    present.delete(hit);
-                else if (!end.optional)
-                    throw new Error(`letopis: link "${cls.id}" requires end "${end.classes.join('|')}"`);
+export const isInc = (v) => typeof v === 'object' && v !== null && v[INC] === true;
+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);
+/** Патч update → остаток для merge и список приращений. Недопустимое — invalid_data до отправки. */
+export function splitPatch(patch) {
+    const incs = [];
+    const noMarkers = (v, path) => {
+        if (isInc(v))
+            fail('invalid_data', `inc() внутри массива (${path.join('.')}) не поддерживается`);
+        if (isOp(v))
+            fail('invalid_data', `оператор фильтра в данных (${path.join('.')}) — данные записываются значениями`);
+        if (Array.isArray(v))
+            v.forEach((x, i) => noMarkers(x, [...path, String(i)]));
+        else if (isPlain(v))
+            for (const [k, x] of Object.entries(v))
+                noMarkers(x, [...path, k]);
+    };
+    const walk = (obj, path) => {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (v === undefined)
+                continue;
+            const p = [...path, k];
+            if (isInc(v)) {
+                if (!Number.isFinite(v.by))
+                    fail('invalid_data', `inc(${v.by}) по пути ${p.join('.')}: величина — конечное число`);
+                if (v.start !== undefined && !Number.isFinite(v.start))
+                    fail('invalid_data', `inc: start по пути ${p.join('.')} — конечное число`);
+                incs.push({ path: p, by: v.by, ...(v.start !== undefined ? { start: v.start } : {}) });
             }
-            if (present.size) {
-                throw new Error(`letopis: link "${cls.id}" has stray link(s) ${[...present].map((k) => `"${k}"`).join(', ')} — not an end in Schema.links`);
+            else if (isOp(v)) {
+                fail('invalid_data', `оператор фильтра в патче (${p.join('.')}) — update записывает значения`);
             }
-        }
-        else {
-            // legacy-схема (строковые концы): 'Entity' — полиморф-счётчик, лишние связи молчат
-            let polymorphic = 0;
-            for (const end of cls.links) {
-                const name = end.classes[0];
-                if (name === 'Entity')
-                    polymorphic++;
-                else if (present.has(name))
-                    present.delete(name);
-                else
-                    throw new Error(`letopis: link "${cls.id}" requires end "${name}"`);
+            else if (Array.isArray(v)) {
+                noMarkers(v, p);
+                out[k] = v;
             }
-            if (present.size < polymorphic) {
-                throw new Error(`letopis: link "${cls.id}" requires ${polymorphic} polymorphic end(s) (any class), got ${present.size}`);
+            else if (isPlain(v)) {
+                const before = incs.length;
+                const sub = walk(v, p);
+                // объект, опустевший после изъятия маркеров, не подставляется вместо значения на пути
+                if (Object.keys(sub).length || incs.length === before)
+                    out[k] = sub;
+            }
+            else {
+                out[k] = v;
             }
         }
-    }
-    // END_BLOCK_VALIDATE_LINK_ENDS
-    return merged;
+        return out;
+    };
+    return { rest: walk(patch, []), incs };
 }
-// START_CONTRACT: insertOne
-//   PURPOSE: INSERT одной строки-версии с ретраем гонок (23505 коллизия updated, 40P01/40001 transient) вне транзакции.
-//   INPUTS: { ctx: Ctx; a: InsertArgs }
-//   OUTPUTS: { Promise<Row> - вставленная строка }
-//   SIDE_EFFECTS: INSERT в Entity через runQuery
-//   LINKS: M-WRITE, V-M-WRITE, M-SQL, M-DDL
-// END_CONTRACT: insertOne
-/** INSERT одной строки с ретраем гонок: 23505 (коллизия updated) и transient (40P01/40001). */
-async function insertOne(ctx, a) {
-    // jsonb-параметры — JS-объектами (postgres.js сериализует сам)
-    const params = [
-        ctx.partition, a.id, a.cls.id, a.data, a.links, a.tags,
-        a.account, a.owner, a.prevUpdated, a.deleted,
-    ];
-    // START_BLOCK_INSERT_ONE_RETRY
-    for (let attempt = 1;; attempt++) {
-        try {
-            const res = await runQuery(ctx, insertSql(ctx.pgSchema), params, 'insert', [a.cls.id]);
-            return toRow(res[0]);
+// ---------------------------------------------------------------------------
+// Проверки до отправки (precheckPlan)
+// ---------------------------------------------------------------------------
+/** Данные create/upsert: объект без маркеров; ранняя проверка валидатором на TypeScript (full — объект целиком). */
+function checkFullData(cls, data, verb, full = true) {
+    if (!isPlain(data))
+        fail('invalid_data', `${verb}(): данные — объект`);
+    const scan = (v, path) => {
+        if (isInc(v))
+            fail('invalid_data', `inc() работает только в update(): ${verb}() по пути ${path.join('.')}`);
+        if (isOp(v))
+            fail('invalid_data', `оператор фильтра в данных ${verb}() (${path.join('.')}) — данные записываются значениями`);
+        if (Array.isArray(v))
+            v.forEach((x, i) => scan(x, [...path, String(i)]));
+        else if (isPlain(v))
+            for (const [k, x] of Object.entries(v))
+                scan(x, [...path, k]);
+    };
+    scan(data, []);
+    // описания системных классов проверяет только база (метасхема Class, class_admit)
+    if (!full || cls.name === 'Class' || cls.abstract)
+        return;
+    const issues = cls.validator()(applyDefaults(cls.schema, data));
+    if (issues.length)
+        throw new ValidationError(cls.name, issues);
+}
+/** Всё, что проверяется без базы, — до отправки первого оператора (§2.5). */
+export function precheckPlan(reg, steps) {
+    let prevOp;
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
+        const op = s.op;
+        if (!op) {
+            prevOp = undefined;
+            continue;
         }
-        catch (e) {
-            // внутри транзакции повтор невозможен (aborted) — любая ошибка наружу
-            if (!ctx.inTx && attempt < RETRIES) {
-                if (e.code === '23505')
-                    continue; // новый clock_timestamp сразу
-                if (isTransient(e)) {
-                    await retryDelay(attempt);
-                    continue;
+        const verb = op.kind;
+        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 описывает удалённые — записывать в них нельзя`);
+        switch (op.kind) {
+            case 'create':
+            case 'upsert':
+                if (s.self)
+                    fail('invalid_query', `${verb}() сразу после ${prevOp?.kind}() — между глаголами нужен шаг`);
+                if (s.pivotKey !== undefined)
+                    fail('invalid_query', `${verb}() на возврате к узлу — он ведёт к существующей сущности, используйте update()`);
+                if (s.filter !== undefined && typeof s.filter !== 'string') {
+                    fail('invalid_query', `${verb}() не ищет: ${s.name}(id).${verb}(…) задаёт id, поиск — это update()`);
                 }
+                if (op.kind === 'upsert' && !s.cls.key.length)
+                    fail('no_key', `upsert(): у класса ${s.cls.name} нет ключа — сравнивать не с чем, используйте create()`);
+                checkFullData(s.cls, op.data, verb);
+                if (s.tagsFilter !== undefined && typeof s.tagsFilter !== 'string' && !Array.isArray(s.tagsFilter)) {
+                    fail('invalid_query', `.tags() перед ${verb}() — строка или список`);
+                }
+                break;
+            case 'update':
+                if (!isPlain(op.data))
+                    fail('invalid_data', 'update(): патч — объект');
+                splitPatch(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) {
+                    const t = reg.leafType(s.cls.name, [f]);
+                    if (t !== 'text')
+                        fail('invalid_query', `anonymize() затирает только строковые поля; ${f} — ${t}`);
+                }
+                break;
             }
-            throw e;
+            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':
+                break;
+            case 'rekey':
+                if (!s.cls.key.length)
+                    fail('no_key', `rekey(): у класса ${s.cls.name} нет ключа — id выдаёт база, менять нечего`);
+                checkFullData(s.cls, op.data, 'rekey', false);
+                break;
         }
-    }
-    // END_BLOCK_INSERT_ONE_RETRY
-}
-/**
- * enforceAcl: право операции на класс цели. Предикат победившего правила:
- *  - фильтрует цели UPDATE/DELETE (step.aclFilter → WHERE при поиске);
- *  - колоночные ключи owner/account пришпиливают значения INSERT
- *    (явный чужой модификатор на цепочке → ошибка).
- * Мутирует step (объект создаётся цепочкой на вызов — локально безопасно).
- */
-// START_CONTRACT: aclWrite
-//   PURPOSE: enforceAcl-проверка права записи/удаления на класс цели; предикат правила пришпиливает owner/account и фильтрует цели.
-//   INPUTS: { ctx: Ctx; step: Step; op: 'WRITE'|'DELETE' }
-//   OUTPUTS: { void - мутирует step (aclFilter/ownerFilter/accountFilter) }
-//   SIDE_EFFECTS: мутирует step
-//   ERRORS: acl denies WRITE/DELETE; acl pins writes to owner/account
-//   LINKS: M-WRITE, V-M-WRITE, M-ACL
-// END_CONTRACT: aclWrite
-function aclWrite(ctx, step, op) {
-    if (!ctx.aclDecide)
-        return;
-    const d = ctx.aclDecide(step.cls, op);
-    if (!d.allow)
-        throw aclDenied(op, step.cls.id, d);
-    if (!d.filter)
-        return;
-    step.aclFilter = d.filter;
-    for (const col of ['owner', 'account']) {
-        const v = d.filter[col];
-        if (typeof v !== 'string')
-            continue;
-        const key = col === 'owner' ? 'ownerFilter' : 'accountFilter';
-        if (step[key] && step[key] !== v) {
-            throw new Error(`letopis: acl pins ${step.cls.id} writes to ${col} ${v}`);
+        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()`);
         }
-        step[key] = v;
+        prevOp = op;
     }
 }
-const noFilter = (f) => f === undefined;
-/** Entity.account NOT NULL: модификатор → scope db.as() → System-аккаунт; иначе ошибка. */
-function resolveAccount(ctx, step) {
-    guardScoped(ctx);
-    if (ctx.enforceAccount && ctx.account && step.accountFilter && step.accountFilter !== ctx.account) {
-        throw new Error(`letopis: enforceAccount is on — writes are pinned to account ${ctx.account}`);
-    }
-    const acc = step.accountFilter ?? ctx.account ?? ctx.systemAccount;
-    if (!acc) {
-        throw new Error('letopis: Entity.account is NOT NULL — set .account(…) / db.as(account) or seed a System account (lib/sql/seed.auth.sql)');
-    }
-    return acc;
+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)`;
+async function query(w, text, params) {
+    return (await w.q.unsafe(text, params, { prepare: true }));
 }
-/** Значение тегов из модификатора .tags(): строка/массив; операторы в записи не годятся. */
-function tagsValue(step) {
-    const t = step.tagsFilter;
-    if (t === undefined)
-        return undefined;
-    if (typeof t === 'string')
-        return [t];
-    if (Array.isArray(t))
-        return t;
-    throw new Error('letopis: .tags() before set() accepts string | string[]');
+/** Чтение в транзакции плана — тот же построитель, что у цепочек. */
+export async function readIn(w, steps, mods, mode, agg) {
+    const q = buildRead(w.reg, w.schema, steps, mods, mode, agg);
+    return { q, res: await query(w, q.text, q.params) };
 }
-/** Конец target, принимающий класс cls (legacy: 'Entity'-конец берёт любой HUB). */
-function endFor(target, cls) {
-    return target.links.find((e) => e.classes.includes(cls.id) || (!target.strictEnds && e.classes.includes('Entity') && cls.category === 'HUB'));
+const readRows = async (w, steps, mods) => (await readIn(w, steps, mods, 'rows')).res.map((r) => toRow(r.row));
+const readIds = async (w, steps, mods) => (await readIn(w, steps, mods, 'ids')).res.map((r) => r.id);
+/** Шаг без звена записи — для чтения целей. */
+const bare = (s) => {
+    const { op: _o, opMods: _m, slots: _s, self: _f, ...rest } = s;
+    return rest;
+};
+/** Роли класса owner, которые принимают класс cls. */
+function rolesAccepting(reg, owner, cls) {
+    return Object.entries(owner.ends).filter(([, e]) => accepts(reg, asList(e.class), cls)).map(([r]) => r);
 }
+/** Роль слота: имя роли записываемого класса или класс, который принимает ровно одна роль. */
+export function slotRole(reg, owner, name) {
+    if (owner.ends[name])
+        return name;
+    const c = reg.find(name);
+    if (!c)
+        fail('invalid_class', `класс или роль ${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(', ')} — назовите роль`);
+}
+/** Неоднозначная роль конца из пути. */
+const ambiguous = (step, target, roles) => fail('invalid_query', `конец класса ${target.name} для шага ${step.name} неоднозначен: роли ${roles.join(', ')} — назовите шаг ролью или задайте слот`);
 /**
- * Связи создаваемой сущности из ПУТИ: каждый реальный шаг-предок, чей класс — конец
- * target, обязан дать ровно одну сущность (id-фильтр — как есть; иначе чтение путём
- * от начала до него: контекст честно учитывается).
+ * Роль из нескольких кандидатов: роли, заданные слотами, не участвуют; из оставшихся — роль с именем
+ * класса шага (duty.Member для шага Member, а Backup — слотом). Иначе — неоднозначно.
  */
-// START_CONTRACT: resolvePathEnds
-//   PURPOSE: Связи создаваемой сущности из пути: каждый шаг-предок, чей класс — конец target, должен дать ровно одну сущность.
-//   INPUTS: { ctx: Ctx; steps: Step[] }
-//   OUTPUTS: { Promise<Record<string,string>> - класс конца → id }
-//   SIDE_EFFECTS: чтения контекста (readRows)
-//   ERRORS: context step must resolve to exactly one entity
-//   LINKS: M-WRITE, V-M-WRITE
-// END_CONTRACT: resolvePathEnds
-async function resolvePathEnds(ctx, steps) {
-    const target = steps[steps.length - 1].cls;
+function pickRole(step, target, roles, taken, cls = step.cls.name) {
+    const free = roles.filter((r) => !taken.has(r));
+    if (free.length <= 1)
+        return free;
+    const named = free.filter((r) => r === cls || r === step.name);
+    return named.length === 1 ? named : ambiguous(step, target, free);
+}
+/**
+ * Концы создаваемой строки из пути (resolvePathEnds 0.21, этап 4, п. 4): каждый шаг до глагола,
+ * на класс которого ссылается конец создаваемого класса, даёт ровно одну сущность. Шаг-роль ведёт
+ * своей ролью; шаг, на который создаваемая строка не ссылается (переход вперёд), пропускается;
+ * шаг по базовому классу выбирает роль по классу найденной строки.
+ */
+async function pathEnds(w, steps, taken) {
+    const target = steps[steps.length - 1];
+    const tcls = target.cls;
     const links = {};
     for (let k = 0; k < steps.length - 1; k++) {
-        const step = steps[k];
-        if (step.pivotKey !== undefined || step.op)
+        const s = steps[k];
+        if (s.pivotKey !== undefined || s.op)
             continue;
-        if (!endFor(target, step.cls))
-            continue;
-        let id;
-        if (typeof step.filter === 'string') {
-            id = step.filter;
+        let roles;
+        if (s.role && tcls.ends[s.role]) {
+            roles = [s.role];
         }
         else {
-            const rows = await readRows(ctx, steps.slice(0, k + 1), { limit: 2 });
-            if (rows.length !== 1) {
-                throw new Error(`letopis: context step "${step.name}" must resolve to exactly one entity (got ${rows.length})`);
+            if (k === steps.length - 2 && !target.role) {
+                const hop = resolveHop(w.reg, s, target);
+                if (hop.dir === 'forward')
+                    continue; // предыдущий шаг ссылается на создаваемую — не наоборот
+            }
+            else if (k === steps.length - 2) {
+                continue; // создаётся цель роли предыдущего шага: ссылку ставит не она
+            }
+            roles = pickRole(s, tcls, rolesAccepting(w.reg, tcls, s.cls.name), taken);
+            if (!roles.length) {
+                const fam = stepClasses(w.reg, s);
+                if (!fam.some((c) => rolesAccepting(w.reg, tcls, c).length))
+                    continue;
+                roles = null; // роль решит класс найденной строки
             }
-            id = rows[0].id;
         }
-        links[step.cls.id] = id;
-    }
-    return links;
-}
-/** Резолв слот-значений: строки как есть; вложенные планы — в той же транзакции, ровно одна сущность. */
-// START_CONTRACT: resolveSlots
-//   PURPOSE: Резолв слот-значений (.Класс.set/.unset): строки как есть, вложенные планы — та же транзакция и ровно одна сущность; союз-конец снимается целиком.
-//   INPUTS: { ctx: Ctx; target: ClassDef; extra: Step['extraLinks'] }
-//   OUTPUTS: { Promise<{ vals: Record<string,string>; drops: Set<string> }> }
-//   SIDE_EFFECTS: может исполнять вложенные планы/чтения
-//   ERRORS: slot value plan must resolve to exactly one entity; resolved to class "<x>"
-//   LINKS: M-WRITE, V-M-WRITE
-// END_CONTRACT: resolveSlots
-async function resolveSlots(ctx, target, extra) {
-    const vals = {};
-    const drops = new Set();
-    for (const [clsId, v] of Object.entries(extra ?? {})) {
-        // союз-замещение: слот занимает КОНЕЦ целиком — соседние классы союза снимаются
-        const end = endFor(target, ctx.registry.resolve(clsId));
-        for (const c of end?.classes ?? [clsId])
-            drops.add(c);
-        if (v === null)
-            continue; // .delete() — только снятие
         let id;
-        if (typeof v === 'string') {
-            id = v;
+        if (typeof s.filter === 'string' && roles) {
+            id = s.filter;
         }
         else {
-            const rows = v.plan.some((s) => s.op)
-                ? (await runPlan(ctx, v.plan, v.mods ?? {}, 'rows'))
-                : await readRows(ctx, v.plan, { ...(v.mods ?? {}), limit: 2 });
-            if (rows.length !== 1) {
-                throw new Error(`letopis: slot "${clsId}" value plan must resolve to exactly one entity (got ${rows.length})`);
-            }
-            if (rows[0].class !== clsId) {
-                throw new Error(`letopis: slot "${clsId}" value plan resolved to class "${rows[0].class}"`);
-            }
+            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})`);
             id = rows[0].id;
+            if (!roles) {
+                roles = pickRole(s, tcls, rolesAccepting(w.reg, tcls, rows[0].class), taken, rows[0].class);
+                if (!roles.length)
+                    continue;
+            }
+        }
+        const role = roles[0];
+        if (tcls.ends[role]?.many) {
+            const cur = asList(links[role] ?? []);
+            if (!cur.includes(id))
+                links[role] = [...cur, id];
+        }
+        else {
+            links[role] = id;
         }
-        vals[clsId] = id;
     }
-    return { vals, drops };
+    return links;
 }
-/** id новой сущности по IdGen класса (v5 считается отдельно — нужны концы/данные). */
-const genId = (cls) => (cls.idGen.version === 7 ? uuidv7() : randomUUID());
-/**
- * default поля из правила Schema.attributes: объект-правило `{default: …}` или
- * DSL-строка `'string|default:базовая'`. Нужен v5Id: id считается ДО валидации (та
- * подставляет defaults позже), поэтому необязательное from-поле берёт дефолт здесь.
- */
-function defaultOf(rule) {
-    if (rule && typeof rule === 'object' && !Array.isArray(rule) && 'default' in rule) {
-        return rule.default;
-    }
-    if (typeof rule === 'string') {
-        const seg = rule.split('|').map((s) => s.trim()).find((s) => s.startsWith('default:'));
-        if (seg)
-            return seg.slice('default:'.length);
+/** Значения слотов: строки как есть, цепочки — в той же транзакции. */
+async function slotIds(w, v) {
+    if (v === null)
+        return [];
+    if (typeof v === 'string')
+        return [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);
+        return rows.map((r) => r.id);
     }
-    return undefined;
+    return [v.id];
 }
-/**
- * Детерминированный id (uuid v5): имя = «схема:партиция:класс:значения from».
- * from-источник — конец Schema.links (класс или полное имя союза 'Service|Complex';
- * значение — id присутствующего класса конца) или скалярное поле data (если не задано —
- * его default из Schema.attributes: id стабилен и без явного ввода необязательного поля).
- */
-// START_CONTRACT: v5Id
-//   PURPOSE: Детерминированный id (uuid v5) из «схема:партиция:класс:значения from» (концы Schema.links или скалярные поля/дефолты).
-//   INPUTS: { ctx: Ctx; cls: ClassDef; links: object; data: object }
-//   OUTPUTS: { string - uuid v5 }
-//   SIDE_EFFECTS: none
-//   ERRORS: needs end "<...>"; needs scalar data field "<f>"
-//   LINKS: M-WRITE, V-M-WRITE, M-UUID
-// END_CONTRACT: v5Id
-function v5Id(ctx, cls, links, data) {
-    const parts = [];
-    for (const f of cls.idGen.from) {
-        const end = cls.links.find((e) => e.classes.includes(f) || e.classes.join('|') === f);
-        if (end) {
-            const hit = end.classes.find((c) => c in links);
-            if (!hit) {
-                throw new Error(`letopis: id (uuid v5) of "${cls.id}" needs end "${end.classes.join('|')}" — set it in the path or with a slot`);
-            }
-            parts.push(links[hit]);
+/** Слоты → операции links_patch; для новой строки — применяются к концам из пути. */
+async function resolveSlots(w, cls, slots) {
+    const out = [];
+    for (const sl of 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} сущностей`);
         }
+        out.push({ role: sl.role, op: sl.op, value: sl.op === 'unset' || sl.value === null ? null : end.many ? ids : ids[0] });
+    }
+    return out;
+}
+function applySlotsLocal(links, ops) {
+    const out = { ...links };
+    for (const o of ops) {
+        if (o.op === 'unset' || (o.op === 'set' && o.value === null))
+            delete out[o.role];
+        else if (o.op === 'set')
+            out[o.role] = o.value;
         else {
-            const v = data[f] === undefined ? defaultOf(cls.attributes[f]) : data[f];
-            if (v === undefined || v === null || typeof v === 'object') {
-                throw new Error(`letopis: id (uuid v5) of "${cls.id}" needs scalar data field "${f}"`);
-            }
-            parts.push(String(v));
+            const cur = asList(out[o.role] ?? []).map((x) => x.toLowerCase());
+            const vals = asList(o.value ?? []).map((x) => x.toLowerCase());
+            out[o.role] = o.op === 'add' ? [...cur, ...vals.filter((x) => !cur.includes(x))] : cur.filter((x) => !vals.includes(x));
         }
     }
-    return uuidv5(`${ctx.pgSchema}:${ctx.partition}:${cls.id}:${parts.join(':')}`);
+    return out;
 }
-/** Новая версия каждой строки: deep-merge данных + слоты концов (союз-конец замещается целиком). */
-async function versionRows(ctx, target, found, data, slots) {
-    const cls = target.cls;
-    const out = [];
-    for (const row of found) {
-        const mergedData = deepMerge(row.data, data); // только указанные листья
-        const mergedLinks = { ...row.links };
-        for (const c of slots.drops)
-            delete mergedLinks[c];
-        Object.assign(mergedLinks, slots.vals);
-        const full = validate(cls, row.id, mergedData, mergedLinks);
-        out.push(await insertOne(ctx, {
-            id: row.id, cls, data: full, links: mergedLinks,
-            tags: tagsValue(target) ?? row.tags, account: row.account, owner: row.owner,
-            prevUpdated: row.updated, deleted: null,
-        }));
+const tagsValue = (s) => s.tagsFilter === undefined ? null : typeof s.tagsFilter === 'string' ? [s.tagsFilter] : s.tagsFilter;
+/** «Уже существует»: id вычисляет библиотека (idOf), а не разбирает текст ошибки сервера (§2.5). */
+function existsError(w, cls, data, links, given, cause) {
+    let id = given;
+    if (!id && cls.key.length && w.tenant) {
+        try {
+            id = idOf({ name: cls.name, key: cls.key, ends: Object.keys(cls.ends) }, { ...data, ...links }, { tenant: w.tenant });
+        }
+        catch {
+            id = undefined;
+        }
+    }
+    return Object.assign(new LetopisError('exists', `объект класса ${cls.name} уже существует${id ? ` (id ${id})` : ''}`, { id: id ?? null }), { cause });
+}
+const isPkConflict = (e) => {
+    const err = e;
+    return err.code === '23505' && err.constraint_name === 'entity_pkey';
+};
+async function createOp(w, steps, opStep, upsert) {
+    const op = opStep.op;
+    const cls = opStep.cls;
+    const S = quoteId(w.schema);
+    const slots = await resolveSlots(w, cls, opStep.slots);
+    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;
+    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]);
+        return res.map((r) => {
+            const row = toRow(r.row);
+            if (upsert)
+                row.$upsert = r.old_rev === null ? 'created' : r.old_rev === row.rev ? 'unchanged' : 'updated';
+            return row;
+        });
+    }
+    catch (e) {
+        if (!upsert && isPkConflict(e))
+            throw existsError(w, cls, op.data, links, given, e);
+        throw e;
     }
-    return out;
 }
 /**
- * .create(data) — «чтобы сущность существовала»:
- *  - id не задан → INSERT (id по IdGen класса; links = концы из пути + слоты);
- *  - id известен (Класс(id) / data.id / вычислен v5): есть → новая версия (deep-merge),
- *    нет → INSERT с этим id (идемпотентный create, REST-PUT семантика);
- *  - фильтр-объект / pivot — ошибка: create не ищет, это update().
+ * Меньше затронутых строк, чем нашёл шаг (§2.5): невидимые — target_not_found; видимые с другим
+ * номером версии в строгом режиме — conflict; остальные видимые — их не дала изменить RLS (acl_denied).
  */
-// START_CONTRACT: createOp
-//   PURPOSE: .create(data) — INSERT новой сущности либо новая версия при известном/вычисленном id (идемпотентный create); поиск — это update().
-//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; data: object }
-//   OUTPUTS: { Promise<Row[]> }
-//   SIDE_EFFECTS: INSERT в Entity (в транзакции runPlan)
-//   ERRORS: create() on a pivot; takes no filter; got two ids; computes id (remove explicit); acl denies WRITE
-//   LINKS: M-WRITE, V-M-WRITE, M-ACL
-// END_CONTRACT: createOp
-export async function createOp(ctx, steps, mods, data) {
-    // START_BLOCK_CREATE_RESOLVE
-    const target = steps[steps.length - 1];
-    const cls = target.cls;
-    aclWrite(ctx, target, 'WRITE');
-    if (target.pivotKey !== undefined) {
-        throw new Error(`letopis: create() on a pivot step — pivot returns to an existing node, use update()`);
+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 (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 filterId = typeof target.filter === 'string' ? target.filter : undefined;
-    if (!noFilter(target.filter) && filterId === undefined) {
-        throw new Error(`letopis: create() takes no filter — ${cls.alias}(id).create(…) fixes the id, searching is update()`);
+    return fail('acl_denied', `строки видны, но изменить их нельзя: ${seen.map((r) => r.id).join(', ')}`, { ids: seen.map((r) => r.id) });
+}
+/** Цели 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 ?? {});
+}
+async function updateOp(w, steps, opStep) {
+    const op = opStep.op;
+    const S = quoteId(w.schema);
+    // 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);
+    if (op.rev !== undefined) {
+        if (ids.length > 1)
+            fail('rev_ambiguous', `update(patch, { rev }): у шага ${opStep.name} ${ids.length} целей — строгий режим только для одной`);
+        if (!ids.length)
+            fail('target_not_found', `update(patch, { rev }): у шага ${opStep.name} нет цели`);
     }
-    // слоты (.Класс.set/.unset): значения/снятия концов; союз-конец замещается целиком
-    const slots = await resolveSlots(ctx, cls, target.extraLinks);
-    const dataId = typeof data.id === 'string' ? data.id : undefined;
-    if (filterId && dataId && filterId !== dataId) {
-        throw new Error(`letopis: create() got two ids — step "${filterId}" vs data.id "${dataId}"`);
+    if (!ids.length)
+        return [];
+    const { rest, incs } = splitPatch(useDataId ? data : op.data);
+    const params = [ids];
+    const ph = (v, cast) => `$${params.push(v)}::${cast}`;
+    let expr = `${S}.merge(e.data, ${ph(rest, 'jsonb')})`;
+    for (const i of incs)
+        expr = `${S}.inc(${expr}, ${ph(i.path, 'text[]')}, ${ph(i.by, 'numeric')}, ${ph(i.start ?? null, 'numeric')})`;
+    const sets = [`data = ${expr}`];
+    const slots = await resolveSlots(w, opStep.cls, opStep.slots);
+    if (slots.length)
+        sets.push(`links = ${S}.links_patch(e.links, ${ph(slots, 'jsonb')})`);
+    const tags = tagsValue(opStep);
+    if (tags)
+        sets.push(`tags = ${ph(tags, 'text[]')}`);
+    const revCond = op.rev !== undefined ? ` and e.rev = ${ph(op.rev, 'int')}` : '';
+    const res = await query(w, `update ${S}.entity e set ${sets.join(', ')} where e.id = any ($1::uuid[])${revCond} returning ${rowJson('new')} as row`, params);
+    if (res.length < ids.length) {
+        const got = new Set(res.map((r) => r.row.id));
+        await explainMissing(w, ids.filter((x) => !got.has(x)), op.rev);
     }
-    let explicitId = filterId ?? dataId;
-    // связи создаваемого: концы из пути + слоты (слоты выигрывают, unset снимает)
-    const pathEnds = await resolvePathEnds(ctx, steps);
-    const writeLinks = { ...pathEnds };
-    for (const c of slots.drops)
-        delete writeLinks[c];
-    Object.assign(writeLinks, slots.vals);
-    if (cls.idGen.version === 5) {
-        if (explicitId) {
-            throw new Error(`letopis: class "${cls.id}" computes id (uuid v5 from ${cls.idGen.from.join(', ')}) — remove the explicit id`);
-        }
-        explicitId = v5Id(ctx, cls, writeLinks, data);
+    return res.map((r) => toRow(r.row));
+}
+async function deleteOp(w, steps, opStep) {
+    const op = opStep.op;
+    const S = quoteId(w.schema);
+    const ids = await targetIds(w, steps, opStep);
+    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;
+        });
     }
-    if (explicitId !== undefined) {
-        // id известен и существует (в границах пути) → новая версия
-        const pathSteps = [...steps.slice(0, -1), { ...target, filter: explicitId }];
-        const found = await readRows(ctx, pathSteps, mods);
-        if (found.length)
-            return versionRows(ctx, target, found, data, slots);
-        // enforceAcl-предикат: «не нашёл среди доступных» НЕ значит «можно создать» —
-        // существующая, но недоступная сущность иначе перехватывалась бы новой версией
-        // с чужим owner. Проверка существования — БЕЗ предиката и пришпиленных колонок.
-        if (target.aclFilter) {
-            const bare = { ...ctx, aclDecide: undefined };
-            const probe = {
-                ...target,
-                filter: explicitId,
-                aclFilter: undefined,
-                ownerFilter: undefined,
-                accountFilter: undefined,
-                linksFilter: undefined,
-            };
-            const taken = await readRows(bare, [probe], {});
-            if (taken.length)
-                return [];
-        }
+    // результат — надгробия этой транзакции после метки: 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]);
+    if (gone.length < ids.length) {
+        const got = new Set(gone.map((r) => r.row.id));
+        await explainMissing(w, ids.filter((x) => !got.has(x)));
+    }
+    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
+    const have = new Set(out.map((r) => r.id));
+    for (const g of gone) {
+        if (have.has(g.row.id))
+            continue;
+        const row = toRow(g.row);
+        row.$deleted = true;
+        out.push(row);
     }
-    const id = explicitId ?? genId(cls);
-    const account = resolveAccount(ctx, target);
-    const owner = target.ownerFilter ?? ctx.owner ?? account;
-    const full = validate(cls, id, data, writeLinks);
-    return [
-        await insertOne(ctx, {
-            id, cls, data: full, links: writeLinks,
-            tags: tagsValue(target) ?? [], account, owner, prevUpdated: null, deleted: null,
-        }),
-    ];
-    // END_BLOCK_CREATE_RESOLVE
+    return out;
 }
-/**
- * .update(data?) — новая версия КАЖДОГО найденного путём (deep-merge листьев);
- * цели: Класс() ≡ Класс({}) — все в границах контекста, id/фильтр/pivot — как в чтении.
- * Не найдено → [] — update НИКОГДА не создаёт.
- */
-// START_CONTRACT: updateOp
-//   PURPOSE: .update(data?) — новая версия каждого найденного путём (deep-merge листьев); никогда не создаёт.
-//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; data: object }
-//   OUTPUTS: { Promise<Row[]> }
-//   SIDE_EFFECTS: INSERT новых версий
-//   LINKS: M-WRITE, V-M-WRITE
-// END_CONTRACT: updateOp
-export async function updateOp(ctx, steps, mods, data) {
-    const target = steps[steps.length - 1];
-    aclWrite(ctx, target, 'WRITE');
-    const slots = await resolveSlots(ctx, target.cls, target.extraLinks);
-    // data.id — цель, только если у шага нет своего фильтра
-    const dataId = typeof data.id === 'string' ? data.id : undefined;
-    const pathSteps = noFilter(target.filter) && dataId !== undefined
-        ? [...steps.slice(0, -1), { ...target, filter: dataId }]
-        : steps;
-    const found = await readRows(ctx, pathSteps, mods); // честный путь: переходы, pivot
-    return versionRows(ctx, target, found, data, slots);
+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)
+        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 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)]);
+    return 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) });
+    return dead;
+}
+/** Восстановление (этап 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[]) order by e.id`, [ids]);
+    return res.map((r) => toRow(r.row));
 }
 /**
- * .anonymize(fields): GDPR-затирание — новая версия с '[erased]' в указанных string-полях
- * + тег 'anonymized'. Только string-поля (по Schema); история сохраняется (см. README).
+ * Стирание истории удалённых (этап 6, п. 3): без { confirm: true } — превью (надгробия и число
+ * версий $versions), с ним — версии стёрты, на месте версии 1 — запись purge ($purged).
  */
-export async function anonymizeOp(ctx, steps, mods, fields) {
-    const target = steps[steps.length - 1];
-    const cls = target.cls;
-    aclWrite(ctx, target, 'WRITE');
-    for (const f of fields) {
-        if (cls.fieldTypes.get(f)?.kind !== 'string') {
-            throw new Error(`letopis: anonymize() erases string fields only; "${f}" is ${cls.fieldTypes.get(f)?.kind ?? 'unknown'}`);
-        }
-    }
-    const found = await readRows(ctx, steps, mods); // цели — честный путь
+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 found) {
-        const patch = Object.fromEntries(fields.filter((f) => f in row.data).map((f) => [f, '[erased]']));
-        const mergedData = deepMerge(row.data, patch);
-        const full = validate(cls, row.id, mergedData, row.links);
-        out.push(await insertOne(ctx, {
-            id: row.id, cls, data: full, links: row.links,
-            tags: [...new Set([...row.tags, 'anonymized'])],
-            account: row.account, owner: row.owner, prevUpdated: row.updated, deleted: null,
-        }));
+    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 } : {}) });
     }
     return out;
 }
-/** Транзакционная обёртка: в tr исполняем как есть, вне — sql.begin с ретраем transient
- *  (deadlock/serialization откатывает ВСЮ внутреннюю транзакцию — повтор честен). */
-async function inTransaction(ctx, fn) {
-    if (ctx.inTx)
-        return fn(ctx);
-    // START_BLOCK_IN_TRANSACTION_RETRY
-    for (let attempt = 1;; attempt++) {
+/** Новое значение ключа (этап 6, п. 7): строка с новым id, ссылки переведены, журнал связывает id. */
+async function rekeyOp(w, steps, opStep) {
+    const op = opStep.op;
+    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) {
         try {
-            return (await ctx.sql.begin(async (tsql) => fn({ ...ctx, sql: tsql, inTx: true })));
+            const [{ id: nid }] = await query(w, `select ${S}.rekey($1::uuid, $2::jsonb, $3::jsonb) as id`, [id, data, links]);
+            moved.push(nid);
         }
         catch (e) {
-            if (isTransient(e) && attempt < RETRIES) {
-                await retryDelay(attempt);
-                continue;
-            }
+            if (isPkConflict(e))
+                throw Object.assign(new LetopisError('exists', `rekey(): объект класса ${opStep.cls.name} с таким ключом уже существует`, { id }), { cause: e });
             throw e;
         }
     }
-    // END_BLOCK_IN_TRANSACTION_RETRY
-}
-/**
- * .delete({confirm}): цели = фильтр последнего шага + контекст-связи.
- * confirm: true — серверное удаление (триггер entity_delete: tombstone + рекурсивный
- * каскад + advisory-lock); возвращает ВСЁ удалённое (цели + каскад) с $deleted: true.
- * Без confirm — ПРЕВЬЮ: то же замыкание (цели + каскад), но БД не трогается.
- */
-// START_CONTRACT: delOp
-//   PURPOSE: .delete({confirm}) — серверное удаление (tombstone + рекурсивный каскад) при confirm, иначе превью замыкания; DELETE-право на каждый класс каскада.
-//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; confirm: boolean }
-//   OUTPUTS: { Promise<Row[]> - удалённые (цели+каскад) с $deleted, либо превью }
-//   SIDE_EFFECTS: DELETE в Entity (триггер entity_delete) при confirm
-//   ERRORS: acl denies DELETE (в каскаде)
-//   LINKS: M-WRITE, V-M-WRITE, M-ACL, M-DDL
-// END_CONTRACT: delOp
-export async function delOp(ctx, steps, mods, confirm) {
-    const target = steps[steps.length - 1];
-    aclWrite(ctx, target, 'DELETE');
-    const targets = await readRows(ctx, steps, mods); // цели — честный путь
-    if (!targets.length)
-        return [];
-    const params = [ctx.partition, target.cls.id, ...targets.map((r) => r.id)];
-    // START_BLOCK_DELETE_CASCADE
-    return inTransaction(ctx, async (c) => {
-        const closure = await runQuery(c, closureSql(c.pgSchema, targets.length), params, 'delete', [target.cls.id]);
-        if (!confirm)
-            return closure.map((r) => toRow(r)); // превью: кандидаты живы, БД не тронута
-        // каскад дотянется до зависимых ЛЮБЫХ классов — на каждый нужно DELETE-право
-        if (c.aclDecide) {
-            for (const cn of new Set(closure.map((r) => r.class))) {
-                const d = c.aclDecide(c.registry.resolve(cn), 'DELETE');
-                if (!d.allow)
-                    throw aclDenied('DELETE', `${cn} (в каскаде от ${target.cls.id})`, d);
-            }
-        }
-        await runQuery(c, deleteSql(c.pgSchema, targets.length), params, 'delete', [target.cls.id]);
-        return closure.map((r) => ({ ...toRow(r), $deleted: true }));
-    });
-    // END_BLOCK_DELETE_CASCADE
+    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));
 }
-/**
- * .purge({confirm}): ФИЗИЧЕСКИЙ hard-erase — сносит логически удалённые цели + всё поддерево (все версии).
- * Вся логика — в серверной purge() (двухфазность: живую цель не трогает; замыкание по links; SET LOCAL
- * отключает entity_delete → плоский снос без TM_SelfModified). JS лишь резолвит цели и зовёт функцию.
- * confirm: false → dry-превью (что сотрётся, БД цела); true → снос, возвращает снесённое ($deleted).
- * gate: DELETE-право на класс цели (aclWrite) — поддерево уже было DELETE-авторизовано при мягком удалении.
- * В отличие от .delete() (tombstone, обратимо) — необратимо, историю НЕ сохраняет.
- */
-// START_CONTRACT: purgeOp
-//   PURPOSE: .purge({confirm}) — резолв целей (вкл. tombstone) + вызов серверной purge() (снос при confirm, иначе dry-превью).
-//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; confirm: boolean }
-//   OUTPUTS: { Promise<Row[]> - снесённое с $deleted, либо dry-превью; [] если цели не tombstone/не найдены }
-//   SIDE_EFFECTS: физический DELETE в Entity через purge() (SET LOCAL letopis.purge отключает триггер)
-//   ERRORS: acl denies DELETE (класс цели)
-//   LINKS: M-WRITE, V-M-WRITE, M-ACL, M-DDL, M-SQL
-// END_CONTRACT: purgeOp
-export async function purgeOp(ctx, steps, mods, confirm) {
-    const target = steps[steps.length - 1];
-    aclWrite(ctx, target, 'DELETE');
-    // цели ищем ВКЛЮЧАЯ tombstone — .purge() работает по уже логически удалённым (двухфазность в purge())
-    const targets = await readRows(ctx, steps, { ...mods, withDeleted: true });
-    if (!targets.length)
-        return [];
-    return inTransaction(ctx, async (c) => {
-        const out = [];
-        // вся логика (двухфазность, замыкание, отключение триггера) — в серверной purge(); dry = !confirm
-        for (const t of targets) {
-            const rows = await runQuery(c, purgeCallSql(c.pgSchema), [c.partition, target.cls.id, t.id, !confirm], 'delete', [target.cls.id]);
-            for (const r of rows)
-                out.push(confirm ? { ...toRow(r), $deleted: true } : toRow(r));
-        }
-        return out;
-    });
+function opCall(w, steps, opStep) {
+    switch (opStep.op.kind) {
+        case 'create': return createOp(w, steps, opStep, false);
+        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);
+    }
 }
-/** Разрезать план: сегменты (…шаги + op-шаг) и читающий хвост после последней операции. */
-function splitPlan(steps) {
+/** Разрезать план: сегменты (…шаги + шаг с глаголом) и читающий хвост после последнего глагола. */
+export function splitPlan(steps) {
     const segments = [];
     let buf = [];
     for (const s of steps) {
         buf.push(s);
         if (s.op) {
-            segments.push({ steps: buf, op: s.op });
+            segments.push({ steps: buf });
             buf = [];
         }
     }
     return { segments, tail: buf };
 }
-function opCall(c, steps, op) {
-    switch (op.kind) {
-        case 'create':
-            return createOp(c, steps, op.mods, op.data ?? {});
-        case 'update':
-            return updateOp(c, steps, op.mods, op.data ?? {});
-        case 'anonymize':
-            return anonymizeOp(c, steps, op.mods, op.fields ?? []);
-        case 'delete':
-            return delOp(c, steps, op.mods, op.confirm === true);
-        case 'purge':
-            return purgeOp(c, steps, op.mods, op.confirm === true);
-    }
-}
-/** Виртуальный старт-шаг «от этих строк»: контекст/чтение следующего сегмента. */
-const virtualStep = (c, row) => ({ name: row.class, cls: c.registry.resolve(row.class), filter: row.id });
-const RawRowFmt = {
-    rows: (res) => res.map((r) => {
-        const row = toRow(r.row);
-        return r.row.depth != null ? { ...row, $depth: r.row.depth } : row;
-    }),
-    paths: (res) => res.map((r) => Object.fromEntries(Object.entries(r.path).map(([k, v]) => [k, toRow(v)]))),
-    versions: (res) => res.map((r) => (r.row.deleted ? { ...toRow(r.row), $deleted: true } : toRow(r.row))),
-};
+/** Старт следующего сегмента «от этих строк»: шаг с их id (класс и роль — как у шага глагола). */
+const fromRows = (opStep, ids, cls) => ({
+    name: opStep.name, cls: cls ?? opStep.cls, role: cls ? undefined : opStep.role, aliasKey: opStep.aliasKey,
+    filter: ids, nodeKey: nextNodeKey(),
+});
 /**
- * Исполнить план целиком: все операции + финальное чтение — одна транзакция
- * (внутренняя, с ретраем transient; внутри db.begin() — транзакция пользователя).
- * Продолжение после операции: fan-out — каждый следующий сегмент исполняется от каждой
- * строки результата (контекст = строка); self-шаг (op сразу после op) пишет в те же строки.
- * После delete продолжение идёт от строк КЛАССА ЦЕЛИ (замыкание каскада шире).
+ * Исполнить план в транзакции w.q: сегменты по порядку, продолжение — от результата предыдущего
+ * глагола (create и upsert — по строке, остальные — от всех строк сразу); хвост — чтение от
+ * результата последнего глагола тем же построителем, что у цепочек.
  */
-// START_CONTRACT: runPlan
-//   PURPOSE: Исполнить план целиком (сегменты операций + читающий хвост) одной транзакцией; продолжение = fan-out по строкам результата.
-//   INPUTS: { ctx: Ctx; steps: Step[]; mods: ChainMods; mode: PlanMode }
-//   OUTPUTS: { Promise<unknown> - результат в запрошенном режиме }
-//   SIDE_EFFECTS: записи + чтения в одной транзакции
-//   LINKS: M-WRITE, V-M-WRITE, M-SQL
-// END_CONTRACT: runPlan
-export async function runPlan(ctx, steps, mods, mode) {
+export async function execPlan(w, steps, mods, mode, agg) {
     const { segments, tail } = splitPlan(steps);
-    return inTransaction(ctx, async (c) => {
-        // START_BLOCK_RUNPLAN_SEGMENTS
-        let last = []; // полный результат последней операции (для терминала)
-        let start = []; // строки для продолжения (класс цели)
-        for (let i = 0; i < segments.length; i++) {
-            const seg = segments[i];
-            const targetCls = seg.steps[seg.steps.length - 1].cls;
-            if (i === 0) {
-                last = await opCall(c, seg.steps, seg.op);
-            }
-            else {
-                last = [];
-                for (const row of start) {
-                    const rowSteps = seg.steps[0].self
-                        ? [{ ...seg.steps[0], self: undefined, filter: row.id, op: undefined }]
-                        : [virtualStep(c, row), ...seg.steps.map((s) => ({ ...s, op: undefined }))];
-                    last.push(...await opCall(c, rowSteps, seg.op));
-                }
-            }
-            start = (seg.op.kind === 'delete' || seg.op.kind === 'purge')
-                ? last.filter((r) => r.class === targetCls.id) : last;
+    let last = [];
+    let start = [];
+    let prevOp;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const opStep = seg.steps[seg.steps.length - 1];
+        const kind = opStep.op.kind;
+        const perRow = kind === 'create' || kind === 'upsert';
+        if (i === 0) {
+            last = await opCall(w, seg.steps, opStep);
+        }
+        else if (!start.length) {
+            last = [];
         }
-        // END_BLOCK_RUNPLAN_SEGMENTS
-        const opStep = segments[segments.length - 1].steps.at(-1);
-        const keyName = opStep.aliasKey ?? opStep.name;
-        // хвост-чтение от результата последней операции (в той же транзакции)
-        if (tail.length) {
-            if (!start.length)
-                return emptyFor(mode, mods);
-            const virt = { name: keyName, cls: opStep.cls, filter: start.map((r) => r.id) };
-            return readByMode(c, [virt, ...tail], mods, mode);
+        else if (opStep.self) {
+            // те же сущности: шаг глагола с их id вместо фильтра (create и upsert так не продолжаются — precheckPlan)
+            const same = { ...opStep, filter: start.map((r) => r.id), pivotKey: undefined, nodeKey: nextNodeKey() };
+            last = await opCall(w, [same], same);
         }
-        // терминал прямо на операции
-        switch (mode) {
-            case 'rows':
-                return last;
-            case 'ids':
-                return last.map((r) => r.id);
-            case 'count':
-                return last.length;
-            case 'paths':
-                return last.map((r) => ({ [keyName]: r }));
-            case 'versions':
-            case 'agg': {
-                if (!start.length)
-                    return emptyFor(mode, mods);
-                const virt = { name: keyName, cls: opStep.cls, filter: start.map((r) => r.id) };
-                return readByMode(c, [virt], mods, mode);
+        else if (perRow) {
+            last = [];
+            for (const r of start) {
+                const rowSteps = [fromRows(prevOp, r.id, w.reg.resolve(r.class)), ...seg.steps];
+                last.push(...await opCall(w, rowSteps, opStep));
             }
         }
-    });
-}
-function emptyFor(mode, mods) {
-    switch (mode) {
-        case 'rows':
-        case 'versions':
-        case 'paths':
-        case 'ids':
-            return [];
-        case 'count':
-            return 0;
-        case 'agg':
-            return mods.aggFn === 'countBy' ? [] : [{ v: null }];
+        else {
+            last = await opCall(w, [fromRows(prevOp, start.map((r) => r.id)), ...seg.steps], opStep);
+        }
+        // после удаления продолжение — от удалённых строк класса цели (замыкание каскада шире); после
+        // стирания истории продолжать не от чего
+        start = kind === 'delete' && opStep.op.confirm
+            ? last.filter((r) => stepClasses(w.reg, opStep).includes(r.class))
+            : kind === 'purge' ? [] : last;
+        prevOp = opStep;
+    }
+    const opStep = segments[segments.length - 1].steps.at(-1);
+    const key = opStep.aliasKey ?? opStep.name;
+    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);
+        return { kind: 'read', q, res };
     }
+    return { kind: 'rows', rows: last, key };
 }
-/** Финальное чтение плана: тот же buildRead, что у обычных цепочек. */
-async function readByMode(c, steps, mods, mode) {
-    const classes = steps.map((s) => s.cls.id);
-    switch (mode) {
-        case 'rows': {
-            const q = buildRead(c, steps, mods, 'rows');
-            return RawRowFmt.rows(await runQuery(c, q.text, q.params, 'rows', classes));
-        }
-        case 'paths': {
-            const q = buildRead(c, steps, mods, 'paths');
-            return RawRowFmt.paths(await runQuery(c, q.text, q.params, 'paths', classes));
-        }
-        case 'versions': {
-            const q = buildRead(c, steps, mods, 'versions');
-            return RawRowFmt.versions(await runQuery(c, q.text, q.params, 'versions', classes));
+// ---------------------------------------------------------------------------
+// Батч (этап 4, п. 8): очередь планов одной транзакцией
+// ---------------------------------------------------------------------------
+/** Простая вставка: один шаг с create или upsert, без id, слотов и концов из пути. */
+function pureKind(plan) {
+    if (plan.length !== 1)
+        return null;
+    const s = plan[0];
+    const kind = s.op?.kind;
+    if ((kind !== 'create' && kind !== 'upsert') || s.filter !== undefined || s.slots?.length || s.pivotKey !== undefined)
+        return null;
+    const props = (s.cls.schema.properties ?? {});
+    // ключ только из полей данных: id сопоставляется со входом без концов
+    if (s.cls.key.length && s.cls.key.every((k) => k in props))
+        return 'keyed';
+    return kind === 'create' && !s.cls.key.length ? 'keyless' : null;
+}
+/**
+ * Очередь планов одной транзакцией. Подряд идущие простые вставки одного класса с ключом — одна
+ * многострочная вставка, подряд идущие upsert — тоже (повтор id режет группу: один оператор не
+ * меняет строку дважды); результат сопоставляется со входом по вычисленному id. Вставки класса без
+ * ключа уходят однострочными операторами одним конвейером: порядок строк в returning
+ * многострочной вставки не гарантирован, сопоставить не по чему.
+ */
+export async function execBatch(w, plans) {
+    const out = new Array(plans.length);
+    const S = quoteId(w.schema);
+    const idFor = (s) => {
+        if (!w.tenant)
+            return null;
+        try {
+            return idOf({ name: s.cls.name, key: s.cls.key, ends: [] }, s.op.data, { tenant: w.tenant });
         }
-        case 'ids': {
-            const q = buildRead(c, steps, mods, 'ids');
-            return (await runQuery(c, q.text, q.params, 'ids', classes)).map((r) => r.id);
+        catch {
+            return null;
         }
-        case 'count': {
-            const q = buildRead(c, steps, mods, 'count');
-            return (await runQuery(c, q.text, q.params, 'count', classes))[0].n;
+    };
+    let i = 0;
+    while (i < plans.length) {
+        const kind = pureKind(plans[i]);
+        const head = plans[i][0];
+        if (kind === 'keyed' && idFor(head)) {
+            const verb = head.op.kind;
+            const group = [];
+            const seen = new Set();
+            let j = i;
+            while (j < plans.length && pureKind(plans[j]) === 'keyed' && plans[j][0].op.kind === verb && plans[j][0].cls.name === head.cls.name) {
+                const s = plans[j][0];
+                const id = idFor(s);
+                if (!id || (verb === 'upsert' && seen.has(id)))
+                    break;
+                seen.add(id);
+                group.push({ at: j, s, id });
+                j++;
+            }
+            const input = group.map((g) => ({ d: g.s.op.data, t: tagsValue(g.s), o: g.s.ownerFilter ?? w.owner ?? null }));
+            const conflict = verb === 'upsert'
+                ? '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]);
+            const byId = new Map(res.map((r) => [r.row.id, r]));
+            for (const g of group) {
+                const r = byId.get(g.id);
+                // create: занятый ключ (или повтор в батче) — строка не вставлена
+                if (!r)
+                    throw existsError(w, g.s.cls, g.s.op.data, {}, g.id, null);
+                const row = toRow(r.row);
+                if (verb === 'upsert')
+                    row.$upsert = r.old_rev === null ? 'created' : r.old_rev === row.rev ? 'unchanged' : 'updated';
+                out[g.at] = [row];
+            }
+            i = j;
         }
-        case 'agg': {
-            const q = buildRead(c, steps, mods, 'agg');
-            return runQuery(c, q.text, q.params, 'agg', classes);
+        else if (kind === 'keyless') {
+            let j = i;
+            while (j < plans.length && pureKind(plans[j]) === 'keyless')
+                j++;
+            // однострочные вставки без ожидания ответа каждой — postgres.js шлёт их конвейером
+            const rows = await Promise.all(plans.slice(i, j).map((p) => createOp(w, p, p[0], false)));
+            rows.forEach((r, k) => (out[i + k] = r));
+            i = j;
         }
-    }
-}
-const isPureInsertPlan = (p) => p.steps.length === 1 &&
-    p.steps[0].op?.kind === 'create' &&
-    noFilter(p.steps[0].filter) &&
-    typeof p.steps[0].op.data?.id !== 'string' &&
-    !Object.keys(p.steps[0].extraLinks ?? {}).length &&
-    p.steps[0].cls.idGen.version !== 5;
-// START_CONTRACT: executeBatch
-//   PURPOSE: Исполнить очередь планов одной транзакцией; подряд идущие чистые INSERT одного класса склеиваются в multi-VALUES.
-//   INPUTS: { ctx: Ctx; queue: BatchPlan[] }
-//   OUTPUTS: { Promise<Row[][]> - результат по каждому плану }
-//   SIDE_EFFECTS: INSERT (multi/по-плану) в транзакции
-//   LINKS: M-WRITE, V-M-WRITE, M-SQL
-// END_CONTRACT: executeBatch
-export async function executeBatch(ctx, queue) {
-    if (!queue.length)
-        return [];
-    return inTransaction(ctx, async (c) => {
-        const results = new Array(queue.length);
-        let i = 0;
-        while (i < queue.length) {
-            // START_BLOCK_BATCH_FASTPATH
-            if (isPureInsertPlan(queue[i])) {
-                const cls = queue[i].steps[0].cls;
-                let j = i;
-                while (j < queue.length && isPureInsertPlan(queue[j]) && queue[j].steps[0].cls.id === cls.id)
-                    j++;
-                const group = queue.slice(i, j);
-                const params = [];
-                for (const g of group) {
-                    const s = { ...g.steps[0] };
-                    aclWrite(c, s, 'WRITE'); // склейка multi-VALUES идёт мимо createOp — право+пришпиливание на каждый
-                    const id = genId(cls);
-                    const full = validate(cls, id, s.op?.data ?? {}, {});
-                    const account = resolveAccount(c, s);
-                    params.push(c.partition, id, cls.id, full, {}, tagsValue(s) ?? [], account, s.ownerFilter ?? c.owner ?? account);
-                }
-                const res = await runQuery(c, multiInsertSql(c.pgSchema, group.length), params, 'insert', [cls.id]);
-                for (let k = 0; k < group.length; k++)
-                    results[i + k] = [toRow(res[k])];
-                i = j;
-                continue;
-            }
-            // END_BLOCK_BATCH_FASTPATH
-            results[i] = (await runPlan(c, queue[i].steps, {}, 'rows'));
+        else {
+            const r = await execPlan(w, plans[i], {}, 'rows');
+            out[i] = r.kind === 'rows' ? r.rows : r.res.map((x) => toRow(x.row));
             i++;
         }
-        return results;
-    });
+    }
+    return out;
 }