letopis 1.4.0 → 1.4.2

package/sql/60-write.sql

@@ -472,8 +472,12 @@ as $$
 declare
   e @SCHEMA@.entity;
   c record;
+  was text;
 begin
   select * into c from @SCHEMA@.ctx();
+  if p_class is not null then
+    select x.class into was from @SCHEMA@.entity x where x.id = p_id;
+  end if;
   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,
@@ -489,6 +493,11 @@ begin
     select x.* into e from @SCHEMA@.entity x where x.id = p_id;
   end if;
   perform @SCHEMA@.log_version(e);
+  -- смена класса: сигнал и прежнего класса — его ответы кэша и подписки тоже устарели (log_version сигналит только новый;
+  -- путь через триггер шлёт оба; план 2.0, 7.4 №4)
+  if was is not null and was <> e.class then
+    perform @SCHEMA@.signal(array[was], array[e.tenant]);
+  end if;
   return e;
 end $$;
 
@@ -1217,7 +1226,8 @@ begin
   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
   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;
+        where @SCHEMA@.history_on(k.class, k.tenant)) h on h.class = n.class and h.tenant = n.tenant
+  order by n.at, n.id;  -- порядок seq — порядок входа, а не плана соединения
   -- сигнал — по паре «класс, арендатор»
   select array_agg(k.class), array_agg(k.tenant) into sc, st from (select distinct a.class, a.tenant from added a) k;
   perform @SCHEMA@.signal(sc, st);
@@ -1273,7 +1283,8 @@ begin
   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;
+        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
@@ -1385,6 +1396,24 @@ begin
   return null;
 end $$;
 
+-- Перед удалением строки Account (ревизия 7, решение владельца). Строки secret аккаунта — сессии, хэши паролей и ключей,
+-- секреты TOTP, внешние учётные записи — уносит каскад внешнего ключа secret.account в конце оператора, раньше триггера
+-- после него, поэтому сессии гаснут с сигналом session:<хэш> здесь: процессы сбрасывают кэш ответов этих сессий.
+-- Срабатывает для всех ролей, в том числе владельца: аккаунты удаляют и функции владельца — каскад trg_entity_ad и
+-- account_purge. Строка Account у System не удаляется: ей принадлежат служебные строки secret (KEY — ключ прав и
+-- сигналов, LOCK — строки-замки, PROJECTOR — чекпоинты проекторов), которые каскад стёр бы, а без них установка не пишет.
+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 не удаляется: ему принадлежат служебные строки установки');
+  end if;
+  perform @SCHEMA@.auth_kill(OLD.id, null);
+  return OLD;
+end $$;
+
 -- Действие со строкой, которая ссылается на удаляемые id (p_ids), по правилам её концов (p_ends):
 -- cascade сильнее restrict, restrict сильнее unset; null — строка на них не ссылается. Общее правило
 -- для триггера удаления и превью delete_preview() (этап 4, п. 6): превью не расходится с удалением.
@@ -1456,9 +1485,7 @@ declare
   dplan jsonb;
   wplan jsonb;
   denied text;
-  accs uuid[];
   mems jsonb;
-  lvl_accs uuid[];
   lvl_mems jsonb;
   drows jsonb;
   own uuid[];
@@ -1526,19 +1553,21 @@ begin
   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 — одной вставкой на уровень
+  -- надгробия: последний снимок следующей версией с видом 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)
   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
   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;
+        where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant
+  order by g.id;
   -- пары «класс, арендатор» для сигнала — строкой «класс арендатор» (пробела нет ни в имени, ни в uuid)
   select coalesce(array_agg(g.id), '{}'), coalesce(array_agg(distinct g.class), '{}'),
          coalesce(array_agg(distinct g.class || ' ' || g.tenant::text), '{}'),
-         coalesce(array_agg(g.id) filter (where g.class = 'Account'), '{}'),
          coalesce(jsonb_agg(jsonb_build_object('tenant', g.tenant, 'user', g.links->>'User')) filter (where g.class = 'member'), '[]'::jsonb)
-    into lvl, classes, pairs, accs, mems from gone g;
+    into lvl, classes, pairs, mems from gone g;
   all_ids := lvl;
   while cardinality(lvl) > 0 loop
     -- кто ссылается на уровень: действие по правилам концов (общее с превью)
@@ -1566,20 +1595,19 @@ begin
       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
+      order by d.id  -- надгробия уровня в порядке id, как и на уровне 0
     )
     select coalesce(array_agg(d.id), '{}'), coalesce(array_agg(distinct d.class), '{}'),
            coalesce(array_agg(distinct d.class || ' ' || d.tenant::text), '{}'),
            jsonb_agg(to_jsonb(d)) filter (where not @SCHEMA@.acl_row_ok(dplan, d.class, d.id, d.owner, d.tenant, d.tags, d.data, d.links)),
-           coalesce(array_agg(d.id) filter (where d.class = 'Account'), '{}'),
            coalesce(jsonb_agg(jsonb_build_object('tenant', d.tenant, 'user', d.links->>'User')) filter (where d.class = 'member'), '[]'::jsonb)
-      into lvl, lvl_classes, lvl_pairs, drows, lvl_accs, lvl_mems from d;
+      into lvl, lvl_classes, lvl_pairs, drows, lvl_mems from d;
     -- класс отказавшей строки называется, только если актор её видит (ревью безопасности №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);
     end if;
-    accs := accs || lvl_accs;
     mems := mems || lvl_mems;
     classes := classes || lvl_classes;
     pairs := pairs || lvl_pairs;
@@ -1605,14 +1633,11 @@ begin
   end loop;
   -- выход из членства (и удаление аккаунта, которое снимает его членства): строки арендатора, которыми
   -- владел участник, переходят арендатору (§2.10) — новой версией
-  for r in select distinct (m->>'tenant')::uuid as tenant, (m->>'user')::uuid as usr from jsonb_array_elements(mems) m loop
+  for r in select distinct (m->>'tenant')::uuid as tenant, (m->>'user')::uuid as usr from jsonb_array_elements(mems) m order by 1, 2 loop
     perform @SCHEMA@.owner_to_tenant(r.tenant, r.usr);
   end loop;
-  -- удалённый аккаунт: сессии гаснут, креды удаляются (идентификаторы освобождаются)
-  for r in select distinct u as acc from unnest(accs) u loop
-    perform @SCHEMA@.auth_kill(r.acc, null);
-    update @SCHEMA@.secret x set deleted_at = clock_timestamp() where x.account = r.acc and x.deleted_at is null;
-  end loop;
+  -- удалённый аккаунт (ревизия 7): сессии погасил с сигналом триггер до удаления (trg_entity_bd_account), его строки
+  -- secret стёр каскад внешнего ключа secret.account — идентификаторы входа свободны
   perform @SCHEMA@.signal(array_agg(split_part(x.p, ' ', 1)), array_agg(split_part(x.p, ' ', 2)::uuid))
   from (select distinct p from unnest(pairs) p) x;
   if classes && array['rule', 'Resource', 'member', 'Account', 'Class'] then
@@ -1700,6 +1725,9 @@ create or replace trigger entity_au after update on @SCHEMA@.entity referencing
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_au();
 create or replace trigger entity_bd before delete on @SCHEMA@.entity
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_bd();
+-- удаление аккаунта — для всех ролей, в том числе владельца (каскад trg_entity_ad, account_purge): ревизия 7
+create or replace trigger entity_bd_account before delete on @SCHEMA@.entity
+  for each row when (OLD.class = 'Account') execute function @SCHEMA@.trg_entity_bd_account();
 create or replace trigger entity_ad after delete on @SCHEMA@.entity referencing old table as gone
   for each statement when (current_user <> '@OWNER_NAME@') execute function @SCHEMA@.trg_entity_ad();
 -- в режиме репликации (session_replication_role = replica) триггеры тоже работают
@@ -1708,6 +1736,7 @@ alter table @SCHEMA@.entity enable always trigger entity_bu;
 alter table @SCHEMA@.entity enable always trigger entity_ai;
 alter table @SCHEMA@.entity enable always trigger entity_au;
 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;
 
 -- ========================= смена класса с ключом =========================
@@ -2030,7 +2059,7 @@ begin
     '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)',
-    'trg_entity_bd()', 'trg_entity_ad()', 'owner_to_tenant(uuid, uuid)', 'ref_action(jsonb, jsonb, uuid[])', 'delete_preview(uuid[])', 'merge(jsonb, jsonb)', 'inc(jsonb, text[], numeric, numeric)', 'links_patch(jsonb, jsonb)'] loop
+    'trg_entity_bd()', 'trg_entity_bd_account()', 'trg_entity_ad()', 'owner_to_tenant(uuid, uuid)', 'ref_action(jsonb, jsonb, uuid[])', 'delete_preview(uuid[])', 'merge(jsonb, jsonb)', 'inc(jsonb, text[], numeric, numeric)', 'links_patch(jsonb, jsonb)'] loop
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);
   end loop;

package/sql/70-read.sql

@@ -53,9 +53,11 @@ as $$
       where r.class = any (p_classes) and r.at <= coalesce(p_at, 'infinity'::timestamptz)) c
   cross join lateral (
       select y.* from (select x.* from @SCHEMA@.log x where x.id = c.id offset 0) y
-      where y.class = any (p_classes) and y.at <= coalesce(p_at, 'infinity'::timestamptz)
+      where y.at <= coalesce(p_at, 'infinity'::timestamptz)
       order by y.rev desc limit 1) w
-  where @SCHEMA@.link_ids(w.links) @> array[p_src]
+  -- класс — у последней версии на момент, а не среди версий классов шага: после смены класса без смены id объект
+  -- не числится в прежнем классе (план 2.0, 7.1 №1)
+  where w.class = any (p_classes) and @SCHEMA@.link_ids(w.links) @> array[p_src]
 $$;
 
 -- id строк классов p_classes: по вложению в data (GIN entity_data), по целям концов (GIN entity_ends),
@@ -134,12 +136,16 @@ begin
   else
     -- арендатор id неизменен, записи purge и trim несут арендатора объекта: условие до distinct on не меняет, какая
     -- версия id последняя (индекс log_class_tenant_at)
+    -- кандидаты — по классу (индекс log_class_tenant_at), последняя версия id на момент — любого класса, и класс
+    -- проверяется у неё: иначе после смены класса без смены id объект числился бы в прежнем классе (план 2.0, 7.1 №1)
     return query select v.id, v.rev from (
-        select distinct on (l.id) l.id, l.rev, l.op, l.class, l.tenant, l.owner, l.tags, l.data, l.links
-        from @SCHEMA@.log l
-        where l.class = any (p_classes) and l.tenant = any (v_tenants) and l.at <= coalesce(p_at, 'infinity'::timestamptz)
-        order by l.id, l.rev desc) v
-      where (v.op = 'delete') = p_dead and v.op not in ('purge', 'trim', 'reset')
+        select distinct l.id from @SCHEMA@.log l
+        where l.class = any (p_classes) and l.tenant = any (v_tenants) and l.at <= coalesce(p_at, 'infinity'::timestamptz)) c
+      cross join lateral (
+        select y.id, y.rev, y.op, y.class, y.tenant, y.owner, y.tags, y.data, y.links
+        from @SCHEMA@.log y where y.id = c.id and y.at <= coalesce(p_at, 'infinity'::timestamptz)
+        order by y.rev desc limit 1) v
+      where v.class = any (p_classes) and (v.op = 'delete') = p_dead and v.op not in ('purge', 'trim', 'reset')
         and (p_data is null or v.data @> p_data) and (p_ends is null or @SCHEMA@.link_ids(v.links) @> p_ends)
         and @SCHEMA@.row_visible(v.tenant, v.class, v.id, v.owner, v.tags, v.data, v.links, c_tenant, c_account, c_plan);
     -- свои членства в других арендаторах: версии, ссылавшиеся на аккаунт (GIN log_ends)

package/sql/75-history.sql

@@ -11,6 +11,7 @@
 --   change_paths  — пути для колонки changed (пишут триггер правки и log_version);
 --   row_leaves    — листья снимка строки (то, что объясняет blame);
 --   version_paths — пути из changed тех версий, у которых предыдущая версия видна вызывающему;
+--   history_segments — отрезки истории объекта по переносам id (follow и blame);
 --   diff_versions — что изменилось между двумя версиями или моментами (jsonb в виде ответа diff());
 --   blame         — какая версия, кто, когда и почему последней изменила каждый лист (ответ blame()).
 
@@ -154,21 +155,79 @@ begin
   if c_account is null then
     return;
   end if;
+  -- обе версии — поиском по (id, rev) на каждую пару: lateral с limit 1 не даёт планировщику соединить журнал хэшем.
+  -- Свой план вызова (первые пять на соединении) по фильтру видимости оценивал версии n в 2 строки и искал
+  -- предыдущую версию по одному id, проверяя номер фильтром, — квадрат от числа версий: blame по 1000 версиям
+  -- ~250 мс, по 10 000 — секунды (план 2.0, попутно с 7.1 №2)
   return query
     select n.id, n.rev, n.changed
     from unnest(p_ids, p_revs) q(id, rev)
-    join @SCHEMA@.log n on n.id = q.id and n.rev = q.rev
-    join @SCHEMA@.log o on o.id = n.id and o.rev = n.rev - 1
-    where n.changed is not null
-      and n.op not in ('purge', 'trim', 'reset') and o.op not in ('purge', 'trim', 'reset')
-      and @SCHEMA@.row_visible(n.tenant, n.class, n.id, n.owner, n.tags, n.data, n.links, c_tenant, c_account, c_plan)
-      and @SCHEMA@.row_visible(o.tenant, o.class, o.id, o.owner, o.tags, o.data, o.links, c_tenant, c_account, c_plan);
+    cross join lateral (select x.id, x.rev, x.changed from @SCHEMA@.log x
+      where x.id = q.id and x.rev = q.rev and x.changed is not null and x.op not in ('purge', 'trim', 'reset')
+        and @SCHEMA@.row_visible(x.tenant, x.class, x.id, x.owner, x.tags, x.data, x.links, c_tenant, c_account, c_plan)
+      limit 1) n
+    cross join lateral (select 1 from @SCHEMA@.log o
+      where o.id = n.id and o.rev = n.rev - 1 and o.op not in ('purge', 'trim', 'reset')
+        and @SCHEMA@.row_visible(o.tenant, o.class, o.id, o.owner, o.tags, o.data, o.links, c_tenant, c_account, c_plan)
+      limit 1) o;
+end $$;
+
+-- Отрезки истории объекта (план 2.0, 7.1 №2): версии id с номерами (lo, hi], hi null — до последней. Границы
+-- отрезков на id — переносы: надгробие переноса (delete с moved) кончает отрезок, первая версия на новом id (reclass,
+-- rekey с moved) начинает. Объект, заведённый на прежнем id после переноса, — другой отрезок: follow и blame его не
+-- берут (прежде брали все версии всех связанных id). Начало — отрезок с версией p_rev объекта p_id (n = 0), дальше по
+-- переносам назад (n < 0) и, если не p_back, вперёд (n > 0). Перенос пишется парой строк с moved друг на друга
+-- (надгробие на старом id → новый id, первая версия на новом → старый): строки переноса id находит индекс log_moved
+-- через парную строку, без прохода по версиям id; у объекта без переносов — один пустой поиск. Строка, чья пара стёрта
+-- (история другой стороны удалена целиком или обрезана), границей не считается. Пара одного переноса — ближайшая по
+-- seq (время у них может разойтись на микросекунды). Тот же обход строит versions({ follow }) в построителе
+-- (lib/src/sql.ts:buildRead): меняются вместе. plpgsql, а не sql: план запроса кэшируется (тело функции на sql
+-- планировалось на каждом вызове).
+create or replace function @SCHEMA@.history_segments(p_id uuid, p_rev int, p_back boolean default false)
+returns table (id uuid, lo int, hi int, n int)
+language plpgsql stable
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+#variable_conflict use_column
+begin
+  return query with recursive s(id, lo, hi, n) as (
+    select p_id, b.lo, b.hi, 0 from (
+      select greatest(coalesce(max(x.rev) filter (where x.op = 'delete' and x.rev < p_rev), 0),
+                      coalesce(max(x.rev - 1) filter (where x.op <> 'delete' and x.rev <= p_rev), 0)) as lo,
+             least(min(x.rev) filter (where x.op = 'delete' and x.rev >= p_rev),
+                   min(x.rev - 1) filter (where x.op <> 'delete' and x.rev > p_rev)) as hi
+      from @SCHEMA@.log m join @SCHEMA@.log x on x.moved = m.id and x.id = p_id where m.moved = p_id) b
+    union
+    select g.id, b.lo, b.hi, g.n
+    from s cross join lateral (
+      -- назад: первая версия отрезка — прибытие с прежнего id; прежний отрезок кончается надгробием переноса сюда
+      select a.moved as id, (select t.rev from @SCHEMA@.log t where t.id = a.moved and t.op = 'delete' and t.moved = s.id
+          order by abs(t.seq - a.seq) limit 1) as r, s.n - 1 as n
+      from @SCHEMA@.log a
+      where s.n <= 0 and a.id = s.id and a.rev = s.lo + 1 and a.moved is not null and a.op <> 'delete'
+      union all
+      -- вперёд: последняя версия отрезка — надгробие переноса; следующий отрезок начинается прибытием отсюда
+      select t.moved, (select a.rev from @SCHEMA@.log a where a.id = t.moved and a.op <> 'delete' and a.moved = s.id
+          order by abs(a.seq - t.seq) limit 1), s.n + 1
+      from @SCHEMA@.log t
+      where not p_back and s.n >= 0 and t.id = s.id and t.rev = s.hi and t.op = 'delete' and t.moved is not null
+    ) g
+    cross join lateral (
+      select greatest(coalesce(max(x.rev) filter (where x.op = 'delete' and x.rev < g.r), 0),
+                      coalesce(max(x.rev - 1) filter (where x.op <> 'delete' and x.rev <= g.r), 0)) as lo,
+             least(min(x.rev) filter (where x.op = 'delete' and x.rev >= g.r),
+                   min(x.rev - 1) filter (where x.op <> 'delete' and x.rev > g.r)) as hi
+      from @SCHEMA@.log m join @SCHEMA@.log x on x.moved = m.id and x.id = g.id where m.moved = g.id) b
+    where g.r is not null and abs(g.n) <= 1000
+  )
+  select s.id, s.lo, s.hi, s.n from s;
 end $$;
 
 -- diff: что изменилось между двумя версиями объекта (ответ терминала diff()). «После» — номер версии
 -- p_to, последняя версия на момент p_to_at или последняя вообще; «до» — номер p_from, последняя живая
 -- версия на момент p_from_at (объекта не было — null, все пути added) или версия перед «после».
--- p_follow — через смену id (reclass, rekey) по колонке moved; надгробие переноса — не версия.
+-- p_follow — через смену id (reclass, rekey) по колонке moved: отрезки истории этого объекта (history_segments) от
+-- версии p_to или последней версии p_id; надгробие переноса — не версия.
 -- «После» — надгробие: to.deleted, изменения полей не перечисляются.
 create or replace function @SCHEMA@.diff_versions(p_id uuid, p_from int default null, p_to int default null,
   p_from_at timestamptz default null, p_to_at timestamptz default null, p_follow boolean default false)
@@ -181,21 +240,26 @@ set jit = off
 as $$
 declare
   ids uuid[] := array[p_id];
+  los int[] := array[0];
+  his int[] := array[null::int];
+  multi boolean := false;
+  whole boolean := true;
   t record;
   f record;
   has_f boolean;
 begin
   if p_follow then
-    with recursive g(id) as (
-      select p_id
-      union
-      select x.id from g cross join lateral (
-        select l.moved as id from @SCHEMA@.log l where l.id = g.id and l.moved is not null
-        union select l.id from @SCHEMA@.log l where l.moved = g.id) x)
-    select array_agg(g.id) into ids from g;
+    select array_agg(s.id), array_agg(s.lo), array_agg(s.hi) into ids, los, his
+    from (select distinct g.id, g.lo, g.hi from @SCHEMA@.history_segments(p_id, coalesce(p_to, (select max(l.rev) from @SCHEMA@.log l
+      where l.id = p_id and l.op not in ('purge', 'trim', 'reset')))) g) s;
+    multi := cardinality(ids) > (select count(distinct x) from unnest(ids) x);
+    whole := cardinality(ids) = 1 and los[1] = 0 and his[1] is null;
   end if;
   select l.id, l.rev, l.at, l.seq, l.op, l.class, l.data, l.links, l.tags, l.owner into t from @SCHEMA@.log l
   where l.id = any (ids) and l.op not in ('purge', 'trim', 'reset') and not (p_follow and l.op = 'delete' and l.moved is not null)
+    and case when whole then true when multi then exists (select 1 from unnest(ids, los, his) s(id, lo, hi) where s.id = l.id and l.rev > s.lo
+        and l.rev <= coalesce(s.hi, 2147483647))
+      else l.rev > los[array_position(ids, l.id)] and l.rev <= coalesce(his[array_position(ids, l.id)], 2147483647) end
     and (p_to is null or (l.id = p_id and l.rev = p_to)) and (p_to_at is null or l.at <= p_to_at)
   order by l.at desc, l.seq desc limit 1;
   if t.id is null then
@@ -208,6 +272,9 @@ begin
   elsif p_from_at is not null then
     select l.id, l.rev, l.at, l.op, l.class, l.data, l.links, l.tags, l.owner into f from @SCHEMA@.log l
     where l.id = any (ids) and l.op not in ('purge', 'trim', 'reset') and not (p_follow and l.op = 'delete' and l.moved is not null)
+      and case when whole then true when multi then exists (select 1 from unnest(ids, los, his) s(id, lo, hi) where s.id = l.id and l.rev > s.lo
+          and l.rev <= coalesce(s.hi, 2147483647))
+        else l.rev > los[array_position(ids, l.id)] and l.rev <= coalesce(his[array_position(ids, l.id)], 2147483647) end
       and l.at <= p_from_at
     order by l.at desc, l.seq desc limit 1;
     -- срез на момент: удалённого объекта тогда не было
@@ -215,6 +282,9 @@ begin
   else
     select l.id, l.rev, l.at, l.op, l.class, l.data, l.links, l.tags, l.owner into f from @SCHEMA@.log l
     where l.id = any (ids) and l.op not in ('purge', 'trim', 'reset') and not (p_follow and l.op = 'delete' and l.moved is not null)
+      and case when whole then true when multi then exists (select 1 from unnest(ids, los, his) s(id, lo, hi) where s.id = l.id and l.rev > s.lo
+          and l.rev <= coalesce(s.hi, 2147483647))
+        else l.rev > los[array_position(ids, l.id)] and l.rev <= coalesce(his[array_position(ids, l.id)], 2147483647) end
       and (l.at, l.seq) < (t.at, t.seq)
     order by l.at desc, l.seq desc limit 1;
     has_f := f.id is not null;
@@ -241,7 +311,9 @@ end $$;
 -- blame: для каждого листа версии (последней на момент p_at или текущей) — версия, которая последней его
 -- изменила, с автором, агентом, видом операции и причиной (ответ терминала blame()). Просматривается не
 -- больше p_limit последних версий, назад через смену id (первая версия нового id указывает на прежний
--- колонкой moved). Пропуск номера версии (прореживание, обрезка, невидимая версия) — выпавшая версия могла
+-- колонкой moved) — по отрезкам истории этого объекта (history_segments): объект, что жил на этом id до переноса
+-- или заведён на прежнем id после, — не его история; начало истории — первая версия самого раннего отрезка (у
+-- объекта без переносов — версия 1). Пропуск номера версии (прореживание, обрезка, невидимая версия) — выпавшая версия могла
 -- изменить лист и вернуть значение, поэтому лист точен (exact), только если от текущей версии до найденной
 -- пропусков нет; лист, не менявшийся в просмотренной истории, принадлежит самой старой просмотренной версии —
 -- exact, только если это версия 1 и пропусков нет вовсе. complete — история просмотрена целиком и без пропусков.
@@ -254,9 +326,12 @@ set search_path = pg_catalog, @SCHEMA@, pg_temp
 set jit = off
 as $$
 declare
-  ids uuid[] := array[p_id];
+  ids uuid[];
+  los int[];
+  his int[];
+  multi boolean;
+  whole boolean;
   t record;
-  prev uuid;
   lim int := greatest(coalesce(p_limit, 1000), 1);
   res jsonb;
 begin
@@ -264,12 +339,11 @@ begin
   where l.id = p_id and l.op not in ('purge', 'trim', 'reset') and (p_at is null or l.at <= p_at)
   order by l.rev desc limit 1;
   if t.id is null then return null; end if;
-  loop
-    select l.moved into prev from @SCHEMA@.log l
-    where l.id = ids[cardinality(ids)] and l.moved is not null and l.op in ('reclass', 'rekey') order by l.rev limit 1;
-    exit when prev is null or prev = any (ids);
-    ids := ids || prev;
-  end loop;
+  -- отрезки от самого раннего: ids[1], los[1] — начало истории объекта
+  select array_agg(s.id order by s.n), array_agg(s.lo order by s.n), array_agg(s.hi order by s.n) into ids, los, his
+  from (select g.id, g.lo, g.hi, min(g.n) as n from @SCHEMA@.history_segments(p_id, t.rev, true) g group by 1, 2, 3) s;
+  multi := cardinality(ids) > (select count(distinct x) from unnest(ids) x);
+  whole := cardinality(ids) = 1 and los[1] = 0 and his[1] is null;
   with v as (
     -- соседняя более старая версия — окном (lead), а не соединением CTE с собой: соединение шло бы вложенным
     -- циклом по квадрату числа версий
@@ -279,6 +353,9 @@ begin
            lead(l.owner) over o as o_owner, lead(l.class) over o as o_class
     from @SCHEMA@.log l
     where l.id = any (ids) and l.op not in ('purge', 'trim', 'reset') and not (l.op = 'delete' and l.moved is not null)
+      and case when whole then true when multi then exists (select 1 from unnest(ids, los, his) s(id, lo, hi) where s.id = l.id and l.rev > s.lo
+          and l.rev <= coalesce(s.hi, 2147483647))
+        else l.rev > los[array_position(ids, l.id)] and l.rev <= coalesce(his[array_position(ids, l.id)], 2147483647) end
       and (l.at, l.seq) <= (t.at, t.seq)
     window o as (order by l.at desc, l.seq desc)
     order by l.at desc, l.seq desc limit lim + 1
@@ -312,14 +389,15 @@ begin
     from leaves lv join ch on lv.path[1:cardinality(ch.path)] = ch.path or ch.path[1:cardinality(lv.path)] = lv.path
     group by lv.path
   ), oldest as (
-    select w.n, w.rev from w order by w.n desc limit 1
+    -- first — самая старая версия окна и есть начало истории объекта
+    select w.n, w.rev, w.id = ids[1] and w.rev = los[1] + 1 as first from w order by w.n desc limit 1
   ), cut as (
     select count(*) > lim as cut from v
   ), fields as (
     select lv.path,
       jsonb_build_object('path', to_jsonb(lv.path), 'rev', cv.rev, 'at', cv.at, 'author', cv.author, 'op', cv.op,
         'exact', case when h.n is not null then not exists (select 1 from gaps g where g.n <= h.n)
-                      else (select o.rev = 1 from oldest o) and not (select c.cut from cut c) and not exists (select 1 from gaps) end)
+                      else (select o.first from oldest o) and not (select c.cut from cut c) and not exists (select 1 from gaps) end)
       || case when cv.id <> p_id then jsonb_build_object('id', cv.id) else '{}'::jsonb end
       || case when cv.agent is not null then jsonb_build_object('agent', cv.agent) else '{}'::jsonb end
       || case when cv.reason is not null then jsonb_build_object('reason', cv.reason) else '{}'::jsonb end as obj
@@ -328,7 +406,7 @@ begin
     join w cv on cv.n = coalesce(h.n, (select o.n from oldest o))
   )
   select jsonb_build_object('id', p_id, 'class', t.class, 'rev', t.rev,
-           'complete', (select o.rev = 1 from oldest o) and not (select c.cut from cut c) and not exists (select 1 from gaps),
+           'complete', (select o.first from oldest o) and not (select c.cut from cut c) and not exists (select 1 from gaps),
            'fields', coalesce((select jsonb_agg(f.obj order by f.path) from fields f), '[]'::jsonb))
          || case when t.op = 'delete' then '{"deleted": true}'::jsonb else '{}'::jsonb end
   into res;
@@ -342,7 +420,7 @@ begin
     'jsonb_changes(jsonb, jsonb, text[])',
     'row_changes(jsonb, jsonb, text[], uuid, text, jsonb, jsonb, text[], uuid, text)',
     'change_paths(jsonb, jsonb, text[], uuid, text, jsonb, jsonb, text[], uuid, text)',
-    'row_leaves(jsonb, jsonb, text[], uuid, text)', 'version_paths(uuid[], int[])',
+    'row_leaves(jsonb, jsonb, text[], uuid, text)', 'version_paths(uuid[], int[])', 'history_segments(uuid, int, boolean)',
     'diff_versions(uuid, int, int, timestamptz, timestamptz, boolean)', 'blame(uuid, timestamptz, int)'] loop
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);
@@ -354,5 +432,5 @@ grant execute on function @SCHEMA@.jsonb_changes(jsonb, jsonb, text[]),
   @SCHEMA@.row_changes(jsonb, jsonb, text[], uuid, text, jsonb, jsonb, text[], uuid, text),
   @SCHEMA@.change_paths(jsonb, jsonb, text[], uuid, text, jsonb, jsonb, text[], uuid, text),
   @SCHEMA@.row_leaves(jsonb, jsonb, text[], uuid, text), @SCHEMA@.version_paths(uuid[], int[]),
-  @SCHEMA@.diff_versions(uuid, int, int, timestamptz, timestamptz, boolean),
+  @SCHEMA@.history_segments(uuid, int, boolean), @SCHEMA@.diff_versions(uuid, int, int, timestamptz, timestamptz, boolean),
   @SCHEMA@.blame(uuid, timestamptz, int) to @APP@;

package/sql/80-auth.sql

@@ -755,7 +755,8 @@ declare
   s record;
 begin
   if nullif(current_setting('letopis.account', true), '') is not null then
-    perform @SCHEMA@.lt_fail('invalid_query', 'auth.switch — для собственной сессии, не при имперсонации');
+    -- код из каталога базы (invalid_query в нём нет — lt_fail дал бы LT000 и сырую ошибку; план 2.0, 7.5 №3)
+    perform @SCHEMA@.lt_fail('acl_denied', 'auth.switch — для собственной сессии, не при имперсонации');
   end if;
   select x.id, x.account into s from @SCHEMA@.secret x
   where x.kind = 'SESSION' and x.deleted_at is null and x.material = sha256(convert_to(coalesce(tok, ''), 'UTF8'))
@@ -795,6 +796,43 @@ begin
     where m.class = 'member' and m.links->>'User' = c.account::text and @SCHEMA@.auth_enabled(m.tenant);
 end $$;
 
+-- Сведения о сессии по токену (db.auth.session): сервис, у которого есть токен пользователя (например, из
+-- cookie), узнаёт, чья это сессия, жива ли она и в каком арендаторе работает, не подключаясь по этому токену.
+-- Право auth.session, как у issue_session. Неверный, погашенный или истёкший токен и отключённый аккаунт — null:
+-- причина не различается, как в ctx(). Сессия ищется только среди SESSION: ключ API или код с тем же sha256 не
+-- подойдут. member — проверка членства из ctx() без исключения: членство в рабочем арендаторе цело и арендатор
+-- включён; собственный арендатор — всегда true.
+create or replace function @SCHEMA@.auth_session_info(p_token text) returns jsonb
+language plpgsql stable security definer
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  c record;
+  s record;
+  t uuid;
+begin
+  select * into c from @SCHEMA@.ctx();
+  perform @SCHEMA@.auth_session_required(c.account);
+  perform @SCHEMA@.acl_require('auth.session');
+  select x.account, x.meta, x.expires_at into s from @SCHEMA@.secret x
+  where x.kind = 'SESSION' and x.deleted_at is null and x.material = sha256(convert_to(coalesce(p_token, ''), 'UTF8'))
+    and (x.expires_at is null or x.expires_at > clock_timestamp());
+  if s.account is null or not @SCHEMA@.auth_enabled(s.account) then
+    return null;
+  end if;
+  t := coalesce((s.meta->>'tenant')::uuid, s.account);
+  return jsonb_build_object(
+    'account', s.account,
+    'tenant', t,
+    'member', t = s.account or (
+      exists (select 1 from @SCHEMA@.entity x
+              where x.id = @SCHEMA@.v5_id(t, 'member', array[s.account::text, t::text]) and x.class = 'member' and x.tenant = t)
+      and @SCHEMA@.auth_enabled(t)),
+    'expiresAt', s.expires_at,
+    'loginAt', s.meta->'login_at',
+    'methods', coalesce(s.meta->'methods', '[]'::jsonb));
+end $$;
+
 do $$
 declare f text;
 begin
@@ -807,7 +845,7 @@ begin
     'login_otp(text, text, text)', 'totp_code(bytea, bigint)', 'auth_enroll_totp(uuid)', 'auth_verify_totp(uuid, text, int)',
     'auth_totp_enabled(uuid)', 'auth_link(uuid, text, text, jsonb, boolean)', 'auth_lookup(text, text, boolean)',
     'auth_credentials(uuid)', 'auth_revoke_credential(uuid, boolean)', 'auth_set_flags(uuid, boolean, boolean)',
-    'auth_refresh(interval)', 'auth_logout()', 'auth_logout_all(uuid)', 'auth_switch(uuid)', 'auth_tenants()'] loop
+    'auth_refresh(interval)', 'auth_logout()', 'auth_logout_all(uuid)', 'auth_switch(uuid)', 'auth_tenants()', 'auth_session_info(text)'] loop
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);
   end loop;
@@ -824,4 +862,4 @@ grant execute on function
   @SCHEMA@.auth_totp_enabled(uuid), @SCHEMA@.auth_link(uuid, text, text, jsonb, boolean), @SCHEMA@.auth_lookup(text, text, boolean),
   @SCHEMA@.auth_credentials(uuid), @SCHEMA@.auth_revoke_credential(uuid, boolean), @SCHEMA@.auth_set_flags(uuid, boolean, boolean),
   @SCHEMA@.auth_refresh(interval), @SCHEMA@.auth_logout(), @SCHEMA@.auth_logout_all(uuid), @SCHEMA@.auth_switch(uuid),
-  @SCHEMA@.auth_tenants() to @APP@;
+  @SCHEMA@.auth_tenants(), @SCHEMA@.auth_session_info(text) to @APP@;

package/sql/88-derived.sql

@@ -25,7 +25,8 @@ begin
   for update;
   if not found then
     update @SCHEMA@.secret s set deleted_at = clock_timestamp()
-    where s.kind = 'PROJECTOR' and casefold(s.ident) = casefold(p_name) and s.account <> '@SYSTEM@'::uuid and s.deleted_at is null;
+    where s.kind = 'PROJECTOR' and casefold(s.ident) collate pg_unicode_fast = casefold(p_name) collate pg_unicode_fast
+      and s.account <> '@SYSTEM@'::uuid and s.deleted_at is null;
     insert into @SCHEMA@.secret (account, kind, ident, meta) values ('@SYSTEM@'::uuid, 'PROJECTOR', p_name, '{}'::jsonb);
     return '{}'::jsonb;
   end if;
@@ -272,6 +273,7 @@ begin
     from g
     join (select d.class, d.tenant from (select distinct y.class, y.tenant from g y) d
           where @SCHEMA@.history_on(d.class, d.tenant)) h on h.class = g.class and h.tenant = g.tenant
+    order by g.id  -- надгробия в порядке id, как в trg_entity_ad
   )
   select count(*)::int, coalesce(array_agg(distinct g.class || ' ' || g.tenant::text), '{}') into n, pairs from g;
   if n > 0 then