letopis 1.4.2 → 3.0.0

package/dist/chain.js

@@ -7,15 +7,17 @@
  * узлу (pivot): от него ветвится следующий шаг. Модификаторы возвращают новую цепочку; терминалы
  * строят один запрос (sql.ts) и исполняют его транзакцией под сессией (tx.ts).
  *
- * Запись (этап 4): глаголы create, update, upsert, delete, anonymize, reclass — звенья плана; слоты
+ * Запись (этап 4): глаголы create, update, upsert, delete — звенья плана; слоты
  * `.Роль.set/unset/add/remove` правят концы записываемой версии. Терминал цепочки с глаголами
  * исполняет весь план одной транзакцией (write.ts): продолжение идёт от результата глагола.
- * Этап 6: restore, purge, rekey; versions({ follow }); кэш результатов .cache() (cache.ts).
+ * Этап 6: restore; versions(); кэш результатов .cache() (cache.ts).
  */
-import { LetopisError, removed } from './errors.js';
+import { lerr, lwarn, similar } from './errors.js';
 import { sessionTag } from './cache.js';
 import { buildRead, nextNodeKey, resolveHop, roleTargets, stepClasses, toRow, } from './sql.js';
-import { execBatch, execPlan, precheckPlan, slotRole } from './write.js';
+import { CHAIN_METHODS, OP } from './types.js';
+import { NOLOG, guarded, traced } from './log.js';
+import { completeIssues, dropUndefined, execBatch, execPlan, lockIds, precheckPlan, slotRole, } from './write.js';
 /** Внутренний канал: план чужой ленивой цепочки (entity()). */
 export const PLAN = Symbol('letopis.plan');
 const peekPlan = (x) => x !== null && (typeof x === 'object' || typeof x === 'function') ? x[PLAN] : undefined;
@@ -38,9 +40,67 @@ export function lookupStep(reg, name) {
     const t = targets.map((n) => reg.find(n)).find((c) => !!c);
     return t ? { cls: t, role: name } : undefined;
 }
-const unknownName = (name) => {
-    throw new LetopisError('invalid_class', `класс или роль ${name} не найдены`);
+/** Системные классы (прав, членств, аккаунтов, описаний): в «похожие» неизвестного шага не идут (план 2.1, A6). */
+const SYSTEM_CLASSES = new Set(['Class', 'Account', 'member', 'Resource', 'rule']);
+const SYSTEM_ID = '2eba6d0a-1edd-4bb6-a85a-a703dab49035';
+const isSystem = (c) => c.ancestors.some((n) => SYSTEM_CLASSES.has(n));
+/** Имена, которыми начинается шаг: классы, их алиасы и роли концов реестра, кроме системных классов. */
+const stepNames = (reg) => reg.all().filter((c) => !isSystem(c)).flatMap((c) => [c.name, ...(c.alias ? [c.alias] : []), ...Object.keys(c.ends)]);
+/**
+ * Свойства массива, которые спрашивают у цепочки, забыв терминал: `.length`, `.map(…)`, `[0]` — не шаги (план 2.1, A6).
+ * Не case-метки member: имена попали бы в зарезервированные (check:docs, reserved) — проверяются после неудачного поиска.
+ */
+const ARRAY_PROPS = new Set(['length', 'map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every', 'slice', 'at', 'toJSON', '0']);
+/**
+ * Неизвестный класс или роль — с похожими именами реестра (план 2.0, 7.9 №6). Свойство массива — api.chain_not_rows;
+ * в реестре только классы System — сессия, похоже, в личном арендаторе (api.unknown_step_no_classes).
+ */
+const unknownName = (reg, name) => {
+    if (ARRAY_PROPS.has(name))
+        throw lerr('api.chain_not_rows', { name });
+    const key = reg.all().every((c) => c.tenant === SYSTEM_ID) ? 'api.unknown_step_no_classes' : 'api.unknown_step';
+    throw lerr(key, { name, similar: similar(name, stepNames(reg)) });
+};
+/** Терминалы и агрегаты цепочки: у цепочки без сессии они отдают отказ промисом (sessionless). */
+const TERMINALS = new Set(['rows', 'first', 'ids', 'count', 'paths', 'versions', 'sum', 'avg', 'min', 'max', 'countBy']);
+/**
+ * Неизвестный шаг у фасада без сессии (токен погашен или истёк после connect(), второй раунд 2.1, A5): не синхронный
+ * выброс про «личный арендатор», а цепочка, чьи терминалы отдают api.token_not_active (no_session) отклонённым
+ * промисом — как у любой другой ошибки запроса. Шаги, модификаторы и глаголы такой цепочки ничего не проверяют.
+ */
+function sessionless() {
+    const fail = () => Promise.reject(lerr('api.token_not_active'));
+    const dead = new Proxy(function () { }, {
+        get(_t, p) {
+            if (typeof p === 'symbol' || p === 'then')
+                return undefined;
+            return TERMINALS.has(p) ? fail : dead;
+        },
+        apply: () => dead,
+    });
+    return dead;
+}
+/**
+ * Фасад с токеном без сессии: шага нет среди классов, а арендатора у сессии нет — шаг из sessionless(); батч и
+ * подключение без токена (администраторское) — как прежде.
+ */
+const noSession = (ctx, name) => !ctx.batch && !ARRAY_PROPS.has(name) && ctx.hasToken?.() === true && ctx.tenant() === null;
+/** Перебор цепочки (for…of, spread, Array.from) — понятный отказ вместо «is not iterable». */
+const notIterable = () => {
+    throw lerr('api.chain_not_rows', { name: '[Symbol.iterator]' });
 };
+/**
+ * withDeleted() — модификатор своего шага (план 2.1, A9): у шага не последнего, когда у последнего его нет, — один раз
+ * предупреждение (до 2.1 флаг относился к последнему шагу).
+ */
+function warnWithDeleted(steps, log) {
+    const last = steps[steps.length - 1];
+    if (!last || last.withDeleted)
+        return;
+    const at = steps.slice(0, -1).find((s) => s.withDeleted && s.pivotKey === undefined);
+    if (at)
+        lwarn('api.with_deleted_step', { step: at.name, last: last.name }, { once: `with-deleted|${at.name}|${last.name}`, log });
+}
 const nodeOf = (steps, s) => s.pivotKey === undefined ? s : steps.find((x) => x.nodeKey === s.pivotKey) ?? s;
 /** Узел для возврата: последний реальный шаг того же класса-связи в текущем читающем сегменте. */
 function pivotNodeOf(steps, cls) {
@@ -54,7 +114,7 @@ function pivotNodeOf(steps, cls) {
     return undefined;
 }
 const noHistoryWarned = new Set();
-function warnNoHistory(steps, method) {
+function warnNoHistory(steps, method, log) {
     const cls = steps[steps.length - 1]?.cls;
     if (!cls || cls.history !== false)
         return;
@@ -62,7 +122,7 @@ function warnNoHistory(steps, method) {
     if (noHistoryWarned.has(key))
         return;
     noHistoryWarned.add(key);
-    console.warn(`letopis: .${method}() у класса ${cls.name} без журнала (history: false) — истории нет`);
+    lwarn('api.no_history', { method, cls: cls.name }, { log });
 }
 function report(ctx, mode, steps, t0, rows) {
     if (!ctx.onQuery && ctx.slowMs === undefined)
@@ -73,7 +133,233 @@ function report(ctx, mode, steps, t0, rows) {
     if (ctx.onQuery)
         ctx.onQuery({ mode, classes, ms, rows, slow });
     else if (slow)
-        console.warn(`letopis: медленный запрос ${ms.toFixed(0)} мс — ${mode} ${classes.join('→')}`);
+        lwarn('api.slow_query', { ms: ms.toFixed(0), mode, classes: classes.join('→') }, { log: ctx.log });
+}
+/**
+ * Свойства цепочки, вызов которых может отказать синхронно (модификаторы и глаголы): ошибка — событие error. Не
+ * case-метки: check-docs принимает их за зарезервированные имена.
+ */
+const GUARDED = new Set(['entity', 'limit', 'offset', 'sort', 'asOf', 'after', 'withDeleted', 'deep', 'exact', 'alias', 'tags',
+    'owner', 'create', 'update', 'upsert', 'delete', 'forUpdate', 'restore', 'cache']);
+const LIST_MAX = 50;
+/** Сколько строк каждого класса. */
+function byClass(rows) {
+    const m = {};
+    for (const r of rows)
+        m[r.class] = (m[r.class] ?? 0) + 1;
+    return m;
+}
+/** id строк — не больше LIST_MAX. */
+const idsOf = (rows) => rows.slice(0, LIST_MAX).map((r) => r.id);
+/** Значение фильтра или аргумента для текста цепочки: поля-секреты — '***', длинное — обрезано. */
+function fmtVal(log, x, depth = 0) {
+    if (x === undefined)
+        return 'undefined';
+    if (x === null || typeof x === 'number' || typeof x === 'boolean')
+        return String(x);
+    if (typeof x === 'string')
+        return JSON.stringify(x.length > 80 ? `${x.slice(0, 80)}…` : x);
+    if (typeof x === 'bigint')
+        return `${x}n`;
+    if (typeof x !== 'object')
+        return typeof x;
+    if (depth > 3)
+        return '…';
+    if (x instanceof Date)
+        return JSON.stringify(x.toISOString());
+    const op = x[OP];
+    if (typeof op === 'string') {
+        const args = x.args ?? [];
+        return `${op}(${args.map((a) => fmtVal(log, a, depth + 1)).join(', ')})`;
+    }
+    const peek = peekPlan(x);
+    if (peek)
+        return `(${chainText(log, peek.steps, peek.mods)})`;
+    if (Array.isArray(x)) {
+        const head = x.slice(0, 10).map((a) => fmtVal(log, a, depth + 1)).join(',');
+        return `[${head}${x.length > 10 ? `,…+${x.length - 10}` : ''}]`;
+    }
+    const entries = Object.entries(x);
+    const shown = entries.slice(0, 20).map(([k, v]) => `${JSON.stringify(k)}:${log.secret(k) ? '"***"' : fmtVal(log, v, depth + 1)}`);
+    return `{${shown.join(',')}${entries.length > 20 ? `,…+${entries.length - 20}` : ''}}`;
+}
+/** Данные записи — только имена полей (значения в лог не идут). */
+const keysOf = (data) => `{${Object.keys(data ?? {}).join(',')}}`;
+/** Модификаторы выборки текстом: .sort(…).limit(…)… */
+function modsText(m) {
+    if (!m)
+        return '';
+    let t = '';
+    if (m.order !== undefined)
+        t += `.sort(${JSON.stringify(m.order)}${m.desc ? ", 'desc'" : ''})`;
+    if (m.limit !== undefined)
+        t += `.limit(${m.limit})`;
+    if (m.offset !== undefined)
+        t += `.offset(${m.offset})`;
+    if (m.asOf !== undefined)
+        t += `.asOf(${JSON.stringify(m.asOf)})`;
+    if (m.after !== undefined)
+        t += '.after(…)';
+    if (m.forUpdate)
+        t += '.forUpdate()';
+    if (m.cache)
+        t += `.cache(${m.cache.ttl !== undefined ? `{ttl:${m.cache.ttl}}` : ''})`;
+    return t;
+}
+/** Глагол текстом: данные — именами полей, expect — числом строк. */
+function opText(op) {
+    const o = [];
+    if (op.kind === 'create' || op.kind === 'upsert')
+        return `${op.kind}(${keysOf(op.data)})`;
+    if (op.kind === 'update') {
+        if (op.rev !== undefined)
+            o.push(`rev:${op.rev}`);
+        if (op.all)
+            o.push('all:true');
+        return `update(${keysOf(op.data)}${o.length ? `, {${o.join(',')}}` : ''})`;
+    }
+    if (op.kind === 'delete') {
+        if (op.confirm)
+            o.push('confirm:true');
+        if (op.all)
+            o.push('all:true');
+    }
+    if (op.kind === 'restore' && op.partial)
+        o.push('partial:true');
+    if (op.expect !== undefined)
+        o.push(`expect:[${op.expect.length}]`);
+    return `${op.kind}(${o.length ? `{${o.join(',')}}` : ''})`;
+}
+/** Значение слота текстом. */
+function slotText(v) {
+    if (v === null)
+        return 'null';
+    if (typeof v === 'string')
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return `[${v.length}]`;
+    return 'plan' in v ? '(цепочка)' : JSON.stringify(v.id);
+}
+/**
+ * Цепочка в читаемом виде: `Shop({"name":"A"}).Product.limit(10).rows()`. Фильтры — значениями (поля-секреты — '***'),
+ * данные записи — только именами полей.
+ */
+export function chainText(log, steps, mods, term, args = []) {
+    let out = '';
+    steps.forEach((s, i) => {
+        if (!s.self) {
+            out += `${i ? '.' : ''}${s.name}(${s.filter !== undefined ? fmtVal(log, s.filter) : ''})`;
+            if (s.exact)
+                out += '.exact()';
+            if (s.withDeleted)
+                out += '.withDeleted()';
+            if (s.deepMax !== undefined)
+                out += `.deep(${s.deepMax})`;
+            if (s.aliasKey !== undefined)
+                out += `.alias(${JSON.stringify(s.aliasKey)})`;
+            if (s.tagsFilter !== undefined)
+                out += `.tags(${fmtVal(log, s.tagsFilter)})`;
+            if (s.ownerFilter !== undefined)
+                out += `.owner(${JSON.stringify(s.ownerFilter)})`;
+        }
+        if (s.op) {
+            out += `${modsText(s.opMods)}.${opText(s.op)}`;
+            for (const sl of s.slots ?? [])
+                out += `.${sl.role}.${sl.op}(${sl.op === 'unset' ? '' : slotText(sl.value)})`;
+        }
+        if (out.length > 4000)
+            return;
+    });
+    out += modsText(mods);
+    if (term)
+        out += `.${term}(${args.filter((a) => a !== undefined).map((a) => fmtVal(log, a)).join(', ')})`;
+    return out;
+}
+/** Подробности события записи: состав по классам и id; у удаления — сверка с expect, у restore — пропуски. */
+function writeDetail(op, rows) {
+    const d = {};
+    if (op.kind === 'delete') {
+        d.confirm = op.confirm;
+        d.expect = op.expect !== undefined ? op.expect.length : false;
+        if (op.all)
+            d.all = true;
+        // с expect замыкание каскада блокируется for update и превью сверяется заново (write.ts, deleteOp)
+        if (op.confirm && op.expect !== undefined)
+            d.locked = true;
+        if (rows && !op.confirm) {
+            const actions = {};
+            for (const r of rows)
+                if (r.$action)
+                    actions[r.$action] = (actions[r.$action] ?? 0) + 1;
+            d.actions = actions;
+        }
+    }
+    else if (op.kind === 'restore') {
+        d.expect = op.expect !== undefined ? op.expect.length : false;
+        if (op.partial)
+            d.partial = true;
+        if (rows) {
+            const skipped = rows.filter((r) => r.$action === 'skip');
+            d.restored = rows.length - skipped.length;
+            d.skipped = skipped.slice(0, LIST_MAX).map((r) => ({ id: r.id, why: r.$why }));
+            rows = rows.filter((r) => r.$action !== 'skip');
+        }
+    }
+    else if (rows && op.kind === 'upsert') {
+        const how = {};
+        for (const r of rows)
+            if (r.$upsert)
+                how[r.$upsert] = (how[r.$upsert] ?? 0) + 1;
+        d.upsert = how;
+    }
+    if (rows) {
+        d.classes = byClass(rows);
+        d.ids = idsOf(rows);
+    }
+    return d;
+}
+/** Событие терминала: read — без глаголов, иначе по последнему глаголу write, delete.preview, delete, restore. */
+function termEvent(log, steps, mods, name, args, st, r, ms) {
+    const ops = steps.flatMap((s) => (s.op ? [s.op] : []));
+    const rows = name === 'count' && typeof r === 'number' ? r : st.n;
+    if (!ops.length) {
+        if (!log.wants('read'))
+            return;
+        log.emit('read', { op: name, ms, ...(rows !== undefined ? { rows } : {}), chain: chainText(log, steps, mods, name, args),
+            ...(st.cache ? { detail: { cache: st.cache } } : {}) });
+        return;
+    }
+    const last = ops[ops.length - 1];
+    const event = last.kind === 'delete' ? (last.confirm ? 'delete' : 'delete.preview') : last.kind === 'restore' ? 'restore' : 'write';
+    // запись в db.begin() — в счётчик транзакции: по нему её tx.commit идёт уровнем info
+    log.mark(event);
+    if (!log.wants(event))
+        return;
+    log.emit(event, { op: [...new Set(ops.map((o) => o.kind))].join(','), ms, rows: st.rows ? st.rows.length : rows,
+        chain: chainText(log, steps, mods, name, args), detail: writeDetail(last, st.rows) });
+}
+/** Терминал под логгером: время, событие успеха и error с цепочкой; выключенный логгер — сам вызов. */
+async function traceTerm(ctx, steps, mods, name, args, fn) {
+    const log = ctx.log;
+    if (!log?.enabled)
+        return fn({});
+    const st = {};
+    const t0 = performance.now();
+    let r;
+    try {
+        r = await fn(st);
+    }
+    catch (e) {
+        log.error(e, { op: name, ms: performance.now() - t0, chain: chainText(log, steps, mods, name, args) });
+        throw e;
+    }
+    try {
+        termEvent(log, steps, mods, name, args, st, r, performance.now() - t0);
+    }
+    catch {
+        // событие не собралось — терминал всё равно отработал
+    }
+    return r;
 }
 /** Классы, которые читает цепочка (семейства шагов): по ним сбрасывается её ответ в кэше. */
 function readClasses(reg, steps) {
@@ -91,7 +377,7 @@ function cacheTtl(ctx, steps, mods, classes) {
         return null;
     return Math.min(...marks.map((m) => (m.ttl !== undefined ? m.ttl * 1000 : c.store.ttlMs)));
 }
-async function exec(ctx, q, mode, steps, mods = {}) {
+async function exec(ctx, q, mode, steps, mods = {}, st = {}) {
     const classes = ctx.cache ? readClasses(ctx.reg, steps) : [];
     const ttl = ctx.cache ? cacheTtl(ctx, steps, mods, classes) : null;
     if (ttl !== null) {
@@ -99,8 +385,16 @@ async function exec(ctx, q, mode, steps, mods = {}) {
         const who = ctx.cache.who();
         const key = store.key(q.text, q.params, who);
         const hit = store.get(key);
-        if (hit)
+        const log = ctx.log;
+        if (hit) {
+            st.cache = 'hit';
+            if (log?.wants('cache.hit'))
+                log.emit('cache.hit', { op: mode, rows: hit.length, chain: chainText(log, steps, mods, mode) });
             return hit;
+        }
+        st.cache = 'miss';
+        if (log?.wants('cache.miss'))
+            log.emit('cache.miss', { op: mode, chain: chainText(log, steps, mods, mode), detail: { ttl: ttl / 1000 } });
         const tag = sessionTag(who.token);
         const tok = store.token(classes, tag, who.tenant);
         const t0 = performance.now();
@@ -119,18 +413,24 @@ async function exec(ctx, q, mode, steps, mods = {}) {
     report(ctx, mode, steps, t0, res.length);
     return res;
 }
-async function read(ctx, steps, mods, mode, agg) {
+async function read(ctx, steps, mods, mode, agg, st = {}) {
     const hasOps = steps.some((s) => s.op);
     if (ctx.batch && hasOps)
-        throw new LetopisError('invalid_query', 'план стоит в очереди батча — его исполнит batch.run()');
+        throw lerr('api.batch_queued');
+    if (!hasOps)
+        warnWithDeleted(steps, ctx.log);
+    const counted = (r) => {
+        st.n = r.res.length;
+        return r;
+    };
     if (mods.forUpdate)
-        return lockedRead(ctx, steps, mods, mode);
+        return lockedRead(ctx, steps, mods, mode, agg).then(counted);
     if (hasOps)
-        return plan(ctx, steps, mods, mode, agg);
+        return plan(ctx, steps, mods, mode, agg, st).then(counted);
     const { cache: _c, ...plain } = mods;
     const q = buildRead(ctx.reg, ctx.schema, steps, plain, mode, agg);
     const ev = mode === 'countPaths' ? 'count' : mode;
-    return exec(ctx, q, ev, steps, mods).then((res) => ({ q, res }));
+    return exec(ctx, q, ev, steps, mods, st).then((res) => counted({ q, res }));
 }
 /** Модификатор выборки, заданный в mods, — именем метода цепочки; forUpdate() отказывает сам (lock_unsupported). */
 function modName(mods) {
@@ -138,14 +438,21 @@ function modName(mods) {
     return key === 'order' || key === 'desc' ? 'sort' : key;
 }
 function afterVerbError(name, verb) {
-    return new LetopisError('invalid_query', `${name}() после ${verb}() ни на что не действует: глагол проходит по всем целям шага, а ответ — его строки. ` +
-        `Цели сужают limit(), offset() и sort() до глагола: db.Класс(…).limit(n).${verb}(…)`);
+    return lerr('api.mod_after_verb', { name, verb });
+}
+/**
+ * Курсор after() листает строки, а count() и агрегаты чтения считают по всем объектам шага: раньше курсор там молча не
+ * учитывался, с 2.0 — invalid_query до запроса (план 2.0, этап 4, п. 2; 7.10 №7).
+ */
+function afterNotPaged(mods, fn) {
+    if (mods.after !== undefined)
+        throw lerr('api.after_not_paged', { fn });
 }
 /**
  * Терминалы rows, first, ids, count и paths цепочки, которая кончается глаголом, отдают строки самой правки.
  * Модификатор выборки между глаголом и терминалом ни на что не подействовал бы: limit резал бы только ответ, хотя
  * правка прошла по всем целям, остальные молча пропускались. Поэтому — отказ до записи. После глагола модификатор
- * относится к чтению за ним (шаг класса, versions(), diff(), blame(), агрегаты) или сужает цели следующего глагола.
+ * относится к чтению за ним (шаг класса, versions(), агрегаты) или сужает цели следующего глагола.
  */
 function checkAfterVerb(steps, mods) {
     const op = steps[steps.length - 1]?.op;
@@ -157,8 +464,13 @@ function checkAfterVerb(steps, mods) {
  * Цепочка с глаголами: весь план одной транзакцией (§2.5). Результат приводится к виду ответа
  * чтения (строки rows/paths, id, n, агрегаты), чтобы терминалы разбирали его одинаково.
  */
-async function plan(ctx, steps, mods, mode, agg) {
-    precheckPlan(ctx.reg, steps);
+async function plan(ctx, steps, mods, mode, agg, st = {}) {
+    try {
+        precheckPlan(ctx.reg, steps, mods.order, agg);
+    }
+    catch (e) {
+        throw await completeIssues(ctx, e);
+    }
     const t0 = performance.now();
     const r = await ctx.exec.run((q) => execPlan({ reg: ctx.reg, schema: ctx.schema, q, tenant: ctx.tenant(), owner: ctx.owner, ...reasons(ctx) }, steps, mods, mode, agg));
     if (r.kind === 'read') {
@@ -172,6 +484,7 @@ async function plan(ctx, steps, mods, mode, agg) {
         return r;
     }
     const rows = r.rows;
+    st.rows = rows;
     report(ctx, mode === 'countPaths' ? 'count' : mode === 'paths' ? 'paths' : mode === 'ids' ? 'ids' : 'rows', steps, t0, rows.length);
     // не switch: check-docs принимает case-метки этого файла за имена, которые Proxy разбирает раньше классов
     if (mode === 'paths')
@@ -189,12 +502,18 @@ async function plan(ctx, steps, mods, mode, agg) {
  * которая перестала подходить под условия шага, в ответ не попадает; подходящая, но не
  * заблокированная — acl_denied.
  */
-async function lockedRead(ctx, steps, mods, mode) {
+async function lockedRead(ctx, steps, mods, mode, agg) {
     if (!ctx.exec.explicit)
-        throw new LetopisError('tx_required', 'forUpdate() — только внутри db.begin(): вне явной транзакции блокировка снялась бы сразу');
-    if ((mode !== 'rows' && mode !== 'ids') || mods.asOf !== undefined || mods.withDeleted || steps.some((s) => s.deepMax !== undefined || s.op)) {
-        throw new LetopisError('lock_unsupported', 'forUpdate() — с терминалами rows, first, ids, без агрегатов, asOf, versions, withDeleted, deep и глаголов');
-    }
+        throw lerr('api.for_update_outside_tx');
+    // что именно мешает блокировке — в тексте, что допустимо — в подсказке (второй раунд 2.1, A7)
+    const op = steps.find((s) => s.op)?.op;
+    const what = op ? `${op.kind}()`
+        : mode !== 'rows' && mode !== 'ids' ? `${mode === 'agg' ? agg?.fn ?? 'agg' : mode === 'countPaths' ? 'count' : mode}()`
+            : mods.asOf !== undefined ? 'asOf()'
+                : steps.some((s) => s.withDeleted) ? 'withDeleted()'
+                    : steps.some((s) => s.deepMax !== undefined) ? 'deep()' : undefined;
+    if (what)
+        throw lerr('api.for_update_unsupported', { what });
     const S = `"${ctx.schema.replace(/"/g, '""')}"`;
     const { forUpdate: _f, ...plain } = mods;
     const idsQ = buildRead(ctx.reg, ctx.schema, steps, plain, 'ids');
@@ -205,40 +524,46 @@ async function lockedRead(ctx, steps, mods, mode) {
         const ids = (await q.unsafe(idsQ.text, idsQ.params, { prepare: true })).map((r) => r.id);
         if (!ids.length)
             return [];
-        const locked = new Set((await q.unsafe(`select id from ${S}.entity where id = any ($1::uuid[]) order by id for no key update`, [ids], { prepare: true })).map((r) => r.id));
+        const locked = await lockIds(q, S, ids);
         const want = new Set(ids);
         const fresh = (await q.unsafe(rowsQ.text, rowsQ.params, { prepare: true }))
             .filter((r) => want.has(r.row.id));
         const denied = fresh.filter((r) => !locked.has(r.row.id)).map((r) => r.row.id);
         if (denied.length)
-            throw new LetopisError('acl_denied', `строки видны, но заблокировать их нельзя: ${denied.join(', ')}`, { ids: denied });
+            throw lerr('api.lock_denied', { ids: denied.join(', ') }, { detail: { ids: denied } });
         return fresh;
     });
-    report(ctx, mode, steps, t0, res.length);
+    report(ctx, mode === 'ids' ? 'ids' : 'rows', steps, t0, res.length);
     return { q: rowsQ, res: mode === 'ids' ? res.map((r) => ({ id: r.row.id })) : res };
 }
+/**
+ * Промис versions(): методы цепочки на нём (versions().rows(), versions().sort()) — ошибка letopis с подсказкой, а не
+ * TypeError «… is not a function» (3.0). Сам промис уже идёт: его отказ гасится, иначе он ушёл бы в unhandledRejection.
+ */
+function versionsPromise(p) {
+    for (const method of CHAIN_METHODS) {
+        if (method === 'then')
+            continue;
+        Object.defineProperty(p, method, {
+            value: () => {
+                p.catch(() => { });
+                throw lerr('api.versions_terminal', { method });
+            },
+        });
+    }
+    return p;
+}
 /** Причины для плана: по умолчанию у глаголов (у батча — своя) и та, что стоит в транзакции. */
 const reasons = (ctx) => ({ reason: ctx.reason ?? ctx.txReason ?? '', txReason: ctx.txReason ?? '' });
 /** Опция reason глагола (план 1.1, §2.1): проверяет precheckPlan. */
 const reasonOf = (o) => (o?.reason !== undefined ? { reason: o.reason } : {});
-/** diff({ from, to }): номер версии (целое ≥ 1) или момент (ISO-строка, Date). */
-function versionRef(v, what, moments = true) {
-    if (typeof v === 'number' && Number.isInteger(v) && v >= 1 && v <= 2147483647)
-        return v;
-    if (moments && v instanceof Date && !Number.isNaN(+v))
-        return v.toISOString();
-    if (moments && typeof v === 'string' && !Number.isNaN(Date.parse(v)))
-        return v;
-    throw new LetopisError('invalid_query', `${what}: номер версии (целое ≥ 1)${moments ? ' или момент (ISO-строка, Date)' : ''}`);
-}
-/** blame({ at }): момент (ISO-строка, Date). */
-function momentOf(v, what) {
-    if (v instanceof Date && !Number.isNaN(+v))
-        return v.toISOString();
-    if (typeof v === 'string' && !Number.isNaN(Date.parse(v)))
-        return v;
-    throw new LetopisError('invalid_query', `${what}: момент — ISO-строка или Date`);
-}
+/**
+ * Опция all у update() и delete({ confirm: true }): правка всех целей без фильтра (план 2.0, этап 4, п. 2); у
+ * delete({ confirm: true }) и restore() ещё — без сверки с expect (3.0).
+ */
+const allOf = (o) => (o?.all === true ? { all: true } : {});
+/** Опция expect у restore() и delete({ confirm: true }) (план 2.1, A1, A2): форму проверяет precheckPlan. */
+const expectOf = (o) => (o?.expect !== undefined ? { expect: o.expect } : {});
 /** Строка ответа: из чтения — to_jsonb узла, из плана — готовая строка записи. */
 const rowOf = (r) => (r.done ? r.row : toRow(r.row));
 /** Значение слота: id, список id, строка ответа или ленивая цепочка. */
@@ -255,11 +580,19 @@ function slotValue(v) {
         return v.map((x) => (typeof x === 'string' ? x : x.id));
     if (typeof v === 'object' && typeof v.id === 'string')
         return { id: v.id };
-    throw new LetopisError('invalid_query', 'значение слота — id, список id, строка ответа или цепочка');
+    throw lerr('api.slot_value');
 }
 function classProp(ctx, name, found, ownerSteps, mods, nodes) {
     const { cls, role } = found;
-    const step = (filter) => {
+    const step = (...args) => {
+        const filter = args[0];
+        // A13: X(undefined) — фильтра нет, шаг найдёт все строки (как X()); чаще всего это пустая переменная с id
+        if (args.length && filter === undefined)
+            lwarn('api.step_undefined_filter', { name }, { once: `undefined-filter|${name}`, log: ctx.log });
+        // A13: sort() относится к последнему шагу цепочки — шаг после него забирает сортировку себе
+        if (ownerSteps && mods.order !== undefined) {
+            lwarn('api.sort_not_last', { field: mods.order, step: name }, { once: `sort-not-last|${mods.order}|${name}`, log: ctx.log });
+        }
         const prev = ownerSteps?.[ownerSteps.length - 1];
         // повтор связи в пути — возврат к её узлу
         const node = prev && cls.kind === 'link' && !role ? pivotNodeOf(ownerSteps, cls.name) : undefined;
@@ -276,16 +609,16 @@ function classProp(ctx, name, found, ownerSteps, mods, nodes) {
         const last = ownerSteps?.[ownerSteps.length - 1];
         const kind = last?.op?.kind;
         if (!last || (kind !== 'create' && kind !== 'update' && kind !== 'upsert')) {
-            throw new LetopisError('invalid_query', `слот .${name}.${op}() — после create(), update() или upsert(): db.Класс(…).update(…).${name}.${op}(…)`);
+            throw lerr('api.slot_without_write', { name, op });
         }
         const role = slotRole(ctx.reg, last.cls, name);
         const end = last.cls.ends[role];
         if ((op === 'add' || op === 'remove') && !end.many)
-            throw new LetopisError('invalid_query', `слот .${name}.${op}(): конец ${role} одиночный — set() или unset()`);
+            throw lerr('api.slot_single', { name, op, role });
         if (op === 'unset' && (end.required || (end.min ?? 0) > 0))
-            throw new LetopisError('invalid_query', `слот .${name}.unset(): конец ${role} обязателен`);
+            throw lerr('api.slot_required', { name, role });
         if ((op === 'set' || op === 'unset') && last.slots?.some((x) => x.role === role && (x.op === 'set' || x.op === 'unset'))) {
-            throw new LetopisError('invalid_query', `слот ${role} задан дважды в одной записи`);
+            throw lerr('api.slot_twice', { role });
         }
         const value = op === 'unset' ? null : slotValue(v);
         const next = ownerSteps.slice();
@@ -294,10 +627,16 @@ function classProp(ctx, name, found, ownerSteps, mods, nodes) {
             ctx.batch.entry.steps = next;
         return makeChain(ctx, next, mods, nodes);
     };
-    return new Proxy(step, {
+    // ошибка шага или слота (переход, слот без глагола, …) — событие error с цепочкой до него
+    const log = ctx.log;
+    const g = (op, fn) => (log?.enabled
+        ? (...a) => guarded(log, () => ({ op, chain: chainText(log, ownerSteps ?? [], mods) }), () => fn(...a))
+        : fn);
+    const stepFn = g(name, step);
+    return new Proxy(stepFn, {
         get(t, p, r) {
             if (p === 'set' || p === 'unset' || p === 'add' || p === 'remove')
-                return slot(p);
+                return g(`${name}.${p}`, slot(p));
             return Reflect.get(t, p, r);
         },
     });
@@ -313,7 +652,7 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
     const withLast = (patch) => {
         const lastOp = steps[steps.length - 1]?.op;
         if (lastOp)
-            throw new LetopisError('invalid_query', `модификатор шага после ${lastOp.kind}() — сначала шаг класса`);
+            throw lerr('api.step_mod_after_verb', { verb: lastOp.kind });
         const next = steps.slice();
         next[next.length - 1] = { ...steps[steps.length - 1], ...patch };
         return makeChain(ctx, next, mods, nodes);
@@ -335,7 +674,7 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
     const withOp = (op) => {
         const last = steps[steps.length - 1];
         if (!last)
-            throw new LetopisError('invalid_query', `${op.kind}() — нужен шаг класса: db.Класс(…).${op.kind}(…)`);
+            throw lerr('api.verb_without_step', { verb: op.kind });
         // батч: причина db.batch(имя, { reason }) — при постановке в очередь, а не при run(): очередь общая по имени, и
         // run() может позвать фасад без причины или с другой (ревью №1 точки А плана 1.1)
         if (ctx.batch && op.reason === undefined && ctx.reason !== undefined)
@@ -350,7 +689,7 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
         const plan = peekPlan(x);
         const prev = steps.length ? nodeOf(steps, steps[steps.length - 1]) : undefined;
         if (plan?.steps.some((s) => s.op))
-            throw new LetopisError('invalid_query', 'entity() принимает читающий паттерн — цепочку с глаголами вклеить нельзя');
+            throw lerr('api.entity_with_verbs');
         if (plan) {
             const known = nodes.get(x);
             if (known !== undefined) {
@@ -372,10 +711,13 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
                 resolveHop(ctx.reg, prev, next);
             return makeChain(ctx, [...steps, next], mods, nodes);
         }
-        throw new LetopisError('invalid_query', 'entity() принимает ленивую цепочку или строку ответа');
+        throw lerr('api.entity_arg');
     };
-    const agg = (fn) => async (field) => {
-        const { q, res } = await read(ctx, steps, mods, 'agg', { fn, field });
+    /** Терминал: время, событие (read, write, delete, restore) и error — traceTerm. */
+    const term = (name, fn) => (...a) => traceTerm(ctx, steps, mods, name, a, (st) => fn(st, ...a));
+    const agg = (fn) => term(fn, async (st, field) => {
+        afterNotPaged(mods, fn);
+        const { q, res } = await read(ctx, steps, mods, 'agg', { fn, field }, st);
         if (fn === 'countBy')
             return Object.fromEntries(res.map((r) => [r.k ?? 'null', r.n]));
         const v = res[0]?.v;
@@ -386,151 +728,131 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
         if (fn === 'sum' || fn === 'avg' || q?.aggLeaf === 'numeric')
             return Number(v);
         return v;
+    });
+    /** Свойство цепочки: метод или модификатор — функция, иначе шаг класса, алиаса или роли. */
+    const member = (prop) => {
+        switch (prop) {
+            case 'then':
+                return undefined;
+            case 'entity':
+                return entityStep;
+            case 'paths':
+                return term('paths', async (st) => {
+                    checkAfterVerb(steps, mods);
+                    // q === null — пути из результата глагола: строки уже готовы. Ключи — в порядке шагов (jsonb хранит их
+                    // по длине), узел последнего шага — последним: по нему cursorOf(путь, поле) берёт курсор (план 2.0, 7.1 №3)
+                    const { q, res } = await read(ctx, steps, mods, 'paths', undefined, st);
+                    if (q === null)
+                        return res.map((r) => r.path);
+                    return res.map((r) => Object.fromEntries(q.keys.map((k) => [k, toRow(r.path[k])])));
+                });
+            case 'rows':
+                return term('rows', async (st) => {
+                    checkAfterVerb(steps, mods);
+                    return (await read(ctx, steps, mods, 'rows', undefined, st)).res.map(rowOf);
+                });
+            case 'first':
+                return term('first', async (st) => {
+                    checkAfterVerb(steps, mods);
+                    const { res } = await read(ctx, steps, { ...mods, limit: 1 }, 'rows', undefined, st);
+                    return res[0] ? rowOf(res[0]) : null;
+                });
+            case 'ids':
+                return term('ids', async (st) => {
+                    checkAfterVerb(steps, mods);
+                    return (await read(ctx, steps, mods, 'ids', undefined, st)).res.map((r) => r.id);
+                });
+            case 'count':
+                return term('count', async (st, opts) => {
+                    checkAfterVerb(steps, mods);
+                    afterNotPaged(mods, 'count');
+                    return (await read(ctx, steps, mods, opts?.paths ? 'countPaths' : 'count', undefined, st)).res[0].n;
+                });
+            case 'versions':
+                return (...a) => versionsPromise(term('versions', async (st) => {
+                    warnNoHistory(steps, 'versions', ctx.log);
+                    return (await read(ctx, steps, mods, 'versions', undefined, st)).res.map((r) => toRow(r.row));
+                })(...a));
+            case 'sum':
+            case 'avg':
+            case 'min':
+            case 'max':
+            case 'countBy':
+                return agg(prop);
+            case 'limit':
+                return (n) => withMods({ limit: n });
+            case 'offset':
+                return (n) => withMods({ offset: n });
+            case 'sort':
+                return (field, dir) => withMods({ order: field, desc: dir === true || dir === 'desc' });
+            case 'asOf':
+                return (t) => {
+                    warnNoHistory(steps, 'asOf', ctx.log);
+                    return withMods({ asOf: t instanceof Date ? t.toISOString() : t });
+                };
+            case 'after':
+                return (cursor) => withMods({ after: cursor });
+            case 'withDeleted':
+                // модификатор своего шага (план 2.1, A9): X(id).withDeleted().Y().withDeleted() — удалённые Y удалённого X
+                return () => withLast({ withDeleted: true });
+            case 'deep':
+                return (max = 32) => withLast({ deepMax: max });
+            case 'exact':
+                return () => withLast({ exact: true });
+            case 'alias':
+                return (name) => withLast({ aliasKey: name });
+            case 'tags':
+                return (v) => withLast({ tagsFilter: v });
+            case 'owner':
+                return (v) => withLast({ ownerFilter: typeof v === 'object' ? v.id : v });
+            // глаголы записи — звенья плана (этап 4)
+            case 'create':
+                return (data = {}, opts) => withOp({ kind: 'create', data: dropUndefined(data), ...reasonOf(opts) });
+            case 'update':
+                return (data = {}, opts) => withOp({ kind: 'update', data, ...(opts?.rev !== undefined ? { rev: opts.rev } : {}), ...allOf(opts), ...reasonOf(opts) });
+            case 'upsert':
+                return (data = {}, opts) => withOp({ kind: 'upsert', data: dropUndefined(data), ...reasonOf(opts) });
+            case 'delete':
+                return (opts) => withOp({ kind: 'delete', confirm: opts?.confirm === true, ...allOf(opts), ...reasonOf(opts), ...expectOf(opts) });
+            case 'set':
+            case 'unset':
+            case 'add':
+            case 'remove':
+                throw lerr('api.slot_method', { method: prop });
+            case 'forUpdate':
+                return () => withMods({ forUpdate: true });
+            case 'restore':
+                return (opts) => withOp({ kind: 'restore', ...allOf(opts), ...reasonOf(opts), ...expectOf(opts), ...(opts?.partial === true ? { partial: true } : {}) });
+            case 'cache':
+                return (opts) => {
+                    if (opts?.ttl !== undefined && !(opts.ttl > 0))
+                        throw lerr('api.cache_ttl');
+                    return withMods({ cache: opts ?? {} });
+                };
+        }
+        const found = lookupStep(ctx.reg, prop);
+        if (!found && noSession(ctx, prop))
+            return sessionless();
+        return classProp(ctx, prop, found ?? unknownName(ctx.reg, prop), steps, mods, nodes);
     };
+    const log = ctx.log;
     const handler = {
         get(_t, prop) {
             if (prop === PLAN)
                 return { steps, mods };
+            if (prop === Symbol.iterator)
+                return notIterable;
             if (typeof prop === 'symbol')
                 return undefined;
-            switch (prop) {
-                case 'then':
-                    return undefined;
-                case 'entity':
-                    return entityStep;
-                case 'paths':
-                    return async () => {
-                        checkAfterVerb(steps, mods);
-                        // q === null — пути из результата глагола: строки уже готовы. Ключи — в порядке шагов (jsonb хранит их
-                        // по длине), узел последнего шага — последним: по нему cursorOf(путь, поле) берёт курсор (план 2.0, 7.1 №3)
-                        const { q, res } = await read(ctx, steps, mods, 'paths');
-                        if (q === null)
-                            return res.map((r) => r.path);
-                        return res.map((r) => Object.fromEntries(q.keys.map((k) => [k, toRow(r.path[k])])));
-                    };
-                case 'rows':
-                    return async () => {
-                        checkAfterVerb(steps, mods);
-                        return (await read(ctx, steps, mods, 'rows')).res.map(rowOf);
-                    };
-                case 'first':
-                    return async () => {
-                        checkAfterVerb(steps, mods);
-                        const { res } = await read(ctx, steps, { ...mods, limit: 1 }, 'rows');
-                        return res[0] ? rowOf(res[0]) : null;
-                    };
-                case 'ids':
-                    return async () => {
-                        checkAfterVerb(steps, mods);
-                        return (await read(ctx, steps, mods, 'ids')).res.map((r) => r.id);
-                    };
-                case 'count':
-                    return async (opts) => {
-                        checkAfterVerb(steps, mods);
-                        return (await read(ctx, steps, mods, opts?.paths ? 'countPaths' : 'count')).res[0].n;
-                    };
-                case 'versions':
-                    return async (opts) => {
-                        warnNoHistory(steps, 'versions');
-                        const m = opts?.follow ? { ...mods, follow: true } : mods;
-                        return (await read(ctx, steps, m, 'versions')).res.map((r) => toRow(r.row));
-                    };
-                case 'diff':
-                    return async (opts = {}) => {
-                        warnNoHistory(steps, 'diff');
-                        const hist = {
-                            ...(opts.from !== undefined ? { from: versionRef(opts.from, 'diff({ from })') } : {}),
-                            ...(opts.to !== undefined ? { to: versionRef(opts.to, 'diff({ to })') } : {}),
-                            ...(opts.follow ? { follow: true } : {}),
-                        };
-                        return (await read(ctx, steps, { ...mods, hist }, 'diff')).res.map((r) => r.row);
-                    };
-                case 'blame':
-                    return async (opts = {}) => {
-                        warnNoHistory(steps, 'blame');
-                        if (opts.limit !== undefined)
-                            versionRef(opts.limit, 'blame({ limit })', false);
-                        const hist = {
-                            ...(opts.at !== undefined ? { at: momentOf(opts.at, 'blame({ at })') } : {}),
-                            ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
-                        };
-                        // null — объекта на момент at не было (или он не виден)
-                        return (await read(ctx, steps, { ...mods, hist }, 'blame')).res
-                            .map((r) => r.row).filter((x) => x !== null);
-                    };
-                case 'sum':
-                case 'avg':
-                case 'min':
-                case 'max':
-                case 'countBy':
-                    return agg(prop);
-                case 'limit':
-                    return (n) => withMods({ limit: n });
-                case 'offset':
-                    return (n) => withMods({ offset: n });
-                case 'sort':
-                    return (field, dir) => withMods({ order: field, desc: dir === true || dir === 'desc' });
-                case 'asOf':
-                    return (t) => {
-                        warnNoHistory(steps, 'asOf');
-                        return withMods({ asOf: t instanceof Date ? t.toISOString() : t });
-                    };
-                case 'after':
-                    return (cursor) => withMods({ after: cursor });
-                case 'withDeleted':
-                    return () => withMods({ withDeleted: true });
-                case 'deep':
-                    return (max = 32) => withLast({ deepMax: max });
-                case 'exact':
-                    return () => withLast({ exact: true });
-                case 'alias':
-                    return (name) => withLast({ aliasKey: name });
-                case 'tags':
-                    return (v) => withLast({ tagsFilter: v });
-                case 'owner':
-                    return (v) => withLast({ ownerFilter: typeof v === 'object' ? v.id : v });
-                // охранники снесённого API (этап 3, п. 11)
-                case 'run':
-                    throw removed('run()', 'paths()');
-                case 'execute':
-                    throw removed('execute()', 'paths()');
-                case 'account':
-                    throw removed('account()', 'арендатор сессии и auth.switch() (этап 5)');
-                // глаголы записи — звенья плана (этап 4)
-                case 'create':
-                    return (data = {}, opts) => withOp({ kind: 'create', data, ...reasonOf(opts) });
-                case 'update':
-                    return (data = {}, opts) => withOp({ kind: 'update', data, ...(opts?.rev !== undefined ? { rev: opts.rev } : {}), ...reasonOf(opts) });
-                case 'upsert':
-                    return (data = {}, opts) => withOp({ kind: 'upsert', data, ...reasonOf(opts) });
-                case 'delete':
-                    return (opts) => withOp({ kind: 'delete', confirm: opts?.confirm === true, ...reasonOf(opts) });
-                case 'anonymize':
-                    return (fields, opts) => withOp({ kind: 'anonymize', fields, ...reasonOf(opts) });
-                case 'reclass':
-                    return (cls, data, opts) => withOp({ kind: 'reclass', cls, ...(data !== undefined ? { data } : {}), ...reasonOf(opts) });
-                case 'set':
-                case 'unset':
-                case 'add':
-                case 'remove':
-                    throw new LetopisError('invalid_query', `${prop}() — метод слота: db.Класс(…).update(…).Роль.${prop}(…)`);
-                case 'forUpdate':
-                    return () => withMods({ forUpdate: true });
-                case 'restore':
-                    return (opts) => withOp({ kind: 'restore', ...reasonOf(opts) });
-                case 'purge':
-                    return (opts) => withOp({ kind: 'purge', confirm: opts?.confirm === true, ...reasonOf(opts) });
-                case 'rekey':
-                    return (patch, opts) => withOp({ kind: 'rekey', data: patch ?? {}, ...reasonOf(opts) });
-                case 'cache':
-                    return (opts) => {
-                        if (opts?.ttl !== undefined && !(opts.ttl > 0))
-                            throw new LetopisError('invalid_query', 'cache({ ttl }): срок — положительное число секунд');
-                        return withMods({ cache: opts ?? {} });
-                    };
-            }
-            const found = lookupStep(ctx.reg, prop) ?? unknownName(prop);
-            return classProp(ctx, prop, found, steps, mods, nodes);
+            if (!log?.enabled)
+                return member(prop);
+            // ошибка имени (неизвестный шаг, слот как метод) и модификатора или глагола (после глагола, неверный аргумент) —
+            // событие error с цепочкой до него; терминалы пишут свои события сами (traceTerm)
+            const where = () => ({ op: prop, chain: chainText(log, steps, mods) });
+            const got = guarded(log, where, () => member(prop));
+            return typeof got === 'function' && GUARDED.has(prop)
+                ? (...a) => guarded(log, where, () => got(...a))
+                : got;
         },
     };
     return new Proxy({}, handler);
@@ -541,39 +863,50 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
  * и общей с другими фасадами быть не может: иначе план исполнился бы от имени чужого актора.
  */
 export function makeBatch(ctx, queue) {
+    const member = (prop) => {
+        switch (prop) {
+            case 'run':
+                return () => traced(ctx.log ?? NOLOG, 'write', { op: 'batch' }, async () => {
+                    const entries = queue.splice(0, queue.length);
+                    const loose = entries.find((x) => x.loose)?.loose;
+                    if (loose)
+                        throw afterVerbError(loose.name, loose.verb);
+                    const plans = entries.map((x) => x.steps);
+                    try {
+                        for (const p of plans)
+                            precheckPlan(ctx.reg, p);
+                    }
+                    catch (e) {
+                        throw await completeIssues(ctx, e);
+                    }
+                    if (!plans.length)
+                        return [];
+                    return ctx.exec.run((q) => execBatch({ reg: ctx.reg, schema: ctx.schema, q, tenant: ctx.tenant(), owner: ctx.owner, ...reasons(ctx) }, plans));
+                }, (out) => {
+                    const rows = out.flat();
+                    return { rows: rows.length, detail: { plans: out.length, classes: byClass(rows), ids: idsOf(rows) } };
+                });
+            case 'discard':
+                return () => void queue.splice(0, queue.length);
+            case 'size':
+                return () => queue.length;
+        }
+        return startStep({ ...ctx, batch: { queue } }, prop);
+    };
     return new Proxy({}, {
         get(_t, prop) {
             if (typeof prop === 'symbol' || prop === 'then')
                 return undefined;
-            switch (prop) {
-                case 'run':
-                    return async () => {
-                        const entries = queue.splice(0, queue.length);
-                        const loose = entries.find((x) => x.loose)?.loose;
-                        if (loose)
-                            throw afterVerbError(loose.name, loose.verb);
-                        const plans = entries.map((x) => x.steps);
-                        for (const p of plans)
-                            precheckPlan(ctx.reg, p);
-                        if (!plans.length)
-                            return [];
-                        return ctx.exec.run((q) => execBatch({ reg: ctx.reg, schema: ctx.schema, q, tenant: ctx.tenant(), owner: ctx.owner, ...reasons(ctx) }, plans));
-                    };
-                case 'execute':
-                    throw removed('batch.execute()', 'batch.run()');
-                case 'discard':
-                    return () => void queue.splice(0, queue.length);
-                case 'size':
-                    return () => queue.length;
-            }
-            return startStep({ ...ctx, batch: { queue } }, prop);
+            return member(prop);
         },
     });
 }
 /** Старт пути от корня db: класс, алиас или роль. */
 export function startStep(ctx, name) {
-    const found = lookupStep(ctx.reg, name) ?? unknownName(name);
-    return classProp(ctx, name, found, undefined, {}, NO_NODES);
+    const found = lookupStep(ctx.reg, name);
+    if (!found && noSession(ctx, name))
+        return sessionless();
+    return classProp(ctx, name, found ?? unknownName(ctx.reg, name), undefined, {}, NO_NODES);
 }
 /** Старт пути с готового узла: db.entity(row | цепочка). */
 export function startEntity(ctx, x) {