letopis 0.5.0 → 0.13.0

package/dist/up.js

@@ -0,0 +1,209 @@
+/**
+ * letopis.up(): одна точка входа — dev-контейнер (TimescaleDB + Redis), готовность БД,
+ * версионная схема с сидами, connect. Идемпотентно: живой postgres на dsn → docker
+ * пропускается целиком; существующая схема не трогается (fresh: true — дроп и накат).
+ *
+ *   const db = await up({ schema: 'booking', version: 1 });   // → PG-схема "v1.booking"
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { setTimeout as sleep } from 'node:timers/promises';
+import net from 'node:net';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import postgres from 'postgres';
+import { connect } from './index.js';
+const exec = promisify(execFile);
+const DEFAULT_DSN = 'postgres://postgres:test@localhost:15432/letopis';
+const qi = (s) => `"${s.replace(/"/g, '""')}"`;
+const pkgPath = (rel) => fileURLToPath(new URL(rel, import.meta.url));
+/** argv для docker run (чистая функция — покрыта юнитом). dataDir: путь → bind, имя → volume. */
+export function dockerRunArgs(cfg) {
+    const args = ['run', '-d', '--name', cfg.container,
+        '-p', `${cfg.pgPort}:5432`, '-p', `${cfg.redisPort}:6379`,
+        '-v', `${cfg.dataDir ?? 'letopis-pgdata'}:/var/lib/postgresql/data`];
+    if (cfg.user && cfg.user !== 'postgres')
+        args.push('-e', `POSTGRES_USER=${cfg.user}`);
+    // без пароля в dsn контейнер поднимается в trust-режиме (dev), иначе postgres-образ не стартует
+    args.push('-e', cfg.password ? `POSTGRES_PASSWORD=${cfg.password}` : 'POSTGRES_HOST_AUTH_METHOD=trust');
+    args.push('-e', `POSTGRES_DB=${cfg.database}`, cfg.image);
+    return args;
+}
+async function docker(args) {
+    try {
+        const { stdout, stderr } = await exec('docker', args, { maxBuffer: 64 * 1024 * 1024 });
+        return { ok: true, out: stdout.trim(), err: stderr };
+    }
+    catch (e) {
+        const x = e;
+        if (x.code === 'ENOENT')
+            throw new Error('letopis.up: docker CLI not found — install Docker or point dsn at an already running postgres');
+        return { ok: false, out: (x.stdout ?? '').trim(), err: (x.stderr || x.message || '').trim() };
+    }
+}
+async function ensureContainer(cfg, log) {
+    const st = await docker(['container', 'inspect', '--format', '{{.State.Running}}', cfg.container]);
+    if (st.ok && st.out === 'true') {
+        log(`container ${cfg.container} is running — reused`);
+        return;
+    }
+    if (st.ok) {
+        const r = await docker(['start', cfg.container]);
+        if (!r.ok)
+            throw new Error(`letopis.up: docker start ${cfg.container} failed: ${r.err}`);
+        log(`container ${cfg.container} started`);
+        return;
+    }
+    const img = await docker(['image', 'inspect', cfg.image]);
+    if (!img.ok) {
+        log(`building image ${cfg.image} (first time pulls the timescaledb base — may take minutes)…`);
+        const b = await docker(['build', '-t', cfg.image, pkgPath('../docker/')]);
+        if (!b.ok)
+            throw new Error(`letopis.up: docker build ${cfg.image} failed: ${b.err}`);
+        log(`image ${cfg.image} built`);
+    }
+    const r = await docker(dockerRunArgs(cfg));
+    if (!r.ok)
+        throw new Error(`letopis.up: docker run ${cfg.container} failed: ${r.err}`);
+    log(`container ${cfg.container} created (data: ${cfg.dataDir ?? 'volume letopis-pgdata'})`);
+}
+async function pgPing(dsn) {
+    const sql = postgres(dsn, { max: 1, connect_timeout: 3, onnotice: () => { } });
+    try {
+        await sql `select 1`;
+        return { ok: true };
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === '3D000')
+            return { ok: false, kind: 'no-database', err: e }; // сервер жив, базы нет
+        if (code === '57P03')
+            return { ok: false, kind: 'starting', err: e }; // initdb/recovery
+        if (code === '28P01' || code === '28000')
+            return { ok: false, kind: 'fatal', err: e }; // ретраи бессмысленны
+        return { ok: false, kind: 'no-server', err: e };
+    }
+    finally {
+        await sql.end({ timeout: 1 }).catch(() => { });
+    }
+}
+async function ensureDatabase(url, log) {
+    const dbName = decodeURIComponent(url.pathname.slice(1)) || url.username || 'postgres';
+    const admin = new URL(url);
+    admin.pathname = '/postgres';
+    const sql = postgres(admin.toString(), { max: 1, onnotice: () => { } });
+    try {
+        const rows = await sql `SELECT 1 FROM pg_database WHERE datname = ${dbName}`;
+        if (rows.length === 0) {
+            await sql.unsafe(`CREATE DATABASE ${qi(dbName)}`).catch((e) => {
+                if (e.code !== '42P04')
+                    throw e; // 42P04 — гонка параллельных up()
+            });
+            log(`database "${dbName}" created`);
+        }
+    }
+    finally {
+        await sql.end();
+    }
+}
+function tcpAlive(host, port) {
+    return new Promise((res) => {
+        const s = net.connect({ host, port });
+        const done = (v) => { s.destroy(); res(v); };
+        s.once('connect', () => done(true));
+        s.once('error', () => done(false));
+        s.setTimeout(2000, () => done(false));
+    });
+}
+async function applySchema(dsn, full, seeds, fresh, log) {
+    const sql = postgres(dsn, { max: 1, onnotice: () => { } });
+    try {
+        if (fresh) {
+            await sql.unsafe(`DROP SCHEMA IF EXISTS ${qi(full)} CASCADE`);
+            log(`schema "${full}" dropped (fresh)`);
+        }
+        const have = await sql `SELECT 1 FROM information_schema.schemata WHERE schema_name = ${full}`;
+        if (have.length > 0) {
+            log(`schema "${full}" already exists — apply skipped`);
+            return;
+        }
+        const files = [pkgPath('../sql/ddl.sql')];
+        if (seeds === undefined)
+            files.push(pkgPath('../sql/seed.booking.sql'), pkgPath('../sql/seed.auth.sql'));
+        else if (seeds)
+            files.push(...seeds.map((p) => resolve(p)));
+        for (const f of files) {
+            const text = (await readFile(f, 'utf8')).replaceAll('<SCHEMA-NAME>', full);
+            await sql.unsafe(text); // multi-statement simple query
+        }
+        log(`schema "${full}" applied (${files.length} files)`);
+    }
+    finally {
+        await sql.end();
+    }
+}
+export async function up(opts) {
+    const { dsn = DEFAULT_DSN, schema, version, container = 'letopis-timescale', image = 'letopis-db', dataDir, redisPort = 16379, seeds, fresh, quiet, waitTimeoutMs = 120_000, ...connectRest } = opts;
+    if (!/^[a-zA-Z_][a-zA-Z0-9_$]*$/.test(schema))
+        throw new Error(`letopis.up: bad schema name "${schema}" (базовое имя без версии и точек; версию задаёт version)`);
+    if (!Number.isInteger(version) || version < 1)
+        throw new Error(`letopis.up: bad version ${version} (целое ≥ 1)`);
+    const full = `v${version}.${schema}`;
+    const url = new URL(dsn);
+    const host = url.hostname;
+    const local = host === 'localhost' || host === '127.0.0.1' || host === '::1';
+    const log = quiet ? () => { } : (m) => console.log(`[letopis.up] ${m}`);
+    const deadline = Date.now() + waitTimeoutMs;
+    let ping = await pgPing(dsn);
+    if (ping.ok || ping.kind === 'no-database') {
+        // postgres уже отвечает (свой контейнер, CI-сервис, внешняя БД) — docker не нужен
+        if (!ping.ok)
+            await ensureDatabase(url, log);
+        log(`postgres is up at ${host}:${url.port || '5432'} — docker skipped`);
+    }
+    else if (ping.kind === 'fatal') {
+        throw ping.err;
+    }
+    else {
+        if (local) {
+            await ensureContainer({
+                container, image, pgPort: url.port || '5432', redisPort,
+                user: decodeURIComponent(url.username), password: decodeURIComponent(url.password),
+                database: decodeURIComponent(url.pathname.slice(1)) || url.username || 'postgres', dataDir,
+            }, log);
+        }
+        else {
+            log(`waiting for remote postgres at ${host} (no docker for non-local dsn)…`);
+        }
+        const t0 = Date.now();
+        for (;;) {
+            ping = await pgPing(dsn);
+            if (ping.ok)
+                break;
+            if (ping.kind === 'fatal')
+                throw ping.err;
+            if (ping.kind === 'no-database') {
+                await ensureDatabase(url, log);
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`letopis.up: postgres not ready in ${Math.round(waitTimeoutMs / 1000)} s${local ? ` — check: docker logs ${container}` : ''}`);
+            await sleep(500);
+        }
+        log(`postgres ready in ${((Date.now() - t0) / 1000).toFixed(1)} s`);
+        if (local) {
+            // контейнер поднимали мы — убеждаемся, что и redis-порт жив
+            while (!(await tcpAlive(host, redisPort))) {
+                if (Date.now() > deadline)
+                    throw new Error(`letopis.up: redis not ready on ${redisPort} — check: docker logs ${container}`);
+                await sleep(300);
+            }
+            log(`redis ready on ${redisPort}`);
+        }
+    }
+    await applySchema(dsn, full, seeds, fresh ?? false, log);
+    const db = await connect({ ...connectRest, dsn, schema: full });
+    log(`connected (schema "${full}")`);
+    return db;
+}

package/dist/write.d.ts

@@ -36,25 +36,31 @@ export declare function deepMerge(base: Record<string, unknown>, patch: Record<s
  *  - id (фильтр-строка или data.id) → UPSERT: есть → новая версия (deep-merge), нет → создать;
  *  - фильтр-объект → новая версия каждого найденного (в границах контекста); пусто → [].
  */
-export declare function setOp(ctx: Ctx, steps: Step[], mods: ChainMods, data: Record<string, unknown>, extraLinks?: Record<string, string>): Promise<Row[]>;
+export declare function setOp(ctx: Ctx, steps: Step[], mods: ChainMods, data: Record<string, unknown>): Promise<Row[]>;
 /**
  * .anonymize(fields): GDPR-затирание — новая версия с '[erased]' в указанных string-полях
  * + тег 'anonymized'. Только string-поля (по Schema); история сохраняется (см. README).
  */
 export declare function anonymizeOp(ctx: Ctx, steps: Step[], mods: ChainMods, fields: string[]): Promise<Row[]>;
 /**
- * .delete(): цели = фильтр последнего шага + контекст-связи; серверное удаление.
- * Триггер entity_delete: tombstone + рекурсивный каскад (+advisory-lock).
- * Возвращает ВСЁ удалённое (цели + каскад) с $deleted: true.
+ * .delete({confirm}): цели = фильтр последнего шага + контекст-связи.
+ * confirm: true — серверное удаление (триггер entity_delete: tombstone + рекурсивный
+ * каскад + advisory-lock); возвращает ВСЁ удалённое (цели + каскад) с $deleted: true.
+ * Без confirm — ПРЕВЬЮ: то же замыкание (цели + каскад), но БД не трогается.
  */
-export declare function delOp(ctx: Ctx, steps: Step[], mods: ChainMods): Promise<Row[]>;
-export interface BatchOp {
-    kind: 'set' | 'delete';
+export declare function delOp(ctx: Ctx, steps: Step[], mods: ChainMods, confirm: boolean): Promise<Row[]>;
+export type PlanMode = 'rows' | 'ids' | 'count' | 'paths' | 'versions' | 'agg';
+/**
+ * Исполнить план целиком: все операции + финальное чтение — одна транзакция
+ * (внутренняя, с ретраем transient; внутри db.begin() — транзакция пользователя).
+ * Продолжение после операции: fan-out — каждый следующий сегмент исполняется от каждой
+ * строки результата (контекст = строка); self-шаг (op сразу после op) пишет в те же строки.
+ * После delete продолжение идёт от строк КЛАССА ЦЕЛИ (замыкание каскада шире).
+ */
+export declare function runPlan(ctx: Ctx, steps: Step[], mods: ChainMods, mode: PlanMode): Promise<unknown>;
+/** План в очереди батча; steps обновляется по мере роста цепочки. */
+export interface BatchPlan {
     steps: Step[];
-    mods: ChainMods;
-    data?: Record<string, unknown>;
-    /** Связи, довешенные после set() (мутируется билдером до execute()). */
-    extraLinks?: Record<string, string>;
 }
-export declare function executeBatch(ctx: Ctx, queue: BatchOp[]): Promise<Row[][]>;
+export declare function executeBatch(ctx: Ctx, queue: BatchPlan[]): Promise<Row[][]>;
 export {};

package/dist/write.js

@@ -1,17 +1,22 @@
 /**
- * Запись: терминалы .set(data) / .delete() на цепочке + исполнение батчей.
+ * Запись: операции .set(data) / .delete(opts) / .anonymize(fields) — ЗВЕНЬЯ цепочки;
+ * терминал (rows/first/ids/count/run/versions/агрегации) исполняет весь план
+ * ОДНОЙ транзакцией (runPlan) — любой отказ (валидация/ACL) откатывает всё.
  *
- * Связи задаются dot-цепочкой: НЕ-последние шаги (контекст) резолвятся в ровно одну
+ * Связи задаются dot-цепочкой: шаги до операции (контекст) резолвятся в ровно одну
  * сущность каждый и дают:
  *   - containment-фильтр целей при UPDATE/DELETE (links ⊇ {Класс: id}),
  *   - links создаваемой строки при INSERT.
  *
- *   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).Сотрудник().set({ name: 'Вася' }).rows()   // INSERT + links {Org}
+ *   await db.Клиент(c).Запись({ status: 'created' }).set({ status: 'confirmed' }).rows()
+ *   await db.Клиент({ vip: true }).set({ bonus: 500 })       // сегмент 1: UPDATE всех vip
+ *           .Запись().delete({ confirm: true }).rows()       // сегмент 2: снести записи каждого
+ * Продолжение после операции идёт ОТ ЕЁ РЕЗУЛЬТАТА (fan-out по записанным строкам).
  */
 import { randomUUID } from 'node:crypto';
-import { buildRead, runQuery, insertSql, multiInsertSql, deleteSql, closureSql } from './sql.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) {
@@ -79,7 +84,7 @@ function validate(cls, id, data, links) {
     }
     return merged;
 }
-/** INSERT одной строки с ретраем коллизии PK по updated (23505). */
+/** INSERT одной строки с ретраем гонок: 23505 (коллизия updated) и transient (40P01/40001). */
 async function insertOne(ctx, a) {
     // jsonb-параметры — JS-объектами (postgres.js сериализует сам)
     const params = [
@@ -92,12 +97,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;
         }
     }
 }
+/**
+ * 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;
+    }
+}
 /**
  * Различие форм фильтра в записи:
  *   Класс()   — БЕЗ аргумента  → INSERT новой сущности;
@@ -111,7 +150,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;
 }
@@ -165,12 +204,13 @@ function targetStep(target, contextLinks, explicitId) {
  *  - id (фильтр-строка или data.id) → UPSERT: есть → новая версия (deep-merge), нет → создать;
  *  - фильтр-объект → новая версия каждого найденного (в границах контекста); пусто → [].
  */
-export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
+export async function setOp(ctx, steps, mods, data) {
     const target = steps[steps.length - 1];
     const cls = target.cls;
-    // контекст-шаги: и фильтр целей, и значения; довешенные extraLinks — ТОЛЬКО значения
+    aclWrite(ctx, target, 'WRITE');
+    // контекст-шаги: и фильтр целей, и значения; .link() — ТОЛЬКО значения (фильтр не трогает)
     const contextLinks = await resolveContext(ctx, steps.slice(0, -1));
-    const writeLinks = { ...contextLinks, ...extraLinks };
+    const writeLinks = { ...contextLinks, ...(target.extraLinks ?? {}) };
     const dataId = typeof data.id === 'string' ? data.id : undefined;
     const filterId = typeof target.filter === 'string' ? target.filter : undefined;
     const explicitId = filterId ?? dataId;
@@ -182,7 +222,7 @@ export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
         const out = [];
         for (const row of found) {
             const mergedData = deepMerge(row.data, data); // только указанные листья
-            const mergedLinks = { ...row.links, ...writeLinks }; // контекст + довешенные
+            const mergedLinks = { ...row.links, ...writeLinks }; // контекст + .link()
             const full = validate(cls, row.id, mergedData, mergedLinks);
             out.push(await insertOne(ctx, {
                 id: row.id, cls, data: full, links: mergedLinks,
@@ -195,6 +235,22 @@ export async function setOp(ctx, steps, mods, data, extraLinks = {}) {
     // не найдено: INSERT только при явном id или Класс() без аргумента
     if (!explicitId && !insertMode)
         return [];
+    // enforceAcl-предикат + явный id: «не нашёл среди доступных» НЕ значит «можно создать» —
+    // существующая, но недоступная сущность иначе перехватывалась бы новой версией с чужим owner.
+    // Проверка существования — БЕЗ предиката и БЕЗ пришпиленных им колонок.
+    if (explicitId && target.aclFilter) {
+        const bare = { ...ctx, aclDecide: undefined };
+        const probe = {
+            ...targetStep(target, contextLinks, explicitId),
+            aclFilter: undefined,
+            ownerFilter: undefined,
+            accountFilter: undefined,
+            linksFilter: undefined,
+        };
+        const taken = await readRows(bare, [probe], {});
+        if (taken.length)
+            return [];
+    }
     const id = explicitId ?? randomUUID();
     const account = resolveAccount(ctx, target);
     const owner = target.ownerFilter ?? ctx.owner ?? account;
@@ -213,6 +269,7 @@ 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'}`);
@@ -233,19 +290,33 @@ 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];
+    aclWrite(ctx, target, 'DELETE');
     const contextLinks = await resolveContext(ctx, steps.slice(0, -1));
     const targets = await readRows(ctx, [targetStep(target, contextLinks)], mods);
     if (!targets.length)
@@ -253,15 +324,159 @@ export async function delOp(ctx, steps, mods) {
     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 'set':
+            return setOp(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 === 'set' &&
+    noFilter(p.steps[0].filter) &&
+    typeof p.steps[0].op.data?.id !== 'string' &&
+    !Object.keys(p.steps[0].extraLinks ?? {}).length;
 export async function executeBatch(ctx, queue) {
     if (!queue.length)
         return [];
@@ -269,19 +484,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 s = { ...g.steps[0] };
+                    aclWrite(c, s, 'WRITE'); // склейка multi-VALUES идёт мимо setOp — право+пришпиливание на каждый
                     const id = randomUUID();
-                    const full = validate(cls, id, g.data ?? {}, {});
+                    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 +505,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;