letopis 0.5.0 → 0.16.0

package/dist/write.js

@@ -1,17 +1,23 @@
 /**
- * Запись: терминалы .set(data) / .delete() на цепочке + исполнение батчей.
+ * Запись: операции .create(data) / .update(data) / .delete(opts) / .anonymize(fields) —
+ * ЗВЕНЬЯ цепочки; терминал (rows/first/ids/count/run/versions/агрегации) исполняет весь
+ * план ОДНОЙ транзакцией (runPlan) — любой отказ (валидация/ACL) откатывает всё.
  *
- * Связи задаются dot-цепочкой: НЕ-последние шаги (контекст) резолвятся в ровно одну
+ * Связи задаются dot-цепочкой: шаги до операции (контекст) резолвятся в ровно одну
  * сущность каждый и дают:
- *   - containment-фильтр целей при UPDATE/DELETE (links ⊇ {Класс: id}),
- *   - links создаваемой строки при INSERT.
+ *   - containment-фильтр целей при update/delete (links ⊇ {Класс: id}),
+ *   - links создаваемой строки при create.
  *
- *   db.Организация(org).Сотрудник().set({ name: 'Вася' })          // INSERT + links {Org}
- *   tr.Сотрудник(s).Окно(w).Запись(b).занятость().set({ id, kind }) // UPSERT по data.id
- *   db.Клиент(c).Запись({ status: 'created' }).set({ status: 'confirmed' }) // UPDATE найденных
+ *   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 по записанным строкам).
  */
 import { randomUUID } from 'node:crypto';
-import { buildRead, runQuery, insertSql, multiInsertSql, deleteSql, closureSql } from './sql.js';
+import { uuidv5, uuidv7 } from './uuid.js';
+import { buildRead, runQuery, insertSql, multiInsertSql, deleteSql, closureSql, isTransient, retryDelay, RETRIES, } from './sql.js';
+import { aclDenied } from './acl.js';
 export class ValidationError extends Error {
     issues;
     constructor(cls, issues) {
@@ -63,23 +69,41 @@ function validate(cls, id, data, links) {
         throw new ValidationError(cls.id, res);
     delete merged.id;
     if (cls.category === 'LINK') {
-        let polymorphic = 0;
         const present = new Set(Object.keys(links));
-        for (const end of cls.links) {
-            if (end === 'Entity')
-                polymorphic++;
-            else if (present.has(end))
-                present.delete(end);
-            else
-                throw new Error(`letopis: link "${cls.id}" requires end "${end}"`);
+        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('|')}"`);
+            }
+            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`);
+            }
         }
-        if (present.size < polymorphic) {
-            throw new Error(`letopis: link "${cls.id}" requires ${polymorphic} polymorphic end(s) (any class), got ${present.size}`);
+        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}"`);
+            }
+            if (present.size < polymorphic) {
+                throw new Error(`letopis: link "${cls.id}" requires ${polymorphic} polymorphic end(s) (any class), got ${present.size}`);
+            }
         }
     }
     return merged;
 }
-/** INSERT одной строки с ретраем коллизии PK по updated (23505). */
+/** INSERT одной строки с ретраем гонок: 23505 (коллизия updated) и transient (40P01/40001). */
 async function insertOne(ctx, a) {
     // jsonb-параметры — JS-объектами (postgres.js сериализует сам)
     const params = [
@@ -92,17 +116,46 @@ async function insertOne(ctx, a) {
             return toRow(res[0]);
         }
         catch (e) {
-            if (e.code === '23505' && attempt < 3)
-                continue;
+            // внутри транзакции повтор невозможен (aborted) — любая ошибка наружу
+            if (!ctx.inTx && attempt < RETRIES) {
+                if (e.code === '23505')
+                    continue; // новый clock_timestamp сразу
+                if (isTransient(e)) {
+                    await retryDelay(attempt);
+                    continue;
+                }
+            }
             throw e;
         }
     }
 }
 /**
- * Различие форм фильтра в записи:
- *   Класс()   — БЕЗ аргумента  → INSERT новой сущности;
- *   Класс({}) — пустой объект  → «все найденные» (UPDATE в границах контекста).
+ * enforceAcl: право операции на класс цели. Предикат победившего правила:
+ *  - фильтрует цели UPDATE/DELETE (step.aclFilter → WHERE при поиске);
+ *  - колоночные ключи owner/account пришпиливают значения INSERT
+ *    (явный чужой модификатор на цепочке → ошибка).
+ * Мутирует step (объект создаётся цепочкой на вызов — локально безопасно).
  */
+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}`);
+        }
+        step[key] = v;
+    }
+}
 const noFilter = (f) => f === undefined;
 /** Entity.account NOT NULL: модификатор → connect() → System-аккаунт; иначе ошибка. */
 function resolveAccount(ctx, step) {
@@ -111,7 +164,7 @@ function resolveAccount(ctx, step) {
     }
     const acc = step.accountFilter ?? ctx.account ?? ctx.systemAccount;
     if (!acc) {
-        throw new Error('letopis: Entity.account is NOT NULL — set .account(…) / connect({account}) or seed a System account (db/seed.auth.sql)');
+        throw new Error('letopis: Entity.account is NOT NULL — set .account(…) / connect({account}) or seed a System account (lib/sql/seed.auth.sql)');
     }
     return acc;
 }
@@ -126,76 +179,179 @@ function tagsValue(step) {
         return t;
     throw new Error('letopis: .tags() before set() accepts string | string[]');
 }
+/** Конец 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'));
+}
 /**
- * Контекст-шаги (все, кроме последнего) → {КлассId: id}.
- * id-фильтр берётся как есть (без запроса); иной фильтр обязан дать ровно одну сущность.
+ * Связи создаваемой сущности из ПУТИ: каждый реальный шаг-предок, чей класс — конец
+ * target, обязан дать ровно одну сущность (id-фильтр — как есть; иначе чтение путём
+ * от начала до него: контекст честно учитывается).
  */
-async function resolveContext(ctx, steps) {
+async function resolvePathEnds(ctx, steps) {
+    const target = steps[steps.length - 1].cls;
     const links = {};
-    for (const step of steps) {
+    for (let k = 0; k < steps.length - 1; k++) {
+        const step = steps[k];
+        if (step.pivotKey !== undefined || step.op)
+            continue;
+        if (!endFor(target, step.cls))
+            continue;
         let id;
         if (typeof step.filter === 'string') {
             id = step.filter;
         }
-        else if (!noFilter(step.filter) || step.tagsFilter !== undefined || step.accountFilter || step.ownerFilter) {
-            const rows = await readRows(ctx, [step], { limit: 2 });
+        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})`);
             }
             id = rows[0].id;
         }
-        else {
-            throw new Error(`letopis: context step "${step.name}" needs an id or a unique filter`);
-        }
         links[step.cls.id] = id;
     }
     return links;
 }
-/** Шаг поиска целей: фильтр последнего шага + containment контекст-связей. */
-function targetStep(target, contextLinks, explicitId) {
-    return {
-        ...target,
-        filter: explicitId ?? target.filter,
-        linksFilter: Object.keys(contextLinks).length ? contextLinks : undefined,
-    };
+/** Резолв слот-значений: строки как есть; вложенные планы — в той же транзакции, ровно одна сущность. */
+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;
+        }
+        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}"`);
+            }
+            id = rows[0].id;
+        }
+        vals[clsId] = id;
+    }
+    return { vals, drops };
+}
+/** id новой сущности по IdGen класса (v5 считается отдельно — нужны концы/данные). */
+const genId = (cls) => (cls.idGen.version === 7 ? uuidv7() : randomUUID());
+/**
+ * Детерминированный id (uuid v5): имя = «схема:партиция:класс:значения from».
+ * from-источник — конец Schema.links (класс или полное имя союза 'Service|Complex';
+ * значение — id присутствующего класса конца) или скалярное поле data.
+ */
+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]);
+        }
+        else {
+            const v = 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));
+        }
+    }
+    return uuidv5(`${ctx.pgSchema}:${ctx.partition}:${cls.id}:${parts.join(':')}`);
+}
+/** Новая версия каждой строки: 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,
+        }));
+    }
+    return out;
 }
 /**
- * .set(data):
- *  - пустой фильтр последнего шага и нет data.id → INSERT (links = контекст);
- *  - id (фильтр-строка или data.id) → UPSERT: есть → новая версия (deep-merge), нет → создать;
- *  - фильтр-объект → новая версия каждого найденного (в границах контекста); пусто → [].
+ * .create(data) — «чтобы сущность существовала»:
+ *  - id не задан → INSERT (id по IdGen класса; links = концы из пути + слоты);
+ *  - id известен (Класс(id) / data.id / вычислен v5): есть → новая версия (deep-merge),
+ *    нет → INSERT с этим id (идемпотентный create, REST-PUT семантика);
+ *  - фильтр-объект / pivot — ошибка: create не ищет, это update().
  */
-export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
+export async function createOp(ctx, steps, mods, data) {
     const target = steps[steps.length - 1];
     const cls = target.cls;
-    // контекст-шаги: и фильтр целей, и значения; довешенные extraLinks — ТОЛЬКО значения
-    const contextLinks = await resolveContext(ctx, steps.slice(0, -1));
-    const writeLinks = { ...contextLinks, ...extraLinks };
-    const dataId = typeof data.id === 'string' ? data.id : undefined;
+    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()`);
+    }
     const filterId = typeof target.filter === 'string' ? target.filter : undefined;
-    const explicitId = filterId ?? dataId;
-    const insertMode = noFilter(target.filter); // Класс() без аргумента
-    const found = insertMode && !explicitId
-        ? []
-        : await readRows(ctx, [targetStep(target, contextLinks, explicitId)], mods);
-    if (found.length) {
-        const out = [];
-        for (const row of found) {
-            const mergedData = deepMerge(row.data, data); // только указанные листья
-            const mergedLinks = { ...row.links, ...writeLinks }; // контекст + довешенные
-            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,
-            }));
+    if (!noFilter(target.filter) && filterId === undefined) {
+        throw new Error(`letopis: create() takes no filter — ${cls.alias}(id).create(…) fixes the id, searching is update()`);
+    }
+    // слоты (.Класс.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}"`);
+    }
+    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`);
         }
-        return out;
+        explicitId = v5Id(ctx, cls, writeLinks, data);
     }
-    // не найдено: INSERT только при явном id или Класс() без аргумента
-    if (!explicitId && !insertMode)
-        return [];
-    const id = explicitId ?? randomUUID();
+    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 [];
+        }
+    }
+    const id = explicitId ?? genId(cls);
     const account = resolveAccount(ctx, target);
     const owner = target.ownerFilter ?? ctx.owner ?? account;
     const full = validate(cls, id, data, writeLinks);
@@ -206,6 +362,23 @@ export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
         }),
     ];
 }
+/**
+ * .update(data?) — новая версия КАЖДОГО найденного путём (deep-merge листьев);
+ * цели: Класс() ≡ Класс({}) — все в границах контекста, id/фильтр/pivot — как в чтении.
+ * Не найдено → [] — update НИКОГДА не создаёт.
+ */
+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);
+}
 /**
  * .anonymize(fields): GDPR-затирание — новая версия с '[erased]' в указанных string-полях
  * + тег 'anonymized'. Только string-поля (по Schema); история сохраняется (см. README).
@@ -213,13 +386,13 @@ export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
 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 contextLinks = await resolveContext(ctx, steps.slice(0, -1));
-    const found = await readRows(ctx, [targetStep(target, contextLinks)], mods);
+    const found = await readRows(ctx, steps, mods); // цели — честный путь
     const out = [];
     for (const row of found) {
         const patch = Object.fromEntries(fields.filter((f) => f in row.data).map((f) => [f, '[erased]']));
@@ -233,35 +406,195 @@ export async function anonymizeOp(ctx, steps, mods, fields) {
     }
     return out;
 }
-/** Транзакционная обёртка: в tr исполняем как есть, вне — sql.begin. */
+/** Транзакционная обёртка: в tr исполняем как есть, вне — sql.begin с ретраем transient
+ *  (deadlock/serialization откатывает ВСЮ внутреннюю транзакцию — повтор честен). */
 async function inTransaction(ctx, fn) {
     if (ctx.inTx)
         return fn(ctx);
-    return (await ctx.sql.begin(async (tsql) => fn({ ...ctx, sql: tsql, inTx: true })));
+    for (let attempt = 1;; attempt++) {
+        try {
+            return (await ctx.sql.begin(async (tsql) => fn({ ...ctx, sql: tsql, inTx: true })));
+        }
+        catch (e) {
+            if (isTransient(e) && attempt < RETRIES) {
+                await retryDelay(attempt);
+                continue;
+            }
+            throw e;
+        }
+    }
 }
 /**
- * .delete(): цели = фильтр последнего шага + контекст-связи; серверное удаление.
- * Триггер entity_delete: tombstone + рекурсивный каскад (+advisory-lock).
- * Возвращает ВСЁ удалённое (цели + каскад) с $deleted: true.
+ * .delete({confirm}): цели = фильтр последнего шага + контекст-связи.
+ * confirm: true — серверное удаление (триггер entity_delete: tombstone + рекурсивный
+ * каскад + advisory-lock); возвращает ВСЁ удалённое (цели + каскад) с $deleted: true.
+ * Без confirm — ПРЕВЬЮ: то же замыкание (цели + каскад), но БД не трогается.
  */
-export async function delOp(ctx, steps, mods) {
+export async function delOp(ctx, steps, mods, confirm) {
     const target = steps[steps.length - 1];
-    const contextLinks = await resolveContext(ctx, steps.slice(0, -1));
-    const targets = await readRows(ctx, [targetStep(target, contextLinks)], mods);
+    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)];
     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 }));
     });
 }
-const isPureInsert = (op) => op.kind === 'set' &&
-    op.steps.length === 1 &&
-    noFilter(op.steps[0].filter) &&
-    typeof op.data?.id !== 'string' &&
-    !Object.keys(op.extraLinks ?? {}).length;
+/** Разрезать план: сегменты (…шаги + op-шаг) и читающий хвост после последней операции. */
+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 });
+            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);
+    }
+}
+/** Виртуальный старт-шаг «от этих строк»: контекст/чтение следующего сегмента. */
+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))),
+};
+/**
+ * Исполнить план целиком: все операции + финальное чтение — одна транзакция
+ * (внутренняя, с ретраем transient; внутри db.begin() — транзакция пользователя).
+ * Продолжение после операции: fan-out — каждый следующий сегмент исполняется от каждой
+ * строки результата (контекст = строка); self-шаг (op сразу после op) пишет в те же строки.
+ * После delete продолжение идёт от строк КЛАССА ЦЕЛИ (замыкание каскада шире).
+ */
+export async function runPlan(ctx, steps, mods, mode) {
+    const { segments, tail } = splitPlan(steps);
+    return inTransaction(ctx, async (c) => {
+        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' ? last.filter((r) => r.class === targetCls.id) : last;
+        }
+        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);
+        }
+        // терминал прямо на операции
+        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);
+            }
+        }
+    });
+}
+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 }];
+    }
+}
+/** Финальное чтение плана: тот же 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));
+        }
+        case 'ids': {
+            const q = buildRead(c, steps, mods, 'ids');
+            return (await runQuery(c, q.text, q.params, 'ids', classes)).map((r) => r.id);
+        }
+        case 'count': {
+            const q = buildRead(c, steps, mods, 'count');
+            return (await runQuery(c, q.text, q.params, 'count', classes))[0].n;
+        }
+        case 'agg': {
+            const q = buildRead(c, steps, mods, 'agg');
+            return runQuery(c, q.text, q.params, 'agg', classes);
+        }
+    }
+}
+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;
 export async function executeBatch(ctx, queue) {
     if (!queue.length)
         return [];
@@ -269,19 +602,18 @@ export async function executeBatch(ctx, queue) {
         const results = new Array(queue.length);
         let i = 0;
         while (i < queue.length) {
-            const op = queue[i];
-            if (isPureInsert(op)) {
-                const step = op.steps[0];
-                const cls = step.cls;
+            if (isPureInsertPlan(queue[i])) {
+                const cls = queue[i].steps[0].cls;
                 let j = i;
-                while (j < queue.length && isPureInsert(queue[j]) && queue[j].steps[0].cls.id === cls.id)
+                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];
-                    const id = randomUUID();
-                    const full = validate(cls, id, g.data ?? {}, {});
+                    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);
                 }
@@ -291,10 +623,7 @@ export async function executeBatch(ctx, queue) {
                 i = j;
                 continue;
             }
-            results[i] =
-                op.kind === 'set'
-                    ? await setOp(c, op.steps, op.mods, op.data ?? {}, op.extraLinks)
-                    : await delOp(c, op.steps, op.mods);
+            results[i] = (await runPlan(c, queue[i].steps, {}, 'rows'));
             i++;
         }
         return results;