letopis 1.4.1 → 2.0.0

package/sql/60-write.sql

@@ -10,9 +10,9 @@ create or replace function @SCHEMA@.now_ts() returns timestamptz
 language sql volatile
 return clock_timestamp();
 
--- Внутренние блокировки (семейства, проектор, обслуживание) — строки-замки: строки вида LOCK таблицы secret, которой у
+-- Внутренние блокировки (семейства, обслуживание) — строки-замки: строки вида LOCK таблицы secret, которой у
 -- приложения нет, а не advisory-блокировки. Advisory-блокировку берёт любая роль базы, а её ключ виден всем в pg_locks:
--- посторонняя роль занимала бы её и останавливала запись семейства, проектор или обслуживание для всех (ревью
+-- посторонняя роль занимала бы её и останавливала запись семейства или обслуживание для всех (ревью
 -- безопасности №3, №2). id строки-замка — lock_id имени; строки семейств заводятся заранее (class_admit, seed_system),
 -- иначе строку вставляет первое обращение — и параллельное ждёт его транзакцию.
 -- lock_id — первые 16 байт sha256 имени: его считает каждая строка записи, а v5_id собирает jsonb и зовёт pgcrypto.
@@ -34,18 +34,14 @@ begin
     insert into @SCHEMA@.secret (id, account, kind, meta) values (v, '@SYSTEM@'::uuid, 'LOCK', jsonb_build_object('name', p_name))
     on conflict do nothing;
     if not exists (select 1 from @SCHEMA@.secret s where s.id = v) then
-      raise exception using errcode = 'XX000', message = format('строка-замок %s не создана', p_name);
+      -- внутренняя ошибка (SQLSTATE XX000) по ключу каталога: библиотека отдаёт её кодом internal (fromDbError)
+      perform @SCHEMA@.lt_raise('XX000', 'sql-write.lock_row_not_created', jsonb_build_object('name', p_name), 'null'::jsonb);
     end if;
   end if;
   return v;
 end $$;
 
--- Строки вида LOCK других аккаунтов — не строки-замки: в 1.1 вид LOCK был открыт функциям кредов. При накате они
--- помечаются удалёнными; повторный накат их уже не находит.
-update @SCHEMA@.secret s set deleted_at = clock_timestamp()
-where s.kind = 'LOCK' and s.account <> '@SYSTEM@'::uuid and s.deleted_at is null;
-
--- Строка-замок без ожидания (обслуживание и проектор — один исполнитель): true — взята до конца транзакции, false — её
+-- Строка-замок без ожидания (обслуживание — один исполнитель): true — взята до конца транзакции, false — её
 -- держит другая транзакция. Блокировка — отдельным оператором: строку, которую вставила lock_row, видит уже он.
 create or replace function @SCHEMA@.lock_try(p_name text) returns boolean
 language plpgsql volatile
@@ -59,8 +55,8 @@ begin
 end $$;
 
 -- Блокировки семейства (этап 1, п. 10): писатели и загрузчик берут разделяемую блокировку корня семейства, ужесточение
--- описания и rekeyClass — исключительную. Имя — арендатор корневого класса и имя корня (итоговое ревью безопасности):
--- ужесточение или rekeyClass одноимённого класса в другом арендаторе запись сюда не останавливает; корень из System
+-- описания и удаление класса — исключительную. Имя — арендатор корневого класса и имя корня (итоговое ревью
+-- безопасности): ужесточение одноимённого класса в другом арендаторе запись сюда не останавливает; корень из System
 -- (общий для всех арендаторов) — арендатор System. p_data — описание класса с resolved.
 create or replace function @SCHEMA@.family_name(p_tenant uuid, p_data jsonb) returns text
 language sql stable
@@ -104,7 +100,7 @@ begin
     perform @SCHEMA@.lock_row(n);
     perform 1 from @SCHEMA@.secret s where s.id = k for update;
     if not found then
-      raise exception using errcode = 'XX000', message = format('строка-замок %s не найдена', n);
+      perform @SCHEMA@.lt_raise('XX000', 'sql-write.lock_row_not_found', jsonb_build_object('name', n), 'null'::jsonb);
     end if;
   else
     if strpos(held, '|' || n || '|') = 0 then
@@ -121,7 +117,7 @@ begin
       perform @SCHEMA@.lock_row(n);
       perform 1 from @SCHEMA@.secret s where s.id = k for key share;
       if not found then
-        raise exception using errcode = 'XX000', message = format('строка-замок %s не найдена', n);
+        perform @SCHEMA@.lt_raise('XX000', 'sql-write.lock_row_not_found', jsonb_build_object('name', n), 'null'::jsonb);
       end if;
     end if;
   end if;
@@ -129,8 +125,6 @@ begin
     perform set_config('letopis.family_locks', held || '|' || n || '|', true);
   end if;
 end $$;
--- до итогового ревью безопасности ключ был без арендатора
-drop function if exists @SCHEMA@.family_lock(text, boolean);
 
 -- Список классов конца: строка или массив строк → отсортированный jsonb-массив.
 create or replace function @SCHEMA@.class_set(p jsonb) returns jsonb
@@ -195,8 +189,9 @@ end $$;
 -- Разбор и нормализация концов (этап 1, п. 7): объявлены, обязательные на месте, у множественных
 -- нет повторов, соблюдены min и max; uuid — в каноническом виде строчными. К таблицам не обращается:
 -- цели проверяет targets_bad() — триггером после оператора, одним запросом на все строки.
--- Ошибку не бросает: возвращает код и сообщение.
-create or replace function @SCHEMA@.links_shape(p_res jsonb, p_links jsonb, out links jsonb, out code text, out msg text)
+-- Ошибку не бросает: возвращает ключ каталога сообщений и параметры отказа (план 2.0, этап 3, п. 3; вызывающий бросает
+-- ошибку по ним).
+create or replace function @SCHEMA@.links_shape(p_res jsonb, p_links jsonb, out links jsonb, out key text, out params jsonb)
 language plpgsql immutable
 as $$
 #variable_conflict use_variable
@@ -212,47 +207,48 @@ begin
     p_links := '{}'::jsonb;
   end if;
   if jsonb_typeof(p_links) <> 'object' then
-    code := 'invalid_data'; msg := 'links — не объект'; return;
+    key := 'sql-write.links_not_object'; params := '{}'::jsonb; return;
   end if;
-  for l in select key, value from jsonb_each(p_links) loop
+  -- столбцы jsonb_each — с псевдонимом: key — ещё и выходной параметр (variable_conflict use_variable)
+  for l in select j.key, j.value from jsonb_each(p_links) j loop
     if not coalesce(p_res->'ends' ? l.key, false) then
-      code := 'undeclared_end'; msg := format('конец %s не объявлен в классе %s', l.key, p_res->>'name'); return;
+      key := 'sql-write.end_undeclared'; params := jsonb_build_object('end', l.key, 'cls', p_res->>'name'); return;
     end if;
     continue when l.value = 'null'::jsonb;
     if coalesce((p_res->'ends'->l.key->>'many')::boolean, false) then
       if jsonb_typeof(l.value) <> 'array' then
-        code := 'invalid_data'; msg := format('конец %s — список id', l.key); return;
+        key := 'sql-write.end_not_list'; params := jsonb_build_object('end', l.key); return;
       end if;
       arr := '[]'::jsonb;
       for v in select value from jsonb_array_elements(l.value) loop
         if jsonb_typeof(v) <> 'string' or not pg_input_is_valid(v #>> '{}', 'uuid') then
-          code := 'invalid_data'; msg := format('конец %s: значение не uuid', l.key); return;
+          key := 'sql-write.end_not_uuid'; params := jsonb_build_object('end', l.key); return;
         end if;
         v := to_jsonb((v #>> '{}')::uuid::text);
         if arr @> jsonb_build_array(v) then
-          code := 'invalid_data'; msg := format('конец %s: цель повторяется', l.key); return;
+          key := 'sql-write.end_target_repeated'; params := jsonb_build_object('end', l.key); return;
         end if;
         arr := arr || jsonb_build_array(v);
       end loop;
       links := links || jsonb_build_object(l.key, arr);
     else
       if jsonb_typeof(l.value) <> 'string' or not pg_input_is_valid(l.value #>> '{}', 'uuid') then
-        code := 'invalid_data'; msg := format('конец %s: значение не uuid', l.key); return;
+        key := 'sql-write.end_not_uuid'; params := jsonb_build_object('end', l.key); return;
       end if;
       links := links || jsonb_build_object(l.key, (l.value #>> '{}')::uuid::text);
     end if;
   end loop;
-  for e in select key, value from jsonb_each(coalesce(p_res->'ends', '{}'::jsonb)) loop
+  for e in select j.key, j.value from jsonb_each(coalesce(p_res->'ends', '{}'::jsonb)) j loop
     if coalesce((e.value->>'many')::boolean, false) then
       n := coalesce(jsonb_array_length(links->e.key), 0);
       if n < greatest(coalesce((e.value->>'min')::int, 0), case when coalesce((e.value->>'required')::boolean, false) then 1 else 0 end) then
-        code := 'invalid_data'; msg := format('у конца %s слишком мало целей', e.key); return;
+        key := 'sql-write.end_too_few'; params := jsonb_build_object('end', e.key); return;
       end if;
       if e.value ? 'max' and n > (e.value->>'max')::int then
-        code := 'invalid_data'; msg := format('у конца %s слишком много целей', e.key); return;
+        key := 'sql-write.end_too_many'; params := jsonb_build_object('end', e.key); return;
       end if;
     elsif coalesce((e.value->>'required')::boolean, false) and not links ? e.key then
-      code := 'invalid_data'; msg := format('обязательный конец %s не задан', e.key); return;
+      key := 'sql-write.end_required'; params := jsonb_build_object('end', e.key); return;
     end if;
   end loop;
 end $$;
@@ -262,13 +258,16 @@ end $$;
 -- (ends — описание концов, если его ещё нет в строке Class). При p_lock цели сначала блокируются
 -- for key share в порядке id — каждая один раз на оператор, только свои и системные: строку чужого
 -- арендатора не заблокировать и по ожиданию не обнаружить. Проверка идёт после блокировки, по
--- свежим строкам: цель, которую успели удалить или перевести в чужой класс, не пройдёт. Класс цели
+-- свежим строкам: цель, которую успели удалить, не пройдёт. Класс цели
 -- прямо в списке конца — без поиска описания; иначе — предки из строки Class цели.
 -- При p_acl ({tenant, account, plan} — план READ актора) цель ещё и должна быть видна актору (этап 5,
 -- п. 6): строку, которую он не видит, нельзя использовать как цель — ответ тот же, что для
 -- несуществующей. Цели-аккаунты (Account) не проверяются: на них ссылаются членства и владельцы.
--- Возвращает роль первой непрошедшей цели или null; цель — строка производного класса: «!роль»
--- (вызывающий отвечает derived_class).
+-- Роль сеанса, к которой RLS не применяется (суперпользователь, BYPASSRLS, член владельца),
+-- видит любую строку, а пишет и строки, которых план актора не показывает: прятать от неё цель незачем, и p_acl
+-- она не проверяет. До этого администраторское подключение с сессией без прав заводило ресурсы, а правило на них —
+-- нет: target_not_found (внедрение, агентский прогон плана 2.0).
+-- Возвращает роль первой непрошедшей цели или null.
 create or replace function @SCHEMA@.targets_bad(p_rows jsonb, p_lock boolean, p_acl jsonb default null) returns text
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -279,6 +278,11 @@ begin
   if p_rows is null or jsonb_array_length(p_rows) = 0 then
     return null;
   end if;
+  if p_acl is not null
+     and (exists (select 1 from pg_roles r where r.rolname = @SCHEMA@.session_role() and (r.rolsuper or r.rolbypassrls))
+          or pg_has_role(@SCHEMA@.session_role(), '@OWNER_NAME@', 'USAGE')) then
+    p_acl := null;
+  end if;
   if p_lock then
     perform 1 from @SCHEMA@.entity t
     where t.id in (select (v #>> '{}')::uuid from jsonb_array_elements(p_rows) r
@@ -299,7 +303,7 @@ begin
     left join lateral jsonb_array_elements(case jsonb_typeof(k.value) when 'array' then k.value else '[]'::jsonb end) a on true
     where jsonb_typeof(k.value) = 'string' or a.value is not null
   )
-  select case when x.miss then x.role else '!' || x.role end into bad
+  select x.role into bad
   from (
     select p.role,
            t.id is null
@@ -308,14 +312,11 @@ begin
                    or @SCHEMA@.class_set(c.ends->p.role->'class') ?| array(select jsonb_array_elements_text(kr.res->'ancestors')), false)
            or (p_acl is not null and t.class <> 'Account'
                and not @SCHEMA@.row_visible(t.tenant, t.class, t.id, t.owner, t.tags, t.data, t.links,
-                                            (p_acl->>'tenant')::uuid, (p_acl->>'account')::uuid, p_acl->'plan')) as miss,
-           coalesce(kr.res ? 'derivedBy', false) as derived
+                                            (p_acl->>'tenant')::uuid, (p_acl->>'account')::uuid, p_acl->'plan')) as miss
     from p
     join c on c.cls = p.cls and c.tenant = p.tenant and c.ends is not distinct from coalesce(p.ends, c.ends)
     left join @SCHEMA@.entity t on t.id = p.tid
-    -- описание класса цели — только когда класс не назван в конце прямо: тогда нужны его предки, а цель
-    -- производного класса (конец, названный предком; план 1.1, §2.4) не проходит — прямо назвать производный
-    -- класс в конце не даёт описание (class_admit)
+    -- описание класса цели — только когда класс не назван в конце прямо: тогда нужны его предки
     left join lateral (
       select case when t.id is null or @SCHEMA@.class_set(c.ends->p.role->'class') ? t.class then null
              else (select k.data->'resolved' from @SCHEMA@.entity k
@@ -323,18 +324,17 @@ begin
                    order by k.tenant = '@SYSTEM@'::uuid limit 1) end as res
     ) kr on true
   ) x
-  where x.miss or x.derived
+  where x.miss
   limit 1;
   return bad;
 end $$;
--- до этапа 5 цели не сверялись с правами актора
-drop function if exists @SCHEMA@.targets_bad(jsonb, boolean);
 
--- Разбор концов и проверка целей одной строки — для функций владельца (reclass, проверка строк
+-- Разбор концов и проверка целей одной строки — для функций владельца (restore, проверка строк
 -- семейства), которые пишут мимо триггеров. При p_lock цели блокируются for key share; p_acl — как
--- у targets_bad (цели видны актору).
+-- у targets_bad (цели видны актору). Отказ — ключ каталога и параметры, как у links_shape (вызывающий бросает
+-- ошибку по ним).
 create or replace function @SCHEMA@.check_links(p_res jsonb, p_links jsonb, p_tenant uuid, p_lock boolean, p_acl jsonb,
-  out links jsonb, out code text, out msg text)
+  out links jsonb, out key text, out params jsonb)
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
@@ -342,19 +342,16 @@ as $$
 declare
   bad text;
 begin
-  select s.links, s.code, s.msg into links, code, msg from @SCHEMA@.links_shape(p_res, p_links) s;
-  if code is not null or links = '{}'::jsonb then
+  select s.links, s.key, s.params into links, key, params from @SCHEMA@.links_shape(p_res, p_links) s;
+  if key is not null or links = '{}'::jsonb then
     return;
   end if;
   bad := @SCHEMA@.targets_bad(jsonb_build_array(jsonb_build_object(
     'class', p_res->>'name', 'tenant', p_tenant, 'links', links, 'ends', coalesce(p_res->'ends', '{}'::jsonb))), p_lock, p_acl);
-  if bad like '!%' then
-    code := 'derived_class'; msg := format('конец %s ведёт на строку производного класса', substr(bad, 2));
-  elsif bad is not null then
-    code := 'target_not_found'; msg := format('цель конца %s не найдена', bad);
+  if bad is not null then
+    key := 'sql-write.end_target_missing'; params := jsonb_build_object('end', bad);
   end if;
 end $$;
-drop function if exists @SCHEMA@.check_links(jsonb, jsonb, uuid, boolean);
 
 -- id класса с ключом — v5 от арендатора, класса и значений ключа (§2.3); у класса без ключа — null.
 create or replace function @SCHEMA@.key_id(p_res jsonb, p_class text, p_tenant uuid, p_data jsonb, p_links jsonb) returns uuid
@@ -377,8 +374,6 @@ return coalesce((@SCHEMA@.class_row(p_class, p_tenant)).data->'resolved'->>'hist
 -- 96 бит HMAC-SHA256 от «назначение:значение» на ключе сигналов (HMAC ключа строки KEY по
 -- 'letopis:signals', его отдаёт signal_key()): без ключа псевдоним не сопоставить с именем, а
 -- нагрузка детерминирована — PostgreSQL склеивает одинаковые сигналы транзакции.
--- до плана 1.1 сигнал принимал только имена классов
-drop function if exists @SCHEMA@.signal(text[]);
 
 create or replace function @SCHEMA@.signal_token(p_purpose text, p_value text, p_key bytea) returns text
 language sql immutable parallel safe
@@ -440,31 +435,23 @@ begin
 end $$;
 
 -- Версия одной строки в журнал и сигнал — для функций владельца, которые пишут строку сами
--- (пересчёт потомков, снятие конца, перенос на новый id). Классы с history: false журнал не ведут,
+-- (пересчёт потомков, снятие конца, восстановление, надгробие). Классы с history: false журнал не ведут,
 -- но сигнал посылают. Обычную запись журналируют триггеры после оператора — одной вставкой.
 create or replace function @SCHEMA@.log_version(e @SCHEMA@.entity) returns void
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
-declare
-  p @SCHEMA@.log;
 begin
   if @SCHEMA@.history_on(e.class, e.tenant) then
-    -- пути изменения: против предыдущей версии id, у первой версии переноса — против прежнего id (moved)
-    select l.* into p from @SCHEMA@.log l
-    where l.id = case when e.rev > 1 then e.id else e.moved end and l.op not in ('purge', 'trim', 'reset')
-    order by l.rev desc limit 1;
-    insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
-    values (e.id, e.rev, e.class, e.cv, e.tenant, e.owner, e.links, e.data, e.tags, e.at, e.author, e.agent, e.op, e.reason, e.moved, e.prev_hash,
-            case when p.id is not null then @SCHEMA@.change_paths(p.data, p.links, p.tags, p.owner, p.class, e.data, e.links, e.tags, e.owner, e.class) end);
+    insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason)
+    values (e.id, e.rev, e.class, e.cv, e.tenant, e.owner, e.links, e.data, e.tags, e.at, e.author, e.agent, e.op, e.reason);
   end if;
   perform @SCHEMA@.signal(array[e.class], array[e.tenant]);
 end $$;
 
 -- Новая версия строки от имени владельца (пересчёт описаний потомков, снятие конца при удалении):
 -- служебные колонки, журнал, сигнал. Триггеры при этом не срабатывают.
-create or replace function @SCHEMA@.sys_update(p_id uuid, p_data jsonb, p_links jsonb, p_validator jsonpath, p_op text,
-  p_class text default null)
+create or replace function @SCHEMA@.sys_update(p_id uuid, p_data jsonb, p_links jsonb, p_validator jsonpath, p_op text)
 returns @SCHEMA@.entity
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -475,26 +462,20 @@ declare
 begin
   select * into c from @SCHEMA@.ctx();
   update @SCHEMA@.entity x
-     set class = coalesce(p_class, x.class), data = p_data, links = p_links, validator = p_validator,
-         rev = x.rev + 1, prev_hash = x.hash,
+     set data = p_data, links = p_links, validator = p_validator,
+         rev = x.rev + 1,
          at = greatest(@SCHEMA@.now_ts(), x.at + interval '1 microsecond'),
          author = coalesce(c.author, '@SYSTEM@'::uuid), agent = c.agent, op = p_op,
-         reason = nullif(current_setting('letopis.reason', true), ''), moved = null,
-         cv = coalesce((@SCHEMA@.class_row(coalesce(p_class, x.class), x.tenant)).rev, x.cv)
+         reason = nullif(current_setting('letopis.reason', true), ''),
+         cv = coalesce((@SCHEMA@.class_row(x.class, x.tenant)).rev, x.cv)
    where x.id = p_id
   returning x.* into e;
-  -- смена класса: агрегатные поля новой цели триггер после правки посчитал в эту же версию (план 1.1, §2.4) —
-  -- в журнал идёт строка таблицы, а не returning
-  if p_class is not null then
-    select x.* into e from @SCHEMA@.entity x where x.id = p_id;
-  end if;
   perform @SCHEMA@.log_version(e);
   return e;
 end $$;
 
--- Надгробие: последний снимок удалённой строки следующей версией с видом delete; при переносе на
--- новый id (reclass, rekey) moved ссылается на новый id.
-create or replace function @SCHEMA@.tombstone(e @SCHEMA@.entity, p_op text default 'delete', p_moved uuid default null) returns void
+-- Надгробие: последний снимок удалённой строки следующей версией с видом delete.
+create or replace function @SCHEMA@.tombstone(e @SCHEMA@.entity) returns void
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
@@ -503,17 +484,15 @@ declare
 begin
   select * into c from @SCHEMA@.ctx();
   e.rev := e.rev + 1;
-  e.prev_hash := e.hash;
   e.at := greatest(@SCHEMA@.now_ts(), e.at + interval '1 microsecond');
   e.author := coalesce(c.author, '@SYSTEM@'::uuid);
   e.agent := c.agent;
-  e.op := p_op;
+  e.op := 'delete';
   e.reason := nullif(current_setting('letopis.reason', true), '');
-  e.moved := p_moved;
   perform @SCHEMA@.log_version(e);
 end $$;
 
--- Входящие ссылки на строку p_id, роли которых не принимают класс p_class (смена класса, смена родителя).
+-- Входящие ссылки на строку p_id, роли которых не принимают класс p_class (смена родителя класса).
 create or replace function @SCHEMA@.incoming_conflicts(p_id uuid, p_class text, p_tenant uuid) returns jsonb
 language sql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -526,7 +505,7 @@ as $$
     and not @SCHEMA@.role_accepts(r.class, r.tenant, k.key, p_class, p_tenant)
 $$;
 
--- Перечень видимых актору строк и число остальных — для ошибок restrict, смены класса, ужесточения.
+-- Перечень видимых актору строк и число остальных — для ошибок restrict и ужесточения.
 -- Видимость — та же, что у чтения (row_visible с планом READ актора), а не только арендатор.
 create or replace function @SCHEMA@.visible_detail(p_rows jsonb, p_tenant uuid) returns jsonb
 language plpgsql stable
@@ -558,16 +537,13 @@ return (select min(r->>'class') from jsonb_array_elements(p_rows) r, (select @SC
                                    (x.a->>'tenant')::uuid, (x.a->>'account')::uuid, x.a->'plan'));
 
 -- Безопасно ли изменение описания класса (этап 1, п. 10): новые необязательные поля и концы,
--- метаданные, алиас, политика истории, кэш. Всё остальное — ужесточение с проверкой строк, в том числе
--- любая правка условий anyOf и oneOf (1.0.1: прежде они не сравнивались, и строки не перепроверялись),
--- признака производного класса derivedBy и описания агрегатов aggregate (план 1.1, §2.6).
+-- метаданные, алиас, history, кэш. Всё остальное — ужесточение с проверкой строк, в том числе
+-- любая правка условий anyOf и oneOf (1.0.1: прежде они не сравнивались, и строки не перепроверялись).
 create or replace function @SCHEMA@.class_change_safe(o jsonb, n jsonb) returns boolean
 language sql immutable
 return
   o->'key' = n->'key'
   and o->'ancestors' = n->'ancestors'
-  and o->'derivedBy' is not distinct from n->'derivedBy'
-  and o->'aggregate' is not distinct from n->'aggregate'
   and (o->'abstract' = n->'abstract' or n->>'abstract' = 'false')
   and o->'schema'->'anyOf' is not distinct from n->'schema'->'anyOf'
   and o->'schema'->'oneOf' is not distinct from n->'schema'->'oneOf'
@@ -581,7 +557,8 @@ return
                     and (coalesce((e.value->>'required')::boolean, false) or coalesce((e.value->>'min')::int, 0) > 0));
 
 -- Строки семейства, которые не проходят текущие описания своих классов (после ужесточения).
--- Не больше 100 строк; p_incoming — проверять ещё и входящие ссылки (смена родителя).
+-- Не больше 100 строк; p_incoming — проверять ещё и входящие ссылки (смена родителя). У строки — problem (русский текст
+-- по ключу каталога) и сами key и params: библиотека их убирает (fromDbError).
 create or replace function @SCHEMA@.family_conflicts(p_classes text[], p_tenant uuid, p_incoming boolean) returns jsonb
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -593,6 +570,7 @@ declare
   bad jsonb;
   lk record;
   problem text;
+  msg jsonb;  -- ключ и параметры problem
   inc jsonb;
   outv jsonb := '[]'::jsonb;
   a jsonb := @SCHEMA@.acl_actor('READ');
@@ -605,18 +583,26 @@ begin
     cls := @SCHEMA@.class_row(r.class, r.tenant);
     res := cls.data->'resolved';
     problem := null;
+    msg := null;
     if coalesce((res->>'abstract')::boolean, false) then
-      problem := 'класс абстрактный';
+      problem := @SCHEMA@.lt_text('sql-write.problem_abstract');
+      msg := jsonb_build_object('key', 'sql-write.problem_abstract', 'params', '{}'::jsonb);
     else
       bad := @SCHEMA@.validate_data(res->'rules', cls.validator, res->'vars', r.data);
       if bad <> '[]'::jsonb then
-        problem := 'данные: ' || bad::text;
+        -- в русском тексте — нарушения без key и params (текст прежний), а в params строки — сами нарушения с ключами:
+        -- по ним библиотека переведёт и их сообщения
+        problem := @SCHEMA@.lt_text('sql-write.problem_data', jsonb_build_object('issues',
+          (select jsonb_agg(x.i - 'key' - 'params' order by x.n) from jsonb_array_elements(bad) with ordinality x(i, n))::text));
+        msg := jsonb_build_object('key', 'sql-write.problem_data', 'params', jsonb_build_object('issues', bad));
       else
         select * into lk from @SCHEMA@.check_links(res, r.links, r.tenant, false, null);
-        if lk.code is not null then
-          problem := lk.msg;
+        if lk.key is not null then
+          problem := @SCHEMA@.lt_text(lk.key, lk.params);
+          msg := jsonb_build_object('key', lk.key, 'params', coalesce(lk.params, '{}'::jsonb));
         elsif coalesce(@SCHEMA@.key_id(res, r.class, r.tenant, r.data, r.links), r.id) <> r.id then
-          problem := 'id не соответствует ключу класса';
+          problem := @SCHEMA@.lt_text('sql-write.problem_key');
+          msg := jsonb_build_object('key', 'sql-write.problem_key', 'params', '{}'::jsonb);
         end if;
       end if;
     end if;
@@ -631,13 +617,14 @@ begin
         from jsonb_array_elements(inc) i(v)
         left join @SCHEMA@.entity x on x.id = (i.v->>'id')::uuid
         order by seen desc, i.v->>'id' limit 1;
-        problem := case when vis
-          then format('на строку ссылается роль %s строки %s, которая не принимает класс', ref->>'role', ref->>'id')
-          else 'на строку ссылается строка, которой актор не видит, и она не принимает класс' end;
+        msg := case when vis
+          then jsonb_build_object('key', 'sql-write.problem_ref', 'params', jsonb_build_object('role', ref->>'role', 'id', ref->>'id'))
+          else jsonb_build_object('key', 'sql-write.problem_ref_hidden', 'params', '{}'::jsonb) end;
+        problem := @SCHEMA@.lt_text(msg->>'key', msg->'params');
       end if;
     end if;
     if problem is not null then
-      outv := outv || jsonb_build_object('id', r.id, 'class', r.class, 'tenant', r.tenant, 'problem', problem);
+      outv := outv || (jsonb_build_object('id', r.id, 'class', r.class, 'tenant', r.tenant, 'problem', problem) || coalesce(msg, '{}'::jsonb));
       exit when jsonb_array_length(outv) >= 100;
     end if;
   end loop;
@@ -651,26 +638,26 @@ language sql immutable parallel safe
 return array[@RESERVED_NAMES@]::text[];
 
 -- Правка класса p_class арендатора p_tenant меняет имена, по которым его строки находят правила прав: предков
--- (parent), алиас или derivedBy (ревью безопасности №2). План прав берёт для класса имена предков и их алиасы
+-- (parent) или алиас (ревью безопасности №2). План прав берёт для класса имена предков и их алиасы
 -- (acl_plan_for), поэтому строки класса и его потомков попали бы под правила READ, WRITE и DELETE нового предка или
 -- алиаса — право WRITE на Class открывало бы чужие строки. Актору нужно право READ, WRITE и DELETE без условий на
 -- все строки самого класса и каждого потомка своего арендатора, иначе acl_denied. Потомков у арендаторов класса
--- System план прав сессии System не видит — они пропускаются, как у агрегатов (agg_source_admit). Проверка — до
+-- System план прав сессии System не видит — они пропускаются. Проверка — до
 -- правки (class_admit): план видит прежние имена, по которым строки уже защищены.
 create or replace function @SCHEMA@.class_acl_admit(p_class text, p_tenant uuid) returns void
 language plpgsql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 begin
-  perform @SCHEMA@.class_rows_admit(p_class, p_tenant, array['READ', 'WRITE', 'DELETE'],
-    format('класс %s меняет предков, алиас или derivedBy', p_class));
+  perform @SCHEMA@.class_rows_admit(p_class, p_tenant, array['READ', 'WRITE', 'DELETE'], 'reparent');
 end $$;
 
 -- Право актора на все строки класса p_class и каждого его потомка арендатора p_tenant: по каждой операции p_ops —
--- без условий, иначе acl_denied с текстом «<p_what>: нужно право <op> на все строки класса <класс>». Сам класс первым,
+-- без условий, иначе acl_denied «<что меняется>: нужно право <op> на все строки класса <класс>». Что меняется — p_what,
+-- по нему ключ каталога (план 2.0, этап 3, п. 3): reparent, history, tighten; иное — готовый текст. Сам класс первым,
 -- потомки — по глубине и имени; потомков у арендаторов класса System план сессии System не видит — они пропускаются.
--- Зовут class_acl_admit (смена предков, алиаса, derivedBy), ужесточение (class_evolve, rekey_class) и смена политики
--- хранения истории (class_admit; доработки после точки Б).
+-- Зовут class_acl_admit (смена предков и алиаса), ужесточение (class_evolve) и смена history — включение и выключение
+-- журнала (class_admit; доработки после точки Б).
 create or replace function @SCHEMA@.class_rows_admit(p_class text, p_tenant uuid, p_ops text[], p_what text) returns void
 language plpgsql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -679,6 +666,7 @@ declare
   c text;
   op text;
   chk jsonb;
+  p jsonb;
 begin
   for c in select p_class
            union all
@@ -689,21 +677,27 @@ begin
     foreach op in array p_ops loop
       chk := @SCHEMA@.acl_check_data(c, op);
       if not coalesce((chk->>'allow')::boolean, false) or chk ? 'filter' then
-        perform @SCHEMA@.lt_fail('acl_denied', format('%s: нужно право %s на все строки класса %s', p_what, op, c));
+        p := jsonb_build_object('cls', p_class, 'op', op, 'target', c);
+        case p_what
+          when 'reparent' then perform @SCHEMA@.lt_fail('sql-write.reparent_needs_all', p);
+          when 'history' then perform @SCHEMA@.lt_fail('sql-write.history_needs_all', p);
+          when 'tighten' then perform @SCHEMA@.lt_fail('sql-write.tighten_needs_all', p);
+          else perform @SCHEMA@.lt_fail('sql-write.change_needs_all', jsonb_build_object('what', p_what, 'op', op, 'target', c));
+        end case;
       end if;
     end loop;
   end loop;
 end $$;
 
--- Есть ли в журнале версии строк класса p_name арендатора p_tenant; записи purge, trim и reset — не версии (доработки
--- после точки Б: удаление и пересоздание класса, остаток Н2 ревью №2). У класса System — строки любого арендатора, кроме
+-- Есть ли в журнале версии строк класса p_name арендатора p_tenant (доработки после точки Б: удаление и пересоздание
+-- класса, остаток Н2 ревью №2). У класса System — строки любого арендатора, кроме
 -- арендаторов со своим классом с тем же именем: их строки — строки своего класса, как их резолвит class_row (ревью
 -- безопасности №3: история такого класса не мешает администратору создать и удалить класс System)
 create or replace function @SCHEMA@.class_has_history(p_name text, p_tenant uuid) returns boolean
 language sql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 return exists (select 1 from @SCHEMA@.log l
-               where l.class = p_name and l.op not in ('purge', 'trim', 'reset')
+               where l.class = p_name
                  and (l.tenant = p_tenant
                       or p_tenant = '@SYSTEM@'::uuid
                          and l.tenant <> all (array(select x.tenant from @SCHEMA@.entity x
@@ -729,8 +723,8 @@ return exists (select 1 from @SCHEMA@.log t
                  and @SCHEMA@.class_has_history(t.data->>'name', t.tenant));
 
 -- Проверки строки Class сверх метасхемы (этап 1, п. 6): признак system, имя системного класса,
--- имена связей против методов цепочки, однозначность имени конца во всей схеме, право на агрегаты,
--- алиас и право на смену предков, алиаса и derivedBy (ревью безопасности №2).
+-- имена связей и хабов против методов цепочки, однозначность имени конца во всей схеме,
+-- алиас и право на смену предков и алиаса (ревью безопасности №2).
 create or replace function @SCHEMA@.class_admit(p_data jsonb, p_tenant uuid, out data jsonb, out validator jsonpath)
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
@@ -739,25 +733,19 @@ as $$
 declare
   e record;
   o record;
-  dname text;
-  drole text;
   tc @SCHEMA@.entity;
   prevd jsonb;
-  src text;
-  chk jsonb;
-  m jsonb;
-  dkid text;
 begin
   if p_tenant <> '@SYSTEM@'::uuid then
     if (p_data->>'name') = any (array['Class', 'Account', 'member', 'Resource', 'rule']) then
-      perform @SCHEMA@.lt_fail('invalid_class', format('имя %s зарезервировано за системным классом', p_data->>'name'));
+      perform @SCHEMA@.lt_fail('sql-write.system_name_reserved', jsonb_build_object('name', p_data->>'name'));
     end if;
     if coalesce((p_data->>'system')::boolean, false) then
-      perform @SCHEMA@.lt_fail('invalid_class', 'признак system задаёт только установка');
+      perform @SCHEMA@.lt_fail('sql-write.system_flag');
     end if;
     if exists (select 1 from @SCHEMA@.entity s
                where s.id = @SCHEMA@.v5_id('@SYSTEM@'::uuid, 'Class', array[p_data->>'name']) and s.class = 'Class') then
-      perform @SCHEMA@.lt_fail('invalid_class', format('имя %s занято системным классом', p_data->>'name'));
+      perform @SCHEMA@.lt_fail('sql-write.system_name_taken', jsonb_build_object('name', p_data->>'name'));
     end if;
   end if;
   -- родитель — под разделяемой блокировкой своего семейства (хвост ревью доработок после 1.2.0): удаление класса берёт
@@ -770,7 +758,12 @@ begin
   end if;
   select c.data, c.validator into data, validator from @SCHEMA@.class_prepare(p_data, p_tenant) c;
   if data->>'kind' = 'link' and (data->>'name') = any (@SCHEMA@.reserved_names()) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('имя связи %s совпадает с методом цепочки', data->>'name'));
+    perform @SCHEMA@.lt_fail('sql-write.link_name_reserved', jsonb_build_object('name', data->>'name'));
+  end if;
+  -- и хаб (план 2.0, этап 4, п. 2): шаг с именем метода цепочки или корня db до класса не дойдёт. Прежние такие хабы
+  -- остаются (up() называет их в предупреждении), но их строку Class база больше не пишет — ни создание, ни правку
+  if data->>'kind' = 'hub' and (data->>'name') = any (@SCHEMA@.reserved_names()) then
+    perform @SCHEMA@.lt_fail('sql-write.hub_name_reserved', jsonb_build_object('name', data->>'name'));
   end if;
   -- алиас — второе имя класса и для правил прав (ревью безопасности №2): совпади он с именем другого класса (в том
   -- числе Class и системных) или с чужим алиасом арендатора и System, правила одного класса действовали бы на строки
@@ -780,107 +773,36 @@ begin
           or exists (select 1 from @SCHEMA@.entity x
                      where x.class = 'Class' and x.tenant in (p_tenant, '@SYSTEM@'::uuid) and x.data->>'name' <> data->>'name'
                        and (x.data->>'name' = data->>'alias' or x.data->>'alias' = data->>'alias'))) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('алиас %s класса %s совпадает с именем или алиасом другого класса',
-      data->>'alias', data->>'name'));
+    perform @SCHEMA@.lt_fail('sql-write.alias_taken', jsonb_build_object('alias', data->>'alias', 'cls', data->>'name'));
   end if;
   -- и наоборот: имя класса — не чужой алиас арендатора и System, иначе правила, написанные для нового класса, действовали
   -- бы и на строки класса с этим алиасом
   if exists (select 1 from @SCHEMA@.entity x
              where x.class = 'Class' and x.tenant in (p_tenant, '@SYSTEM@'::uuid) and x.data->>'name' <> data->>'name'
                and x.data->>'alias' = data->>'name') then
-    perform @SCHEMA@.lt_fail('invalid_class', format('имя класса %s совпадает с алиасом другого класса', data->>'name'));
+    perform @SCHEMA@.lt_fail('sql-write.name_is_alias', jsonb_build_object('cls', data->>'name'));
   end if;
-  -- агрегаты (план 1.1, §2.4; ревью коммита этапа 4б): поле считают функции владельца по всем строкам источника
-  -- арендатора, без прав чтения, поэтому строки попадают в агрегат только с ведома того, кто читает их все. Пути
-  -- владельца (сид, class_evolve, rekey_class) сюда не заходят. Описание до правки — для сравнения (нет — новый класс)
+  -- описание до правки — для сравнения (нет — новый класс). Пути владельца (сид, class_evolve) сюда не заходят
   select x.data into prevd from @SCHEMA@.entity x
   where x.class = 'Class' and x.tenant = p_tenant and x.data->>'name' = data->>'name';
-  -- производный класс (план 1.1, §2.4) заводит, меняет и удаляет только администратор (/security-review после точки Б):
-  -- проектор берёт арендатора в участники по его классам с пометкой и пишет туда итоги по всем строкам источников,
-  -- поэтому пользователь с правом WRITE на Class, заведя такой класс сам, читал бы итоги по строкам, которые ему читать
-  -- запрещено. Пометка своя или унаследованная, до правки или после; право letopis.projector — у администраторской роли
-  -- подключения и по правилам System (системный администратор — маска letopis.*)
-  if (data->'resolved' ? 'derivedBy' or coalesce(prevd->'resolved' ? 'derivedBy', false))
-     and not @SCHEMA@.letopis_allowed('letopis.projector') then
-    perform @SCHEMA@.lt_fail('acl_denied', format('класс %s производный: его описание задаёт только администратор (право letopis.projector)',
-      data->>'name'));
-  end if;
-  -- предок производного класса (ревью безопасности №3): правка предка пересчитывает описание потомка (class_evolve) —
-  -- поля, ключ, history, — поэтому класс с производными потомками (своего арендатора, у класса System — всех, кроме
-  -- арендаторов со своим одноимённым классом: их потомки наследуют свой класс) меняет тоже только администратор
-  if prevd is not null and not @SCHEMA@.letopis_allowed('letopis.projector') then
-    select x.data->>'name' into dkid from @SCHEMA@.entity x
-    where x.class = 'Class' and x.data->>'name' <> data->>'name'
-      and (x.tenant = p_tenant
-           or p_tenant = '@SYSTEM@'::uuid
-              and x.tenant <> all (array(select y.tenant from @SCHEMA@.entity y
-                                         where y.class = 'Class' and y.data->>'name' = data->>'name' and y.tenant <> '@SYSTEM@'::uuid)))
-      and x.data->'resolved'->'ancestors' ? (data->>'name') and x.data->'resolved' ? 'derivedBy'
-    order by x.data->>'name' limit 1;
-    if dkid is not null then
-      perform @SCHEMA@.lt_fail('acl_denied', format('класс %s — предок производного класса %s: его описание задаёт только администратор (право letopis.projector)',
-        data->>'name', dkid));
-    end if;
-  end if;
-  -- агрегат развёрнутого описания (свой или унаследованный), новый или изменённый против прежнего — описание
-  -- агрегата, новый потомок цели, смена parent, — задаёт только тот, кто без условий читает все строки каждого
-  -- класса-источника: класса of и его потомков (agg_classes: классы арендатора, у класса System — классы System).
-  -- Неизменённый агрегат не проверяется
-  if data->'resolved' ? 'aggregate' then
-    for e in select key, value from jsonb_each(data->'resolved'->'aggregate') order by key loop
-      continue when prevd->'resolved'->'aggregate'->e.key is not distinct from e.value;
-      -- класс-источник должен уже быть (ревью безопасности №3, /security-review): пока его нет, проверять право READ не
-      -- на чем, а когда класс заведёт другой пользователь, проверялись бы только его права — и описавший агрегат читал бы
-      -- в истории цели вклад каждой строки источника. Поэтому источник описывают раньше агрегата
-      if cardinality(@SCHEMA@.agg_classes(e.value->>'of', p_tenant, p_tenant = '@SYSTEM@'::uuid)) = 0 then
-        perform @SCHEMA@.lt_fail('invalid_class', format('агрегат %s.%s: класса-источника %s и его потомков %s нет — источник описывают раньше агрегата',
-          data->>'name', e.key, e.value->>'of', case when p_tenant = '@SYSTEM@'::uuid then 'в System' else 'у арендатора' end));
-      end if;
-      -- сам класс of первым, потомки — по имени
-      foreach src in array array(select n from unnest(@SCHEMA@.agg_classes(e.value->>'of', p_tenant, p_tenant = '@SYSTEM@'::uuid)) n
-                                 order by n = (e.value->>'of') desc, n) loop
-        chk := @SCHEMA@.acl_check_data(src, 'READ');
-        if not coalesce((chk->>'allow')::boolean, false) or chk ? 'filter' then
-          perform @SCHEMA@.lt_fail('acl_denied', format('агрегат %s.%s: нужно право READ на все строки класса %s', data->>'name', e.key, src));
-        end if;
-      end loop;
-    end loop;
-  end if;
-  -- класс становится источником агрегата (новая метка aggregatedBy — смена parent): в агрегат войдут его строки и строки
-  -- потомков — нужно право READ без условий на них до правки, по прежним предкам (здесь), и после (agg_source_admit в
-  -- триггере после оператора; новый класс проверяется только там: до вставки план прав его не видит)
-  m := @SCHEMA@.agg_new_mark(prevd->'resolved', data->'resolved');
-  if m is not null and prevd is not null then
-    perform @SCHEMA@.agg_source_admit(data->>'name', m);
-    for src in select x.data->>'name' from @SCHEMA@.entity x
-               where x.class = 'Class' and x.tenant = p_tenant and x.data->>'name' <> data->>'name'
-                 and x.data->'resolved'->'ancestors' ? (data->>'name')
-               order by jsonb_array_length(x.data->'resolved'->'ancestors'), x.data->>'name' loop
-      perform @SCHEMA@.agg_source_admit(src, m);
-    end loop;
-  end if;
-  -- правка меняет предков, алиас или derivedBy (ревью безопасности №2): строки класса и потомков попали бы под правила
+  -- правка меняет предков или алиас (ревью безопасности №2): строки класса и потомков попали бы под правила
   -- других имён — нужно право READ, WRITE и DELETE без условий на все их строки. У нового класса строк ещё нет
   if prevd is not null
      and (prevd->'resolved'->'ancestors' is distinct from data->'resolved'->'ancestors'
-          or prevd->>'alias' is distinct from data->>'alias'
-          or prevd->'resolved'->'derivedBy' is distinct from data->'resolved'->'derivedBy') then
+          or prevd->>'alias' is distinct from data->>'alias') then
     perform @SCHEMA@.class_acl_admit(data->>'name', p_tenant);
   end if;
   -- алиас класса, у которого удалённые потомки хранят историю строк (ревью безопасности №3): правила находят их старые
-  -- версии и по алиасам предков, а надгробие потомка их не записывает — алиас меняется после purge() их строк
+  -- версии и по алиасам предков, а надгробие потомка их не записывает — алиас не меняется
   if prevd is not null and prevd->>'alias' is distinct from data->>'alias'
      and @SCHEMA@.class_orphan_history(data->>'name', p_tenant) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('удалённые потомки класса %s хранят историю строк: алиас меняется после purge() их строк',
-      data->>'name'));
+    perform @SCHEMA@.lt_fail('sql-write.alias_orphan_history', jsonb_build_object('cls', data->>'name'));
   end if;
-  -- политика хранения истории (доработки после точки Б): по ней maintain() прореживает журнал строк класса, а
-  -- history: false выключает журнал. Одним правом WRITE на Class автор правки стирал бы аудит строк, на которые у него
-  -- нет прав, поэтому смена развёрнутой history существующего класса требует права READ и DELETE без условий на все
-  -- строки класса и его потомков своего арендатора — как trimHistory требует их на каждую цель
+  -- history (доработки после точки Б): history: false выключает журнал. Одним правом WRITE на Class автор правки
+  -- останавливал бы аудит строк, на которые у него нет прав, поэтому смена развёрнутой history существующего класса
+  -- требует права READ и DELETE без условий на все строки класса и его потомков своего арендатора
   if prevd is not null and prevd->'resolved'->'history' is distinct from data->'resolved'->'history' then
-    perform @SCHEMA@.class_rows_admit(data->>'name', p_tenant, array['READ', 'DELETE'],
-      format('класс %s меняет политику хранения истории', data->>'name'));
+    perform @SCHEMA@.class_rows_admit(data->>'name', p_tenant, array['READ', 'DELETE'], 'history');
   end if;
   for e in select key, value from jsonb_each(coalesce(data->'resolved'->'ends', '{}'::jsonb)) loop
     select x.data->>'name' as name into o
@@ -891,52 +813,9 @@ begin
       and @SCHEMA@.class_set(x.data->'resolved'->'ends'->e.key->'class') <> @SCHEMA@.class_set(e.value->'class')
     limit 1;
     if o.name is not null then
-      perform @SCHEMA@.lt_fail('invalid_class', format('конец %s в классе %s ведёт на другой класс', e.key, o.name));
+      perform @SCHEMA@.lt_fail('sql-write.end_other_class', jsonb_build_object('end', e.key, 'cls', o.name));
     end if;
   end loop;
-  -- на строки производного класса (план 1.1, §2.4) не ссылаются: проектор удаляет и строит их заново.
-  -- Классы целей — под разделяемой блокировкой семейства, а класс, который становится производным, — под
-  -- исключительной: описание со ссылкой и пометка derivedBy не проходят параллельно мимо друг друга
-  for e in select key, value from jsonb_each(coalesce(data->'resolved'->'ends', '{}'::jsonb)) loop
-    for tc in select c.* from jsonb_array_elements_text(@SCHEMA@.class_set(e.value->'class')) n(name)
-              cross join lateral @SCHEMA@.class_row(n.name, p_tenant) c where c.id is not null order by c.id loop
-      perform @SCHEMA@.family_lock(tc, false);
-    end loop;
-    dname := null;
-    select x.data->>'name' into dname
-    from @SCHEMA@.entity x
-    where x.class = 'Class' and x.tenant in (p_tenant, '@SYSTEM@'::uuid) and x.data->>'name' <> data->>'name'
-      and @SCHEMA@.class_set(e.value->'class') ? (x.data->>'name') and x.data->'resolved' ? 'derivedBy'
-    limit 1;
-    if dname is null and data->'resolved' ? 'derivedBy' and @SCHEMA@.class_set(e.value->'class') ? (data->>'name') then
-      dname := data->>'name';
-    end if;
-    if dname is not null then
-      perform @SCHEMA@.lt_fail('derived_class', format('конец %s ведёт на производный класс %s', e.key, dname));
-    end if;
-  end loop;
-  if data->'resolved' ? 'derivedBy' then
-    tc := @SCHEMA@.class_row(data->>'name', p_tenant);
-    if tc.id is not null then
-      perform @SCHEMA@.family_lock(tc, true);
-    end if;
-    -- класс становится производным, а на него или его потомков уже ссылаются концы других классов (класс
-    -- System видят все арендаторы — его ссылки ищутся во всех)
-    select x.data->>'name', k.key into dname, drole
-    from @SCHEMA@.entity x
-    cross join lateral jsonb_each(coalesce(x.data->'resolved'->'ends', '{}'::jsonb)) k
-    where x.class = 'Class' and (x.tenant in (p_tenant, '@SYSTEM@'::uuid) or p_tenant = '@SYSTEM@'::uuid)
-      and x.data->>'name' <> data->>'name'
-      and @SCHEMA@.class_set(k.value->'class') ?| (array[data->>'name'] || array(
-        select y.data->>'name' from @SCHEMA@.entity y
-        where y.class = 'Class' and (y.tenant in (p_tenant, '@SYSTEM@'::uuid) or p_tenant = '@SYSTEM@'::uuid)
-          and y.data->'resolved'->'ancestors' ? (data->>'name')))
-    limit 1;
-    if dname is not null then
-      perform @SCHEMA@.lt_fail('derived_class', format('класс %s не может стать производным: на него ссылается конец %s класса %s',
-        data->>'name', drole, dname));
-    end if;
-  end if;
   -- строки-замки семейства (family_lock) — заранее: первая запись в новое семейство их не вставляет
   perform @SCHEMA@.family_rows(p_tenant, data);
 end $$;
@@ -959,98 +838,81 @@ declare
 begin
   select * into c from @SCHEMA@.ctx();
   if c.account is null then
-    perform @SCHEMA@.lt_fail('no_session', 'нет действующей сессии');
+    perform @SCHEMA@.lt_fail('sql-write.no_session');
   end if;
   NEW.tenant := coalesce(NEW.tenant, c.tenant);
   if NEW.tenant <> c.tenant then
-    perform @SCHEMA@.lt_fail('tenant_denied', 'запись в чужого арендатора');
+    perform @SCHEMA@.lt_fail('sql-write.foreign_tenant');
   end if;
   -- аккаунты (с их категориями) — только в System: их пишет системный администратор (этап 5)
   if NEW.class = 'Account' and NEW.tenant <> '@SYSTEM@'::uuid then
-    perform @SCHEMA@.lt_fail('tenant_denied', 'аккаунты лежат в арендаторе System');
+    perform @SCHEMA@.lt_fail('sql-write.account_tenant');
   end if;
   cls := @SCHEMA@.class_row(NEW.class, NEW.tenant);
   if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s не найден', NEW.class));
+    perform @SCHEMA@.lt_fail('sql-write.class_not_found', jsonb_build_object('cls', NEW.class));
   end if;
   -- разделяемая блокировка корня семейства, затем описание перечитывается под ней (класс могли удалить, пока ждали)
   perform @SCHEMA@.family_lock(cls, false);
   cls := @SCHEMA@.class_row(NEW.class, NEW.tenant);
   if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', NEW.class));
+    perform @SCHEMA@.lt_fail('sql-write.class_deleted', jsonb_build_object('cls', NEW.class));
   end if;
   res := cls.data->'resolved';
   if coalesce((res->>'abstract')::boolean, false) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', NEW.class));
-  end if;
-  if res ? 'derivedBy' then
-    perform @SCHEMA@.lt_fail('derived_class', format('класс %s производный: его строки пишет проектор %s', NEW.class, res->>'derivedBy'));
+    perform @SCHEMA@.lt_fail('sql-write.class_abstract', jsonb_build_object('cls', NEW.class));
   end if;
   if NEW.class = 'Class' then
     select a.data, a.validator into NEW.data, NEW.validator from @SCHEMA@.class_admit(coalesce(NEW.data, '{}'::jsonb), NEW.tenant) a;
   else
-    -- агрегатное поле считает база (план 1.1, §2.4): переданное значение — отказ, новое — 0 до умолчаний и
-    -- проверки; итог из живых источников ставит триггер после оператора
-    if res ? 'aggregate' then
-      if coalesce(NEW.data, '{}'::jsonb) ?| @SCHEMA@.agg_fields(res) then
-        perform @SCHEMA@.lt_fail('aggregate_field', format('поля %s класса %s считает база (aggregate) — их не передают',
-          array_to_string(array(select x from unnest(@SCHEMA@.agg_fields(res)) x where NEW.data ? x), ', '), NEW.class));
-      end if;
-      NEW.data := @SCHEMA@.agg_zero(res, coalesce(NEW.data, '{}'::jsonb));
-    end if;
     NEW.data := @SCHEMA@.apply_defaults(res->'schema', coalesce(NEW.data, '{}'::jsonb));
     bad := @SCHEMA@.validate_data(res->'rules', cls.validator, res->'vars', NEW.data);
     if bad <> '[]'::jsonb then
-      perform @SCHEMA@.lt_fail('invalid_data', format('данные не проходят описание класса %s', NEW.class), jsonb_build_object('issues', bad));
+      perform @SCHEMA@.lt_fail('sql-write.invalid_data', jsonb_build_object('cls', NEW.class), jsonb_build_object('issues', bad));
     end if;
     NEW.validator := null;
   end if;
   -- цели проверяет и блокирует триггер после оператора (targets_bad) — один раз на оператор
   select * into lk from @SCHEMA@.links_shape(res, NEW.links);
-  if lk.code is not null then
-    perform @SCHEMA@.lt_fail(lk.code, lk.msg);
+  if lk.key is not null then
+    perform @SCHEMA@.lt_fail(lk.key, lk.params);
   end if;
   NEW.links := lk.links;
   if NEW.class = 'member' and NEW.links->>'Tenant' is distinct from NEW.tenant::text then
-    perform @SCHEMA@.lt_fail('invalid_data', 'конец Tenant членства — арендатор строки');
+    perform @SCHEMA@.lt_fail('sql-write.member_tenant');
   end if;
   kid := @SCHEMA@.key_id(res, NEW.class, NEW.tenant, NEW.data, NEW.links);
   if kid is null then
     if NEW.id is not null then
-      perform @SCHEMA@.lt_fail('id_from_db', format('id класса без ключа %s выдаёт база', NEW.class));
+      perform @SCHEMA@.lt_fail('sql-write.id_from_db', jsonb_build_object('cls', NEW.class));
     end if;
     NEW.id := @SCHEMA@.v5_id(NEW.tenant, NEW.class, array[gen_random_uuid()::text]);
   else
     if NEW.id is not null and NEW.id <> kid then
-      perform @SCHEMA@.lt_fail('id_mismatch', format('id не равен v5 от ключа класса %s', NEW.class), jsonb_build_object('expected', kid));
+      perform @SCHEMA@.lt_fail('sql-write.id_mismatch', jsonb_build_object('cls', NEW.class), jsonb_build_object('expected', kid));
     end if;
     NEW.id := kid;
   end if;
-  -- воскрешение: номер версии и цепочка хэшей продолжаются от последней записи журнала; запись
-  -- блокируется — параллельные purge, обрезка и restore того же id ждут (этап 6), а если purge успел
-  -- стереть её, пара (id, rev) столкнётся с его записью purge в журнале, и операция повторится
-  select l.rev, l.hash, l.at, l.op, l.data into last from @SCHEMA@.log l where l.id = NEW.id order by l.rev desc limit 1 for update;
+  -- воскрешение: номер версии продолжается от последней записи журнала; запись блокируется — параллельный restore того
+  -- же id ждёт (этап 6)
+  select l.rev, l.at, l.op, l.data into last from @SCHEMA@.log l where l.id = NEW.id order by l.rev desc limit 1 for update;
   -- класс с историей строк в журнале (остаток Н2 ревью №2; доработки после точки Б): правила прав находят строки, и
-  -- старые версии тоже, по именам класса, предков и алиасов — класс с другим parent, alias или derivedBy подставил бы
+  -- старые версии тоже, по именам класса, предков и алиасов — класс с другим parent или alias подставил бы
   -- старую историю под чужие правила. Поэтому, если журнал арендатора хранит версии строк класса с этим именем, класс
   -- создаётся только заново и с тем же описанием, что в надгробии его строки Class. Надгробия нет (история осталась от
-  -- класса System, удалённого раньше, или строку Class стёрли мимо триггеров) — отказ: сначала purge() строк
+  -- класса System, удалённого раньше, или строку Class стёрли мимо триггеров) — отказ
   -- Так же — если историю хранят удалённые потомки класса (их правила находят старые версии и по алиасу предка), и
-  -- политика хранения прежняя: по ней maintain() прореживает старые версии (ревью безопасности №3; у описаний без ключа
-  -- history в resolved — значение по умолчанию true)
+  -- history прежняя (ревью безопасности №3; у описаний без ключа history в resolved — значение по умолчанию true)
   if NEW.class = 'Class'
      and (@SCHEMA@.class_has_history(NEW.data->>'name', NEW.tenant) or @SCHEMA@.class_orphan_history(NEW.data->>'name', NEW.tenant))
      and not (coalesce(last.op = 'delete', false)
               and last.data->'resolved'->'ancestors' is not distinct from NEW.data->'resolved'->'ancestors'
               and last.data->>'alias' is not distinct from NEW.data->>'alias'
-              and last.data->'resolved'->'derivedBy' is not distinct from NEW.data->'resolved'->'derivedBy'
               and coalesce(last.data->'resolved'->'history', 'true'::jsonb) is not distinct from coalesce(NEW.data->'resolved'->'history', 'true'::jsonb)) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('журнал хранит историю строк класса %s или его удалённых потомков: создать его можно только заново и с прежними parent, alias, derivedBy и history (или сначала стереть её purge())',
-      NEW.data->>'name'));
+    perform @SCHEMA@.lt_fail('sql-write.history_recreate', jsonb_build_object('cls', NEW.data->>'name'));
   end if;
   ts := @SCHEMA@.now_ts();
   NEW.rev := coalesce(last.rev, 0) + 1;
-  NEW.prev_hash := last.hash;
   NEW.at := greatest(ts, last.at + interval '1 microsecond');
   NEW.created_at := NEW.at;
   NEW.cv := cls.rev;
@@ -1059,13 +921,12 @@ begin
   elsif NEW.owner not in (NEW.tenant, c.account)
         and not exists (select 1 from @SCHEMA@.entity a where a.id = NEW.owner and a.class = 'Account' and a.tenant = '@SYSTEM@'::uuid) then
     -- явный владелец — существующий аккаунт; разрешает ли его условие ACL, решает политика вставки
-    perform @SCHEMA@.lt_fail('target_not_found', 'владелец строки не найден');
+    perform @SCHEMA@.lt_fail('sql-write.owner_not_found');
   end if;
   NEW.author := c.author;
   NEW.agent := c.agent;
   NEW.op := 'create';
   NEW.reason := nullif(current_setting('letopis.reason', true), '');
-  NEW.moved := null;
   NEW.tags := coalesce(NEW.tags, '{}');
   return NEW;
 end $$;
@@ -1078,118 +939,72 @@ declare
   c record;
   cls @SCHEMA@.entity;
   res jsonb;
-  old_res jsonb;
   bad jsonb;
   lk record;
   kid uuid;
-  op text := 'update';
-  inc jsonb;
 begin
   select * into c from @SCHEMA@.ctx();
   if c.account is null then
-    perform @SCHEMA@.lt_fail('no_session', 'нет действующей сессии');
+    perform @SCHEMA@.lt_fail('sql-write.no_session');
   end if;
   if NEW.id <> OLD.id or NEW.tenant <> OLD.tenant or NEW.owner <> OLD.owner or NEW.created_at <> OLD.created_at then
-    perform @SCHEMA@.lt_fail('immutable_key', 'id, арендатора, владельца и время создания менять нельзя');
-  end if;
-  if (NEW.class = 'Class') <> (OLD.class = 'Class') then
-    perform @SCHEMA@.lt_fail('invalid_class', 'строку Class нельзя превратить в данные и наоборот');
+    perform @SCHEMA@.lt_fail('sql-write.immutable_columns');
   end if;
-  -- строки прав не получаются сменой класса: аккаунт с категориями — только в System (ревью этапа 5)
-  if NEW.class <> OLD.class and (NEW.class in ('Account', 'member', 'Resource', 'rule') or OLD.class in ('Account', 'member', 'Resource', 'rule')) then
-    perform @SCHEMA@.lt_fail('reclass_denied', 'класс системной строки не меняется');
+  -- класс строки неизменен (план 2.0, редакция 2): смены класса нет ни правкой, ни функцией
+  if NEW.class <> OLD.class then
+    perform @SCHEMA@.lt_fail('sql-write.class_immutable', jsonb_build_object('cls', OLD.class));
   end if;
   cls := @SCHEMA@.class_row(NEW.class, OLD.tenant);
   if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s не найден', NEW.class));
+    perform @SCHEMA@.lt_fail('sql-write.class_not_found', jsonb_build_object('cls', NEW.class));
   end if;
   perform @SCHEMA@.family_lock(cls, false);
   cls := @SCHEMA@.class_row(NEW.class, OLD.tenant);
   if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', NEW.class));
+    perform @SCHEMA@.lt_fail('sql-write.class_deleted', jsonb_build_object('cls', NEW.class));
   end if;
   res := cls.data->'resolved';
   if coalesce((res->>'abstract')::boolean, false) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', NEW.class));
-  end if;
-  if res ? 'derivedBy' or (NEW.class <> OLD.class and (@SCHEMA@.class_row(OLD.class, OLD.tenant)).data->'resolved' ? 'derivedBy') then
-    perform @SCHEMA@.lt_fail('derived_class', format('класс %s производный: его строки пишет проектор',
-      case when res ? 'derivedBy' then NEW.class else OLD.class end));
-  end if;
-  if NEW.class <> OLD.class then
-    -- смена класса (этап 1, п. 9): только read committed, только для классов без ключа
-    if current_setting('transaction_isolation') <> 'read committed' then
-      perform @SCHEMA@.lt_fail('isolation_level', 'смена класса разрешена только в read committed');
-    end if;
-    old_res := (@SCHEMA@.class_row(OLD.class, OLD.tenant)).data->'resolved';
-    if jsonb_array_length(coalesce(old_res->'key', '[]'::jsonb)) > 0 or jsonb_array_length(coalesce(res->'key', '[]'::jsonb)) > 0 then
-      perform @SCHEMA@.lt_fail('use_reclass', format('у класса %s или %s есть ключ: id меняется, используйте reclass()', OLD.class, NEW.class));
-    end if;
-    -- обычный update берёт слабую блокировку; смене класса нужна for update, чтобы дождаться
-    -- транзакций, которые как раз пишут ссылку на эту строку
-    perform 1 from @SCHEMA@.entity x where x.id = OLD.id for update;
-    -- строка уходит из своего класса — как удаление из него: нужно право DELETE на прежнюю строку (доработки после
-    -- точки Б; иначе с одним WRITE строку переносили в класс, где есть DELETE, и удаляли там)
-    if not @SCHEMA@.acl_row_ok(@SCHEMA@.acl_plan('DELETE'), OLD.class, OLD.id, OLD.owner, OLD.tenant, OLD.tags, OLD.data, OLD.links) then
-      perform @SCHEMA@.lt_fail('acl_denied', format('нет права DELETE на строку класса %s: смена класса убирает её из класса', OLD.class));
-    end if;
-    inc := @SCHEMA@.incoming_conflicts(OLD.id, NEW.class, OLD.tenant);
-    if inc <> '[]'::jsonb then
-      perform @SCHEMA@.lt_fail('reclass_denied', format('роли ссылающихся строк не принимают класс %s', NEW.class),
-        @SCHEMA@.visible_detail(inc, c.tenant));
-    end if;
-    op := 'reclass';
+    perform @SCHEMA@.lt_fail('sql-write.class_abstract', jsonb_build_object('cls', NEW.class));
   end if;
   if NEW.class = 'Class' then
     select a.data, a.validator into NEW.data, NEW.validator from @SCHEMA@.class_admit(NEW.data, OLD.tenant) a;
   else
-    -- агрегатное поле (план 1.1, §2.4): изменить его нельзя, без поля (замена данных целиком) — прежнее значение;
-    -- при смене класса — прежнее число или 0, итог посчитает триггер после оператора
-    if res ? 'aggregate' then
-      NEW.data := @SCHEMA@.agg_guard(res, OLD.data, NEW.data, NEW.class <> OLD.class);
-    end if;
     NEW.data := @SCHEMA@.apply_defaults(res->'schema', NEW.data);
     bad := @SCHEMA@.validate_data(res->'rules', cls.validator, res->'vars', NEW.data);
     if bad <> '[]'::jsonb then
-      perform @SCHEMA@.lt_fail('invalid_data', format('данные не проходят описание класса %s', NEW.class), jsonb_build_object('issues', bad));
+      perform @SCHEMA@.lt_fail('sql-write.invalid_data', jsonb_build_object('cls', NEW.class), jsonb_build_object('issues', bad));
     end if;
     NEW.validator := null;
   end if;
   select * into lk from @SCHEMA@.links_shape(res, NEW.links);
-  if lk.code is not null then
-    perform @SCHEMA@.lt_fail(lk.code, lk.msg);
+  if lk.key is not null then
+    perform @SCHEMA@.lt_fail(lk.key, lk.params);
   end if;
   NEW.links := lk.links;
   if NEW.class = 'member' and NEW.links->>'Tenant' is distinct from OLD.tenant::text then
-    perform @SCHEMA@.lt_fail('invalid_data', 'конец Tenant членства — арендатор строки');
+    perform @SCHEMA@.lt_fail('sql-write.member_tenant');
   end if;
   kid := @SCHEMA@.key_id(res, NEW.class, OLD.tenant, NEW.data, NEW.links);
   if kid is not null and kid <> OLD.id then
-    perform @SCHEMA@.lt_fail('immutable_key', format('ключевое поле класса %s менять нельзя: id изменился бы (rekey)', NEW.class));
+    perform @SCHEMA@.lt_fail('sql-write.key_changed', jsonb_build_object('cls', NEW.class));
   end if;
   -- ничего не изменилось: строка возвращается как есть, версии нет, оператор считает её затронутой
-  if NEW.class = OLD.class and NEW.data = OLD.data and NEW.links = OLD.links and NEW.tags = OLD.tags then
+  if NEW.data = OLD.data and NEW.links = OLD.links and NEW.tags = OLD.tags then
     return OLD;
   end if;
   if NEW.class = 'Class' and not @SCHEMA@.class_change_safe(OLD.data->'resolved', NEW.data->'resolved') then
     -- ужесточение: исключительная блокировка корня семейства (и нового корня при смене родителя)
     perform @SCHEMA@.family_lock(OLD, true);
     perform @SCHEMA@.family_lock(NEW, true);
-    -- смена агрегатов — ещё семейства источников (план 1.1, §2.4): операция, зафиксированная до пересчёта, в него
-    -- войдёт, а ожидающая допишет вклад уже по новому описанию
-    if OLD.data->'resolved'->'aggregate' is distinct from NEW.data->'resolved'->'aggregate' then
-      perform @SCHEMA@.agg_lock_sources(OLD.data->'resolved', NEW.data->'resolved', OLD.tenant);
-    end if;
   end if;
   NEW.rev := OLD.rev + 1;
-  NEW.prev_hash := OLD.hash;
   NEW.at := greatest(@SCHEMA@.now_ts(), OLD.at + interval '1 microsecond');
   NEW.cv := cls.rev;
   NEW.author := c.author;
   NEW.agent := c.agent;
-  NEW.op := op;
+  NEW.op := 'update';
   NEW.reason := nullif(current_setting('letopis.reason', true), '');
-  NEW.moved := null;
   return NEW;
 end $$;
 
@@ -1208,13 +1023,11 @@ begin
     bad := @SCHEMA@.targets_bad((select jsonb_agg(jsonb_build_object('class', n.class, 'tenant', n.tenant, 'links', n.links))
                                  from added n where n.links <> '{}'::jsonb), true, @SCHEMA@.acl_actor('READ'));
   end if;
-  if bad like '!%' then
-    perform @SCHEMA@.lt_fail('derived_class', format('конец %s ведёт на строку производного класса', substr(bad, 2)));
-  elsif bad is not null then
-    perform @SCHEMA@.lt_fail('target_not_found', format('цель конца %s не найдена', bad));
+  if bad is not null then
+    perform @SCHEMA@.lt_fail('sql-write.end_target_missing', jsonb_build_object('end', bad));
   end if;
-  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash)
-  select n.id, n.rev, n.class, n.cv, n.tenant, n.owner, n.links, n.data, n.tags, n.at, n.author, n.agent, n.op, n.reason, n.moved, n.prev_hash
+  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason)
+  select n.id, n.rev, n.class, n.cv, n.tenant, n.owner, n.links, n.data, n.tags, n.at, n.author, n.agent, n.op, n.reason
   from added n
   join (select k.class, k.tenant from (select distinct a.class, a.tenant from added a) k
         where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant
@@ -1225,19 +1038,6 @@ begin
   if sc && array['rule', 'Resource', 'member', 'Account', 'Class'] then
     perform @SCHEMA@.acl_bump();
   end if;
-  if 'Class' = any (sc) then
-    -- новый класс — источник агрегата (ревью коммита этапа 4б): нужно право READ без условий на все его строки; план
-    -- прав после acl_bump видит новый класс
-    perform @SCHEMA@.agg_source_admit(n.data->>'name', @SCHEMA@.agg_new_mark(null, n.data->'resolved'))
-    from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregatedBy';
-    -- и описавшему агрегат (хвост ревью доработок после 1.2.0): заведя потомка источника, читающий всё пользователь
-    -- иначе открыл бы его строки тому, кто описал агрегат без права на них
-    perform @SCHEMA@.agg_author_admit(n.data->>'name', n.tenant, null, n.data->'resolved')
-    from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregatedBy';
-    -- новая цель агрегатов (план 1.1, §2.4): метки её источников (aggregatedBy) — заново
-    perform @SCHEMA@.agg_mark(n.tenant, @SCHEMA@.agg_of(n.data->'resolved'))
-    from added n where n.class = 'Class' and n.data->'resolved' ? 'aggregate';
-  end if;
   return null;
 end $$;
 
@@ -1256,31 +1056,26 @@ declare
   cid uuid;
   bad text;
 begin
-  -- цели проверяются у строк, у которых изменились концы или класс
+  -- цели проверяются у строк, у которых изменились концы
   if exists (select 1 from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev
-             where n.links <> '{}'::jsonb and (n.links <> o.links or n.class <> o.class)) then
+             where n.links <> '{}'::jsonb and n.links <> o.links) then
     bad := @SCHEMA@.targets_bad((select jsonb_agg(jsonb_build_object('class', n.class, 'tenant', n.tenant, 'links', n.links))
                                  from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev
-                                 where n.links <> '{}'::jsonb and (n.links <> o.links or n.class <> o.class)), true, @SCHEMA@.acl_actor('READ'));
+                                 where n.links <> '{}'::jsonb and n.links <> o.links), true, @SCHEMA@.acl_actor('READ'));
   end if;
-  if bad like '!%' then
-    perform @SCHEMA@.lt_fail('derived_class', format('конец %s ведёт на строку производного класса', substr(bad, 2)));
-  elsif bad is not null then
-    perform @SCHEMA@.lt_fail('target_not_found', format('цель конца %s не найдена', bad));
+  if bad is not null then
+    perform @SCHEMA@.lt_fail('sql-write.end_target_missing', jsonb_build_object('end', bad));
   end if;
-  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
-  select n.id, n.rev, n.class, n.cv, n.tenant, n.owner, n.links, n.data, n.tags, n.at, n.author, n.agent, n.op, n.reason, n.moved, n.prev_hash,
-         @SCHEMA@.change_paths(o.data, o.links, o.tags, o.owner, o.class, n.data, n.links, n.tags, n.owner, n.class)
+  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason)
+  select n.id, n.rev, n.class, n.cv, n.tenant, n.owner, n.links, n.data, n.tags, n.at, n.author, n.agent, n.op, n.reason
   from new_rows n
   join old_rows o on o.id = n.id and o.rev <> n.rev
   join (select k.class, k.tenant from (select distinct a.class, a.tenant from new_rows a) k
         where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant
   order by n.id;  -- порядок seq не зависит от плана: правка многих строк пишет версии в порядке id
-  -- сигнал — по парам нового и прежнего класса: при смене класса без ключа ответы прежнего класса в
-  -- кэше других процессов устарели бы (в 1.0.1 сигнал шёл только по новому)
+  -- сигнал — по паре «класс, арендатор» (класс и арендатор строки неизменны)
   select array_agg(k.class), array_agg(k.tenant) into sc, st
-  from (select distinct v.class, v.tenant from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev
-        cross join lateral (values (n.class, n.tenant), (o.class, o.tenant)) v(class, tenant)) k;
+  from (select distinct n.class, n.tenant from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev) k;
   perform @SCHEMA@.signal(sc, st);
   if sc && array['rule', 'Resource', 'member', 'Account', 'Class'] then
     perform @SCHEMA@.acl_bump();
@@ -1289,10 +1084,6 @@ begin
              where n.class = 'Class' order by n.id loop
     select * into o_row from old_rows x where x.id = cid;
     select * into n_row from new_rows x where x.id = cid;
-    -- класс становится источником агрегата (смена parent; ревью коммита этапа 4б): право READ без условий на его строки
-    -- и после правки — по новым предкам (до правки проверил class_admit)
-    perform @SCHEMA@.agg_source_admit(n_row.data->>'name', @SCHEMA@.agg_new_mark(o_row.data->'resolved', n_row.data->'resolved'));
-    perform @SCHEMA@.agg_author_admit(n_row.data->>'name', n_row.tenant, o_row.data->'resolved', n_row.data->'resolved');
     perform @SCHEMA@.class_evolve(o_row, n_row);
   end loop;
   -- отключённый аккаунт: сессии гаснут (этап 5, п. 2), каждая — сигнал кэшу
@@ -1314,15 +1105,7 @@ declare
   classes text[] := array[n.data->>'name'];
   conflicts jsonb;
   c record;
-  -- агрегаты (план 1.1, §2.4): источники, чьи метки пересчитываются; цели, поле которых считается заново
-  agg_names text[] := '{}';
-  agg_own text[] := '{}';
-  agg_other text[] := @SCHEMA@.agg_marked(o.data->'resolved', n.data->'resolved');
 begin
-  if o.data->'resolved'->'aggregate' is distinct from n.data->'resolved'->'aggregate' then
-    agg_names := @SCHEMA@.agg_of(o.data->'resolved') || @SCHEMA@.agg_of(n.data->'resolved');
-    agg_own := agg_own || (n.data->>'name');
-  end if;
   -- потомки: описание resolved и validator пересчитываются, каждый пересчёт — версия класса в журнале
   for d in select x.* from @SCHEMA@.entity x
            where x.class = 'Class' and x.id <> n.id
@@ -1333,43 +1116,18 @@ begin
     if prep.data is distinct from d.data or prep.validator::text is distinct from d.validator::text then
       perform @SCHEMA@.sys_update(d.id, prep.data, d.links, prep.validator, 'update');
     end if;
-    -- потомок становится источником вместе с классом (смена parent; ревью коммита этапа 4б) — то же право READ на его
-    -- строки по новым предкам (до правки проверил class_admit). class_evolve зовёт только триггер правки приложения;
-    -- потомков класса System у арендаторов план прав сессии System не видит, их строки считают агрегаты System для
-    -- целей того же арендатора
-    if d.tenant = n.tenant then
-      perform @SCHEMA@.agg_source_admit(d.data->>'name', @SCHEMA@.agg_new_mark(d.data->'resolved', prep.data->'resolved'));
-    end if;
-    -- и описавшему агрегат — в объёме описания (agg_author_admit сам пропускает класс арендатора под агрегатом System)
-    perform @SCHEMA@.agg_author_admit(d.data->>'name', d.tenant, d.data->'resolved', prep.data->'resolved');
     classes := classes || (d.data->>'name');
-    if d.data->'resolved'->'aggregate' is distinct from prep.data->'resolved'->'aggregate' then
-      agg_names := agg_names || @SCHEMA@.agg_of(d.data->'resolved') || @SCHEMA@.agg_of(prep.data->'resolved');
-      agg_own := agg_own || (d.data->>'name');
-    end if;
-    agg_other := agg_other || @SCHEMA@.agg_marked(d.data->'resolved', prep.data->'resolved');
   end loop;
-  -- агрегаты семейства изменились: метки источников заново и поле у всех целей — из живых источников (строки
-  -- проверит ужесточение ниже); у источника сменились предки — заново цели, которые его считают
-  if cardinality(agg_names) > 0 then
-    perform @SCHEMA@.agg_mark(n.tenant, agg_names);
-  end if;
-  if cardinality(agg_own) > 0 then
-    perform @SCHEMA@.agg_refresh(agg_own, n.tenant, false);
-  end if;
-  if cardinality(agg_other) > 0 then
-    perform @SCHEMA@.agg_refresh(agg_other, n.tenant, true);
-  end if;
   if not @SCHEMA@.class_change_safe(o.data->'resolved', n.data->'resolved') then
     -- ужесточение проверяет все строки семейства, в том числе невидимые актору, и отвечает их числом: пробное
     -- ужесточение (maximum, enum, pattern…) было оракулом по чужим строкам (доработки после точки Б). Нужно право READ
     -- без условий на все строки класса и потомков своего арендатора; строки других арендаторов (класс System) —
     -- уровень установки, их число остаётся в others
-    perform @SCHEMA@.class_rows_admit(n.data->>'name', n.tenant, array['READ'], format('ужесточение класса %s', n.data->>'name'));
+    perform @SCHEMA@.class_rows_admit(n.data->>'name', n.tenant, array['READ'], 'tighten');
     conflicts := @SCHEMA@.family_conflicts(classes, n.tenant, o.data->'resolved'->'ancestors' is distinct from n.data->'resolved'->'ancestors');
     if conflicts <> '[]'::jsonb then
       select * into c from @SCHEMA@.ctx();
-      perform @SCHEMA@.lt_fail('tightening_conflict', format('новому описанию класса %s не соответствуют строки', n.data->>'name'),
+      perform @SCHEMA@.lt_fail('sql-write.tightening_mismatch', jsonb_build_object('cls', n.data->>'name'),
         @SCHEMA@.visible_detail(conflicts, c.tenant));
     end if;
   end if;
@@ -1382,7 +1140,7 @@ set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 begin
   if current_setting('transaction_isolation') <> 'read committed' then
-    perform @SCHEMA@.lt_fail('isolation_level', 'удаление разрешено только в read committed');
+    perform @SCHEMA@.lt_fail('sql-write.delete_isolation');
   end if;
   return null;
 end $$;
@@ -1392,14 +1150,14 @@ end $$;
 -- после него, поэтому сессии гаснут с сигналом session:<хэш> здесь: процессы сбрасывают кэш ответов этих сессий.
 -- Срабатывает для всех ролей, в том числе владельца: аккаунты удаляют и функции владельца — каскад trg_entity_ad и
 -- account_purge. Строка Account у System не удаляется: ей принадлежат служебные строки secret (KEY — ключ прав и
--- сигналов, LOCK — строки-замки, PROJECTOR — чекпоинты проекторов), которые каскад стёр бы, а без них установка не пишет.
+-- сигналов, LOCK — строки-замки), которые каскад стёр бы, а без них установка не пишет.
 create or replace function @SCHEMA@.trg_entity_bd_account() returns trigger
 language plpgsql security definer
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 begin
   if OLD.id = '@SYSTEM@'::uuid then
-    perform @SCHEMA@.lt_fail('acl_denied', 'аккаунт System не удаляется: ему принадлежат служебные строки установки');
+    perform @SCHEMA@.lt_fail('sql-write.system_account_delete');
   end if;
   perform @SCHEMA@.auth_kill(OLD.id, null);
   return OLD;
@@ -1438,10 +1196,10 @@ begin
   for r in select x.* from @SCHEMA@.entity x where x.owner = p_user and x.owner <> x.tenant and x.tenant = p_tenant
            order by x.id for update loop
     update @SCHEMA@.entity x
-       set owner = p_tenant, rev = x.rev + 1, prev_hash = x.hash,
+       set owner = p_tenant, rev = x.rev + 1,
            at = greatest(@SCHEMA@.now_ts(), x.at + interval '1 microsecond'),
            author = coalesce(c.author, '@SYSTEM@'::uuid), agent = c.agent, op = 'update',
-           reason = nullif(current_setting('letopis.reason', true), ''), moved = null
+           reason = nullif(current_setting('letopis.reason', true), '')
      where x.id = r.id
     returning x.* into r;
     perform @SCHEMA@.log_version(r);
@@ -1488,13 +1246,7 @@ begin
   dplan := @SCHEMA@.acl_plan('DELETE');
   wplan := @SCHEMA@.acl_plan('WRITE');
   if exists (select 1 from @SCHEMA@.entity x join gone g on g.id = x.id) then
-    perform @SCHEMA@.lt_fail('recreated_in_statement', 'id удалён и создан заново одним оператором');
-  end if;
-  -- строки производного класса удаляет только проектор (каскад функции владельца сюда не доходит)
-  select d.class into denied from (select distinct g.class, g.tenant from gone g) d
-  where (@SCHEMA@.class_row(d.class, d.tenant)).data->'resolved' ? 'derivedBy' limit 1;
-  if denied is not null then
-    perform @SCHEMA@.lt_fail('derived_class', format('класс %s производный: его строки удаляет проектор', denied));
+    perform @SCHEMA@.lt_fail('sql-write.recreated_in_statement');
   end if;
   -- удаление класса (хвост ревью безопасности доработок после 1.2.0): проверки ниже — нет строк, потомков и истории —
   -- не видят строку, которую писатель ещё не зафиксировал, и она осталась бы без класса, а с ней история удалённого
@@ -1503,25 +1255,7 @@ begin
   for cl in select g.* from gone g where g.class = 'Class' order by @SCHEMA@.family_name(g.tenant, g.data), g.id loop
     perform @SCHEMA@.family_lock(cl, true);
   end loop;
-  for r in select g.id, g.tenant, g.data->>'name' as name, g.data->'resolved' ? 'derivedBy' as derived from gone g where g.class = 'Class' loop
-    -- производный класс удаляет только администратор (class_admit)
-    if r.derived and not @SCHEMA@.letopis_allowed('letopis.projector') then
-      perform @SCHEMA@.lt_fail('acl_denied', format('класс %s производный: его описание задаёт только администратор (право letopis.projector)', r.name));
-    end if;
-    -- класс-источник агрегата (автоматическое ревью коммита 5290be1): пока его называет агрегат класса того же
-    -- арендатора, класс не удаляется — иначе класс с этим именем завёл бы потом другой пользователь, и право READ
-    -- описавшего агрегат на его строки уже не проверить (класс of проверяется только при описании агрегата). Агрегаты
-    -- классов System описывает системный администратор: он читает всё
-    if r.tenant <> '@SYSTEM@'::uuid then
-      select x.data->>'name' || '.' || a.key into denied
-      from @SCHEMA@.entity x cross join lateral jsonb_each(x.data->'resolved'->'aggregate') a
-      where x.class = 'Class' and x.tenant = r.tenant and x.data->'resolved' ? 'aggregate' and a.value->>'of' = r.name
-      order by 1 limit 1;
-      if denied is not null then
-        perform @SCHEMA@.lt_fail('invalid_class', format('класс %s — источник агрегата %s: сначала уберите агрегат из описания цели',
-          r.name, denied));
-      end if;
-    end if;
+  for r in select g.id, g.tenant, g.data->>'name' as name from gone g where g.class = 'Class' loop
     -- у класса System — строки и потомки любого арендатора, кроме арендаторов со своим одноимённым классом: их строки и
     -- потомки относятся к своему классу (class_row; ревью безопасности №3)
     own := case when r.tenant = '@SYSTEM@'::uuid
@@ -1532,24 +1266,21 @@ begin
                where x.class = r.name and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid and x.tenant <> all (own)))
        or exists (select 1 from @SCHEMA@.entity x where x.class = 'Class' and x.data->>'parent' = r.name
                   and (x.tenant = r.tenant or r.tenant = '@SYSTEM@'::uuid and x.tenant <> all (own))) then
-      perform @SCHEMA@.lt_fail('invalid_class', format('у класса %s есть строки или потомки', r.name));
+      perform @SCHEMA@.lt_fail('sql-write.class_not_empty', jsonb_build_object('cls', r.name));
     end if;
     -- и история строк (остаток Н2; доработки после точки Б): удалённый класс с историей, созданный заново с другими
-    -- предками или алиасом, подставил бы её под чужие правила — сначала purge() удалённых строк
+    -- предками или алиасом, подставил бы её под чужие правила — класс с историей строк не удаляется
     if @SCHEMA@.class_has_history(r.name, r.tenant) then
-      perform @SCHEMA@.lt_fail('invalid_class', format('у класса %s есть история строк в журнале: сначала стереть её purge() удалённых строк', r.name));
+      perform @SCHEMA@.lt_fail('sql-write.class_has_history', jsonb_build_object('cls', r.name));
     end if;
   end loop;
-  -- удалена цель агрегатов (план 1.1, §2.4): метки её источников — уже без неё
-  perform @SCHEMA@.agg_mark(g.tenant, @SCHEMA@.agg_of(g.data->'resolved'))
-  from gone g where g.class = 'Class' and g.data->'resolved' ? 'aggregate';
   v_author := coalesce(c.author, '@SYSTEM@'::uuid);
   -- надгробия: последний снимок следующей версией с видом delete — одной вставкой на уровень, в порядке id: без
   -- order by порядок seq (а с ним итог delete() и время at) зависел от плана соединения и менялся от прогона к
   -- прогону; время now_ts() (volatile) планировщик вычисляет уже после сортировки
-  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
+  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason)
   select g.id, g.rev + 1, g.class, g.cv, g.tenant, g.owner, g.links, g.data, g.tags,
-         greatest(@SCHEMA@.now_ts(), g.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason, null, g.hash, '[]'::jsonb
+         greatest(@SCHEMA@.now_ts(), g.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason
   from gone g
   join (select d.class, d.tenant from (select distinct x.class, x.tenant from gone x) d
         where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant
@@ -1580,9 +1311,9 @@ begin
       where x.id in (select y.id from @SCHEMA@.entity y where y.id = any (casc) order by y.id for update)
       returning x.*
     ), t as (
-      insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
+      insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason)
       select d.id, d.rev + 1, d.class, d.cv, d.tenant, d.owner, d.links, d.data, d.tags,
-             greatest(@SCHEMA@.now_ts(), d.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason, null, d.hash, '[]'::jsonb
+             greatest(@SCHEMA@.now_ts(), d.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason
       from d
       join (select dd.class, dd.tenant from (select distinct x.class, x.tenant from d x) dd
             where @SCHEMA@.history_on(dd.class, dd.tenant)) h on h.class = d.class and h.tenant = d.tenant
@@ -1596,8 +1327,10 @@ begin
     -- класс отказавшей строки называется, только если актор её видит (ревью безопасности №3)
     if drows is not null then
       denied := @SCHEMA@.visible_class(drows);
-      perform @SCHEMA@.lt_fail('acl_denied', case when denied is not null then format('нет права DELETE на класс %s в каскаде удаления', denied)
-                                                   else 'нет права DELETE на строки в каскаде удаления' end);
+      if denied is not null then
+        perform @SCHEMA@.lt_fail('sql-write.cascade_delete_denied', jsonb_build_object('cls', denied));
+      end if;
+      perform @SCHEMA@.lt_fail('sql-write.cascade_delete_denied_hidden');
     end if;
     mems := mems || lvl_mems;
     classes := classes || lvl_classes;
@@ -1605,9 +1338,10 @@ begin
     -- unset: снять конец, новая версия
     for r in select x.* from @SCHEMA@.entity x where x.id = any (unsets) order by x.id for update loop
       if not @SCHEMA@.acl_row_ok(wplan, r.class, r.id, r.owner, r.tenant, r.tags, r.data, r.links) then
-        perform @SCHEMA@.lt_fail('acl_denied', case when @SCHEMA@.visible_class(jsonb_build_array(to_jsonb(r))) is not null
-                                                     then format('нет права WRITE на класс %s: снятие конца при удалении', r.class)
-                                                     else 'нет права WRITE на ссылающуюся строку: снятие конца при удалении' end);
+        if @SCHEMA@.visible_class(jsonb_build_array(to_jsonb(r))) is not null then
+          perform @SCHEMA@.lt_fail('sql-write.unset_write_denied', jsonb_build_object('cls', r.class));
+        end if;
+        perform @SCHEMA@.lt_fail('sql-write.unset_write_denied_hidden');
       end if;
       newlinks := '{}'::jsonb;
       for k in select key, value from jsonb_each(r.links) loop
@@ -1638,7 +1372,7 @@ begin
   select coalesce(jsonb_agg(jsonb_build_object('id', x.id, 'class', x.class, 'tenant', x.tenant)), '[]'::jsonb) into blockers
   from (select x.id, x.class, x.tenant from @SCHEMA@.entity x where x.ends && all_ids order by x.id limit 1000) x;
   if blockers <> '[]'::jsonb then
-    perform @SCHEMA@.lt_fail('delete_restricted', 'на удаляемые строки ссылаются другие строки (onDelete: restrict)',
+    perform @SCHEMA@.lt_fail('sql-write.delete_restricted', '{}'::jsonb,
       @SCHEMA@.visible_detail(blockers, c.tenant));
   end if;
   return null;
@@ -1708,9 +1442,7 @@ create or replace trigger entity_bi before insert on @SCHEMA@.entity
   for each row when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_bi();
 create or replace trigger entity_bu before update on @SCHEMA@.entity
   for each row when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_bu();
--- до ревизии 2 журнал писал строковый триггер entity_ai после insert или update
-drop trigger if exists entity_ai on @SCHEMA@.entity;
-create trigger entity_ai after insert on @SCHEMA@.entity referencing new table as added
+create or replace trigger entity_ai after insert on @SCHEMA@.entity referencing new table as added
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_ai();
 create or replace trigger entity_au after update on @SCHEMA@.entity referencing old table as old_rows new table as new_rows
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_au();
@@ -1730,192 +1462,6 @@ alter table @SCHEMA@.entity enable always trigger entity_bd;
 alter table @SCHEMA@.entity enable always trigger entity_bd_account;
 alter table @SCHEMA@.entity enable always trigger entity_ad;
 
--- ========================= смена класса с ключом =========================
-
--- Замена id цели во всех концах.
-create or replace function @SCHEMA@.links_replace(p_links jsonb, p_old uuid, p_new uuid) returns jsonb
-language sql immutable parallel safe
-return (
-  select coalesce(jsonb_object_agg(k.key, case jsonb_typeof(k.value)
-    when 'array' then coalesce((select jsonb_agg(case when x = p_old::text then to_jsonb(p_new::text) else to_jsonb(x) end)
-                                from jsonb_array_elements_text(k.value) x), '[]'::jsonb)
-    else case when k.value #>> '{}' = p_old::text then to_jsonb(p_new::text) else k.value end end), '{}'::jsonb)
-  from jsonb_each(p_links) k
-);
-
--- Перенос строки на новый id (смена класса с ключом, смена ключа): новая строка продолжает журнал
--- нового id и ссылается на старый (moved), ссылки переводятся — если переведённый конец входит
--- в ключ ссылающейся строки, её id тоже меняется, и перевод идёт дальше рекурсивно; старая строка
--- удаляется с надгробием, которое ссылается на новый id. Проверки делает вызывающая функция; p_plan — план WRITE
--- актора (reclass, rekey, rekey_class): каждая строка, чьи ссылки перевод переписывает, на всех уровнях рекурсии должна
--- им проходить (доработки после точки Б: прежде проверялся только первый уровень); null — путь владельца.
--- Агрегаты (план 1.1, §2.4): перенос — несколько операторов (новая строка, перевод ссылок, удаление старой), и
--- триггер агрегатов на это время только копит их вклады (agg_hold_begin), а в конце применяет одним итогом: сумма
--- не проходит через промежуточные значения, новая цель считается целиком из живых источников.
-drop function if exists @SCHEMA@.move_row(@SCHEMA@.entity, uuid, text, jsonb, jsonb, text);
-create or replace function @SCHEMA@.move_row(o @SCHEMA@.entity, p_new_id uuid, p_class text, p_data jsonb, p_links jsonb, p_op text,
-  p_plan jsonb default null)
-returns @SCHEMA@.entity
-language plpgsql volatile
-set search_path = pg_catalog, @SCHEMA@, pg_temp
-as $$
-declare
-  c record;
-  last record;
-  ts timestamptz;
-  n @SCHEMA@.entity;
-  r @SCHEMA@.entity;
-  nl jsonb;
-  rid uuid;
-  held boolean := @SCHEMA@.agg_hold_begin('acc');
-begin
-  select * into c from @SCHEMA@.ctx();
-  select l.rev, l.hash, l.at into last from @SCHEMA@.log l where l.id = p_new_id order by l.rev desc limit 1 for update;
-  ts := greatest(@SCHEMA@.now_ts(), last.at + interval '1 microsecond');
-  insert into @SCHEMA@.entity (id, rev, class, cv, tenant, owner, links, data, tags, at, created_at, author, agent, op, reason, moved, prev_hash, validator)
-  values (p_new_id, coalesce(last.rev, 0) + 1, p_class, coalesce((@SCHEMA@.class_row(p_class, o.tenant)).rev, 0), o.tenant, o.owner,
-          p_links, p_data, o.tags, ts, ts, coalesce(c.author, '@SYSTEM@'::uuid), c.agent, p_op,
-          nullif(current_setting('letopis.reason', true), ''), o.id, last.hash, null)
-  returning * into n;
-  perform @SCHEMA@.log_version(n);
-  for r in select x.* from @SCHEMA@.entity x where x.ends @> array[o.id] and x.id <> p_new_id order by x.id for update loop
-    -- строки производного класса пишет только проектор: перевод их ссылок мимо него оставил бы проекцию
-    -- несогласованной (ревью безопасности №3, №3)
-    if (@SCHEMA@.class_row(r.class, r.tenant)).data->'resolved' ? 'derivedBy' then
-      perform @SCHEMA@.lt_fail('derived_class',
-        case when p_plan is null or @SCHEMA@.visible_class(jsonb_build_array(to_jsonb(r))) is not null
-             then format('на строку ссылается строка производного класса %s: её пишет проектор', r.class)
-             else 'на строку ссылается строка производного класса: её пишет проектор' end);
-    end if;
-    if p_plan is not null and not @SCHEMA@.acl_row_ok(p_plan, r.class, r.id, r.owner, r.tenant, r.tags, r.data, r.links) then
-      perform @SCHEMA@.lt_fail('acl_denied', 'нет права WRITE на ссылающиеся строки');
-    end if;
-    nl := @SCHEMA@.links_replace(r.links, o.id, p_new_id);
-    rid := coalesce(@SCHEMA@.key_id((@SCHEMA@.class_row(r.class, r.tenant)).data->'resolved', r.class, r.tenant, r.data, nl), r.id);
-    if rid <> r.id then
-      perform @SCHEMA@.move_row(r, rid, r.class, r.data, nl, 'rekey', p_plan);
-    else
-      perform @SCHEMA@.sys_update(r.id, r.data, nl, r.validator, 'update');
-    end if;
-  end loop;
-  delete from @SCHEMA@.entity x where x.id = o.id returning x.* into r;
-  -- надгробие всегда вида delete (по нему срез на момент отличает удалённый id), moved — новый id
-  perform @SCHEMA@.tombstone(r, 'delete', p_new_id);
-  if held then
-    perform @SCHEMA@.agg_hold_end(true);
-  end if;
-  return n;
-end $$;
-
--- Смена класса (этап 1, п. 9): у класса с ключом id вычисляется заново для нового класса, ссылки
--- переводятся в той же транзакции, журнал связывает старый и новый id. У класса без ключа id
--- сохраняется. Только read committed; на строку сначала берётся for update.
-create or replace function @SCHEMA@.reclass(p_id uuid, p_class text, p_data jsonb default null) returns uuid
-language plpgsql volatile security definer
-set search_path = pg_catalog, @SCHEMA@, pg_temp
-as $$
-declare
-  c record;
-  o @SCHEMA@.entity;
-  cls @SCHEMA@.entity;
-  res jsonb;
-  d jsonb;
-  bad jsonb;
-  lk record;
-  nid uuid;
-  inc jsonb;
-  rd jsonb;
-  wplan jsonb;
-  denied text;
-  n_denied int;
-begin
-  select * into c from @SCHEMA@.ctx();
-  if c.account is null then
-    perform @SCHEMA@.lt_fail('no_session', 'нет действующей сессии');
-  end if;
-  if current_setting('transaction_isolation') <> 'read committed' then
-    perform @SCHEMA@.lt_fail('isolation_level', 'смена класса разрешена только в read committed');
-  end if;
-  rd := @SCHEMA@.acl_actor('READ');
-  wplan := @SCHEMA@.acl_plan('WRITE');
-  select x.* into o from @SCHEMA@.entity x where x.id = p_id and x.tenant = c.tenant for update;
-  if o.id is null or not @SCHEMA@.row_visible(o.tenant, o.class, o.id, o.owner, o.tags, o.data, o.links, c.tenant, c.account, rd->'plan') then
-    perform @SCHEMA@.lt_fail('target_not_found', 'цель не найдена');
-  end if;
-  if not @SCHEMA@.acl_row_ok(wplan, o.class, o.id, o.owner, o.tenant, o.tags, o.data, o.links) then
-    perform @SCHEMA@.lt_fail('acl_denied', format('нет права WRITE на строку класса %s', o.class));
-  end if;
-  -- строка уходит из своего класса — как удаление из него: нужно право DELETE на прежнюю строку (доработки после
-  -- точки Б; иначе с одним WRITE строку переносили в класс, где есть DELETE, и удаляли там)
-  if not @SCHEMA@.acl_row_ok(@SCHEMA@.acl_plan('DELETE'), o.class, o.id, o.owner, o.tenant, o.tags, o.data, o.links) then
-    perform @SCHEMA@.lt_fail('acl_denied', format('нет права DELETE на строку класса %s: смена класса убирает её из класса', o.class));
-  end if;
-  -- строки прав и классов функция не трогает
-  if o.class in ('Class', 'Account', 'member', 'Resource', 'rule') or p_class in ('Class', 'Account', 'member', 'Resource', 'rule') then
-    perform @SCHEMA@.lt_fail('reclass_denied', 'класс системной строки не меняется');
-  end if;
-  cls := @SCHEMA@.class_row(p_class, o.tenant);
-  if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s не найден', p_class));
-  end if;
-  perform @SCHEMA@.family_lock(cls, false);
-  cls := @SCHEMA@.class_row(p_class, o.tenant);
-  if cls.id is null then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s удалён', p_class));
-  end if;
-  res := cls.data->'resolved';
-  if coalesce((res->>'abstract')::boolean, false) then
-    perform @SCHEMA@.lt_fail('invalid_class', format('класс %s абстрактный', p_class));
-  end if;
-  if res ? 'derivedBy' or (@SCHEMA@.class_row(o.class, o.tenant)).data->'resolved' ? 'derivedBy' then
-    perform @SCHEMA@.lt_fail('derived_class', 'строки производного класса пишет только его проектор');
-  end if;
-  d := coalesce(p_data, o.data);
-  -- агрегатные поля нового класса считает база (план 1.1, §2.4): в данных их не передают; прежнее число остаётся
-  -- до пересчёта, иначе 0
-  if res ? 'aggregate' then
-    if p_data ?| @SCHEMA@.agg_fields(res) then
-      perform @SCHEMA@.lt_fail('aggregate_field', format('агрегатные поля класса %s считает база — в данных reclass их не передают', p_class));
-    end if;
-    d := @SCHEMA@.agg_zero(res, d);
-  end if;
-  d := @SCHEMA@.apply_defaults(res->'schema', d);
-  bad := @SCHEMA@.validate_data(res->'rules', cls.validator, res->'vars', d);
-  if bad <> '[]'::jsonb then
-    perform @SCHEMA@.lt_fail('invalid_data', format('данные не проходят описание класса %s', p_class), jsonb_build_object('issues', bad));
-  end if;
-  select * into lk from @SCHEMA@.check_links(res, o.links, o.tenant, true, rd);
-  if lk.code is not null then
-    perform @SCHEMA@.lt_fail(lk.code, lk.msg);
-  end if;
-  inc := @SCHEMA@.incoming_conflicts(o.id, p_class, o.tenant);
-  if inc <> '[]'::jsonb then
-    perform @SCHEMA@.lt_fail('reclass_denied', format('роли ссылающихся строк не принимают класс %s', p_class),
-      @SCHEMA@.visible_detail(inc, c.tenant));
-  end if;
-  nid := coalesce(@SCHEMA@.key_id(res, p_class, o.tenant, d, lk.links), o.id);
-  if not @SCHEMA@.acl_row_ok(wplan, p_class, nid, o.owner, o.tenant, o.tags, d, lk.links) then
-    perform @SCHEMA@.lt_fail('acl_denied', format('нет права WRITE на класс %s', p_class));
-  end if;
-  if nid <> o.id then
-    -- перевод ссылок пишет ссылающиеся строки: на них тоже нужно право WRITE (глубже первого уровня — move_row);
-    -- класс такой строки называется, только если актор её видит
-    select min(x.class) filter (where @SCHEMA@.row_visible(x.tenant, x.class, x.id, x.owner, x.tags, x.data, x.links, c.tenant, c.account, rd->'plan')),
-           count(*) into denied, n_denied from @SCHEMA@.entity x
-    where x.ends @> array[o.id] and not @SCHEMA@.acl_row_ok(wplan, x.class, x.id, x.owner, x.tenant, x.tags, x.data, x.links);
-    if n_denied > 0 then
-      perform @SCHEMA@.lt_fail('acl_denied', case when denied is not null then format('нет права WRITE на ссылающиеся строки класса %s', denied)
-                                                   else 'нет права WRITE на ссылающиеся строки' end);
-    end if;
-  end if;
-  if nid = o.id then
-    perform @SCHEMA@.sys_update(o.id, d, lk.links, null, 'reclass', p_class);
-  else
-    perform @SCHEMA@.move_row(o, nid, p_class, d, lk.links, 'reclass', wplan);
-  end if;
-  return nid;
-end $$;
-
 -- ========================= merge, inc, links_patch =========================
 
 -- Правка концов слотами (этап 4, п. 4): .Роль.set(), .unset(), а для множественных концов .add()
@@ -1963,7 +1509,10 @@ begin
         end if;
         res := jsonb_set(res, array[role], cur);
       else
-        raise exception using errcode = 'LT003', message = 'letopis: invalid_data: links_patch: неизвестная операция ' || coalesce(o->>'op', 'null');
+        raise exception using errcode = 'LT003', message = 'letopis: invalid_data: '
+            || @SCHEMA@.lt_text('sql-write.links_patch_op', jsonb_build_object('op', coalesce(o->>'op', 'null'))),
+          detail = jsonb_build_object('key', 'sql-write.links_patch_op', 'params', jsonb_build_object('op', coalesce(o->>'op', 'null')),
+            'nodetail', true)::text;
     end case;
   end loop;
   return res;
@@ -2004,39 +1553,46 @@ declare
   cur jsonb := data;
   v jsonb;
   i int;
-  fail text;
+  fail text;  -- ключ каталога отказа (sql-write.inc_*)
+  p jsonb := '{}'::jsonb;
 begin
   if path is null or cardinality(path) = 0 or delta is null then
-    fail := 'inc: нужны путь и величина';
+    fail := 'sql-write.inc_args';
   else
     for i in 1 .. cardinality(path) - 1 loop
       if jsonb_typeof(cur) is distinct from 'object' or not cur ? path[i] then
-        fail := format('inc: путь %s идёт через отсутствующий объект', array_to_string(path, '.'));
+        fail := 'sql-write.inc_path_missing';
         exit;
       end if;
       cur := cur->path[i];
     end loop;
     if fail is null and jsonb_typeof(cur) is distinct from 'object' then
-      fail := format('inc: путь %s идёт не через объект', array_to_string(path, '.'));
+      fail := 'sql-write.inc_path_not_object';
     end if;
     if fail is null then
       v := cur->path[cardinality(path)];
       if v is null then
         if start is null then
-          fail := format('inc: поля %s нет — задайте start', array_to_string(path, '.'));
+          fail := 'sql-write.inc_no_field';
         else
           return jsonb_set(data, path, to_jsonb(start + delta), true);
         end if;
       elsif jsonb_typeof(v) <> 'number' then
-        fail := format('inc: в поле %s не число', array_to_string(path, '.'));
+        fail := 'sql-write.inc_not_number';
       else
         return jsonb_set(data, path, to_jsonb((v #>> '{}')::numeric + delta));
       end if;
     end if;
   end if;
-  raise exception using errcode = 'LT003', message = 'letopis: invalid_data: ' || fail,
+  -- путь — параметр всех текстов, кроме inc_args; нарушение в detail.issues — тот же русский текст с его key и params
+  -- (их убирает fromDbError)
+  if fail <> 'sql-write.inc_args' then
+    p := jsonb_build_object('path', array_to_string(path, '.'));
+  end if;
+  raise exception using errcode = 'LT003', message = 'letopis: invalid_data: ' || @SCHEMA@.lt_text(fail, p),
     detail = jsonb_build_object('issues', jsonb_build_array(jsonb_build_object(
-      'path', to_jsonb(coalesce(path, '{}')), 'keyword', 'inc', 'message', fail)))::text;
+      'path', to_jsonb(coalesce(path, '{}')), 'keyword', 'inc', 'message', @SCHEMA@.lt_text(fail, p), 'key', fail, 'params', p)),
+      'key', fail, 'params', p)::text;
 end $$;
 
 do $$
@@ -2045,8 +1601,7 @@ begin
   foreach f in array array[
     'now_ts()', 'lock_id(text)', 'lock_row(text)', 'lock_try(text)', 'family_name(uuid, jsonb)', 'family_rows(uuid, jsonb)', 'family_lock(@SCHEMA@.entity, boolean)', 'class_set(jsonb)', 'class_accepts(jsonb, text, uuid)', 'role_accepts(text, uuid, text, text, uuid)',
     'apply_defaults(jsonb, jsonb)', 'links_shape(jsonb, jsonb)', 'targets_bad(jsonb, boolean, jsonb)', 'check_links(jsonb, jsonb, uuid, boolean, jsonb)', 'key_id(jsonb, text, uuid, jsonb, jsonb)',
-    'log_version(@SCHEMA@.entity)', 'sys_update(uuid, jsonb, jsonb, jsonpath, text, text)', 'tombstone(@SCHEMA@.entity, text, uuid)',
-    'links_replace(jsonb, uuid, uuid)', 'move_row(@SCHEMA@.entity, uuid, text, jsonb, jsonb, text, jsonb)', 'reclass(uuid, text, jsonb)',
+    'log_version(@SCHEMA@.entity)', 'sys_update(uuid, jsonb, jsonb, jsonpath, text)', 'tombstone(@SCHEMA@.entity)',
     'incoming_conflicts(uuid, text, uuid)', 'visible_detail(jsonb, uuid)', 'visible_class(jsonb)', 'class_change_safe(jsonb, jsonb)',
     'family_conflicts(text[], uuid, boolean)', 'reserved_names()', 'class_acl_admit(text, uuid)', 'class_rows_admit(text, uuid, text[], text)', 'class_has_history(text, uuid)', 'class_orphan_history(text, uuid)', 'class_admit(jsonb, uuid)',
     'trg_entity_bi()', 'trg_entity_bu()', 'trg_entity_ai()', 'trg_entity_au()', 'history_on(text, uuid)', 'signal_token(text, text, bytea)', 'signal_raw(text[])', 'signal(text[], uuid[])', 'class_evolve(@SCHEMA@.entity, @SCHEMA@.entity)',
@@ -2055,8 +1610,6 @@ begin
     execute format('revoke all on function @SCHEMA@.%s from public', f);
   end loop;
 end $$;
--- сырой SQL пишет теми же merge, inc и links_patch, что и библиотека; verify() — в 90-time.sql
--- до этапа 6 verify() был без параметров
-drop function if exists @SCHEMA@.verify();
+-- сырой SQL пишет теми же merge, inc и links_patch, что и библиотека
 grant execute on function @SCHEMA@.merge(jsonb, jsonb), @SCHEMA@.inc(jsonb, text[], numeric, numeric), @SCHEMA@.links_patch(jsonb, jsonb),
-  @SCHEMA@.reserved_names(), @SCHEMA@.reclass(uuid, text, jsonb), @SCHEMA@.delete_preview(uuid[]) to @APP@;
+  @SCHEMA@.reserved_names(), @SCHEMA@.delete_preview(uuid[]) to @APP@;