letopis 1.4.1 → 2.0.0

package/dist/chain.js

@@ -7,12 +7,12 @@
  * узлу (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';
@@ -38,8 +38,11 @@ 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} не найдены`);
+/** Имена, которыми начинается шаг: классы, их алиасы и роли концов реестра. */
+const stepNames = (reg) => reg.all().flatMap((c) => [c.name, ...(c.alias ? [c.alias] : []), ...Object.keys(c.ends)]);
+/** Неизвестный класс или роль — с похожими именами реестра (план 2.0, 7.9 №6). */
+const unknownName = (reg, name) => {
+    throw lerr('api.unknown_step', { name, similar: similar(name, stepNames(reg)) });
 };
 const nodeOf = (steps, s) => s.pivotKey === undefined ? s : steps.find((x) => x.nodeKey === s.pivotKey) ?? s;
 /** Узел для возврата: последний реальный шаг того же класса-связи в текущем читающем сегменте. */
@@ -62,7 +65,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 });
 }
 function report(ctx, mode, steps, t0, rows) {
     if (!ctx.onQuery && ctx.slowMs === undefined)
@@ -73,7 +76,7 @@ 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('→') });
 }
 /** Классы, которые читает цепочка (семейства шагов): по ним сбрасывается её ответ в кэше. */
 function readClasses(reg, steps) {
@@ -122,7 +125,7 @@ async function exec(ctx, q, mode, steps, mods = {}) {
 async function read(ctx, steps, mods, mode, agg) {
     const hasOps = steps.some((s) => s.op);
     if (ctx.batch && hasOps)
-        throw new LetopisError('invalid_query', 'план стоит в очереди батча — его исполнит batch.run()');
+        throw lerr('api.batch_queued');
     if (mods.forUpdate)
         return lockedRead(ctx, steps, mods, mode);
     if (hasOps)
@@ -138,14 +141,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;
@@ -158,7 +168,7 @@ function checkAfterVerb(steps, mods) {
  * чтения (строки rows/paths, id, n, агрегаты), чтобы терминалы разбирали его одинаково.
  */
 async function plan(ctx, steps, mods, mode, agg) {
-    precheckPlan(ctx.reg, steps);
+    precheckPlan(ctx.reg, steps, mods.order, agg);
     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') {
@@ -191,9 +201,9 @@ async function plan(ctx, steps, mods, mode, agg) {
  */
 async function lockedRead(ctx, steps, mods, mode) {
     if (!ctx.exec.explicit)
-        throw new LetopisError('tx_required', 'forUpdate() — только внутри db.begin(): вне явной транзакции блокировка снялась бы сразу');
+        throw lerr('api.for_update_outside_tx');
     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_unsupported');
     }
     const S = `"${ctx.schema.replace(/"/g, '""')}"`;
     const { forUpdate: _f, ...plain } = mods;
@@ -211,7 +221,7 @@ async function lockedRead(ctx, steps, mods, mode) {
             .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);
@@ -221,38 +231,25 @@ async function lockedRead(ctx, steps, mods, mode) {
 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). */
+const allOf = (o) => (o?.all === true ? { all: true } : {});
 /** Строка ответа: из чтения — to_jsonb узла, из плана — готовая строка записи. */
 const rowOf = (r) => (r.done ? r.row : toRow(r.row));
 /** Значение слота: id, список id, строка ответа или ленивая цепочка. */
 function slotValue(v) {
     const peek = peekPlan(v);
-    if (peek)
+    if (peek) {
+        // модификатор сразу после глагола вложенной цепочки — тот же отказ, что у терминала (план 2.0, 7.2 №3)
+        checkAfterVerb(peek.steps, peek.mods);
         return { plan: peek.steps, mods: peek.mods };
+    }
     if (v === null || typeof v === 'string')
         return v;
     if (Array.isArray(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;
@@ -273,16 +270,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();
@@ -310,7 +307,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);
@@ -332,7 +329,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)
@@ -347,7 +344,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) {
@@ -369,9 +366,10 @@ 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) => {
+        afterNotPaged(mods, fn);
         const { q, res } = await read(ctx, steps, mods, 'agg', { fn, field });
         if (fn === 'countBy')
             return Object.fromEntries(res.map((r) => [r.k ?? 'null', r.n]));
@@ -384,147 +382,116 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
             return Number(v);
         return v;
     };
+    /** Свойство цепочки: метод или модификатор — функция, иначе шаг класса, алиаса или роли. */
+    const member = (prop) => {
+        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);
+                    afterNotPaged(mods, 'count');
+                    return (await read(ctx, steps, mods, opts?.paths ? 'countPaths' : 'count')).res[0].n;
+                };
+            case 'versions':
+                return async () => {
+                    warnNoHistory(steps, 'versions');
+                    return (await read(ctx, steps, mods, 'versions')).res.map((r) => toRow(r.row));
+                };
+            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 });
+            // глаголы записи — звенья плана (этап 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 } : {}), ...allOf(opts), ...reasonOf(opts) });
+            case 'upsert':
+                return (data = {}, opts) => withOp({ kind: 'upsert', data, ...reasonOf(opts) });
+            case 'delete':
+                return (opts) => withOp({ kind: 'delete', confirm: opts?.confirm === true, ...allOf(opts), ...reasonOf(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', ...reasonOf(opts) });
+            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) ?? unknownName(ctx.reg, prop);
+        return classProp(ctx, prop, found, steps, mods, nodes);
+    };
     const handler = {
         get(_t, prop) {
             if (prop === PLAN)
                 return { steps, mods };
             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 — пути из результата глагола: строки уже готовы
-                        const { q, res } = await read(ctx, steps, mods, 'paths');
-                        return res.map((r) => Object.fromEntries(Object.entries(r.path).map(([k, v]) => [k, q === null ? v : toRow(v)])));
-                    };
-                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);
+            return member(prop);
         },
     };
     return new Proxy({}, handler);
@@ -535,38 +502,39 @@ export function makeChain(ctx, steps, mods, nodes = NO_NODES) {
  * и общей с другими фасадами быть не может: иначе план исполнился бы от имени чужого актора.
  */
 export function makeBatch(ctx, queue) {
+    const member = (prop) => {
+        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 '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);
+    const found = lookupStep(ctx.reg, name) ?? unknownName(ctx.reg, name);
     return classProp(ctx, name, found, undefined, {}, NO_NODES);
 }
 /** Старт пути с готового узла: db.entity(row | цепочка). */