letopis 1.0.0 → 1.1.0

package/dist/watch.d.ts

@@ -1,5 +1,6 @@
 import type { Executor } from './tx.js';
 import type { Row } from './types.js';
+import type { Signal } from './signals.js';
 export interface WatchOptions {
     /** Откуда: курсор события, 'now' (по умолчанию — изменения после подписки) или 'start' (весь журнал). */
     from?: string;
@@ -26,9 +27,17 @@ export interface WatchCtx {
     exec: Executor;
     /** Классы подписки с потомками (null — все). */
     classes: string[] | null;
-    /** Подписка на сигналы базы; возвращает отписку. */
-    onSignal?: (fn: (name: string) => void) => () => void;
+    /** Подписка на сигналы базы (разобранные); возвращает отписку. */
+    onSignal?: (fn: (s: Signal) => void) => () => void;
+    /** Токен арендатора подписки (null — процесс без ключа или режим без токенов). */
+    tenant?: () => string | null;
 }
+/**
+ * Будит ли сигнал подписку: свои классы (watched; null — все) и свой арендатор (mine — токен; null —
+ * любой); сессии не будят; *, opaque без ключа и нагрузка не по режиму — будят. Незнакомый токен класса
+ * будит только подписку на все классы: классы подписки с перечнем есть в реестре, их токены известны.
+ */
+export declare function wakes(s: Signal, watched: ReadonlySet<string> | null, mine: string | null): boolean;
 export declare class Subscription implements AsyncIterable<WatchEvent> {
     private ctx;
     private opts;

package/dist/watch.js

@@ -8,8 +8,9 @@
  * транзакций (pg_snapshot_xmin) — транзакцию с меньшим номером, зафиксированную позже, курсор уже
  * не обгонит, поэтому событий нет ни потерянных, ни повторных. Поток стоит, пока открыта более
  * старая пишущая транзакция (горизонт общий для кластера); метрика — lag(). Чтение идёт под RLS
- * журнала: каждый видит только своё. Сигнал базы с именем класса только будит подписку (чужие
- * классы — не будят); без LISTEN и на случай потери сигнала — запасной опрос.
+ * журнала: каждый видит только своё. Сигнал базы только будит подписку: свои классы и свой арендатор
+ * (чужие — не будят; процесс без ключа сигналов арендатора не различает, в режиме opaque — и класса);
+ * без LISTEN и на случай потери сигнала — запасной опрос.
  *
  * Курсор подписчика старше яруса all политики хранения его классов — cursor_expired: события могли
  * проредиться, нужно перечитать текущее состояние и подписаться заново.
@@ -28,6 +29,25 @@ function decode(c) {
 }
 /** Снимок ещё нужен: курсор не дошёл до его xmax. */
 const keepSnap = (snap, tx) => snap && BigInt(tx) < BigInt(snap.split(':')[1]) ? snap : undefined;
+/**
+ * Будит ли сигнал подписку: свои классы (watched; null — все) и свой арендатор (mine — токен; null —
+ * любой); сессии не будят; *, opaque без ключа и нагрузка не по режиму — будят. Незнакомый токен класса
+ * будит только подписку на все классы: классы подписки с перечнем есть в реестре, их токены известны.
+ */
+export function wakes(s, watched, mine) {
+    const ours = (t) => t === null || mine === null || t === mine;
+    switch (s.kind) {
+        case 'session':
+        case 'sessions':
+            return false;
+        case 'class':
+            return (!watched || watched.has(s.cls)) && ours(s.tenant);
+        case 'unknown':
+            return !watched && ours(s.tenant);
+        default:
+            return true;
+    }
+}
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 export class Subscription {
     ctx;
@@ -60,10 +80,8 @@ export class Subscription {
         }
         if (ctx.onSignal) {
             const watched = ctx.classes ? new Set(ctx.classes) : null;
-            this.off = ctx.onSignal((name) => {
-                if (name === '' || name.startsWith('session:'))
-                    return;
-                if (watched && name !== '*' && !watched.has(name))
+            this.off = ctx.onSignal((s) => {
+                if (!wakes(s, watched, ctx.tenant?.() ?? null))
                     return;
                 this.dirty = true;
                 this.wake?.();

package/dist/write.d.ts

@@ -17,7 +17,8 @@ export declare function inc(by: number, opts?: {
     start?: number;
 }): IncMarker;
 export declare const isInc: (v: unknown) => v is IncMarker;
-export type PlanOp = {
+/** Глагол плана; reason — причина изменения этого глагола (план 1.1, §2.1). */
+export type PlanOp = ({
     kind: 'create';
     data: Record<string, unknown>;
 } | {
@@ -45,7 +46,11 @@ export type PlanOp = {
 } | {
     kind: 'rekey';
     data: Record<string, unknown>;
+}) & {
+    reason?: string;
 };
+/** Причина изменения: строка до 1000 символов без NUL (её не принимает set_config). */
+export declare function checkReason(v: unknown, where: string): string;
 /** Значение слота: id, список id, строка ответа или ленивая цепочка (в той же транзакции). */
 export type SlotValue = string | string[] | {
     id: string;
@@ -81,6 +86,10 @@ export interface WriteCtx {
     tenant: string | null;
     /** Владелец новых строк по умолчанию (db.as(…, { owner })). */
     owner?: string;
+    /** Причина по умолчанию для глаголов плана и та, что стоит в транзакции; cur — выставленная сейчас. */
+    reason?: string;
+    txReason?: string;
+    cur?: string;
 }
 /** Чтение в транзакции плана — тот же построитель, что у цепочек. */
 export declare function readIn<T>(w: WriteCtx, steps: Step[], mods: ChainMods, mode: ReadMode, agg?: AggSpec): Promise<{

package/dist/write.js

@@ -35,6 +35,13 @@ export function inc(by, opts = {}) {
     return Object.freeze({ [INC]: true, by, ...(opts.start !== undefined ? { start: opts.start } : {}) });
 }
 export const isInc = (v) => typeof v === 'object' && v !== null && v[INC] === true;
+/** Причина изменения: строка до 1000 символов без NUL (её не принимает set_config). */
+export function checkReason(v, where) {
+    if (typeof v !== 'string' || v.length > 1000 || v.includes('\0')) {
+        throw new LetopisError('invalid_query', `${where}: reason — строка до 1000 символов`);
+    }
+    return v;
+}
 const fail = (code, msg, detail) => {
     throw new LetopisError(code, msg, detail);
 };
@@ -126,6 +133,8 @@ export function precheckPlan(reg, steps) {
             continue;
         }
         const verb = op.kind;
+        if (op.reason !== undefined)
+            checkReason(op.reason, `${verb}()`);
         const m = s.opMods ?? {};
         if (m.asOf !== undefined)
             fail('invalid_query', `${verb}(): asOf описывает прошлое — записывать в него нельзя`);
@@ -188,6 +197,14 @@ export function precheckPlan(reg, steps) {
         prevOp = op;
     }
 }
+/** letopis.reason перед оператором глагола — только если причина меняется (план 1.1, §2.1). */
+async function useReason(w, want) {
+    if (want === (w.cur ?? w.txReason ?? ''))
+        return;
+    await query(w, `select set_config('letopis.reason', $1, true)`, [want]);
+    w.cur = want;
+}
+const reasonFor = (w, s) => s.op?.reason ?? w.reason ?? '';
 const quoteId = (name) => `"${name.replace(/"/g, '""')}"`;
 /** Строка ответа в том же виде, что у чтения (to_jsonb колонок узла). */
 const rowJson = (a) => `jsonb_build_object('id', ${a}.id, 'rev', ${a}.rev, 'class', ${a}.class, 'tenant', ${a}.tenant, 'owner', ${a}.owner, `
@@ -578,7 +595,8 @@ async function rekeyOp(w, steps, opStep) {
     const res = await query(w, `select ${rowJson('e')} as row from ${S}.entity e where e.id = any ($1::uuid[]) order by e.id`, [moved]);
     return res.map((r) => toRow(r.row));
 }
-function opCall(w, steps, opStep) {
+async function opCall(w, steps, opStep) {
+    await useReason(w, reasonFor(w, opStep));
     switch (opStep.op.kind) {
         case 'create': return createOp(w, steps, opStep, false);
         case 'upsert': return createOp(w, steps, opStep, true);
@@ -652,9 +670,11 @@ export async function execPlan(w, steps, mods, mode, agg) {
             : kind === 'purge' ? [] : last;
         prevOp = opStep;
     }
+    // причина глагола не переходит на следующие операторы транзакции
+    await useReason(w, w.reason ?? '');
     const opStep = segments[segments.length - 1].steps.at(-1);
     const key = opStep.aliasKey ?? opStep.name;
-    if (tail.length || mode === 'versions' || mode === 'agg') {
+    if (tail.length || mode === 'versions' || mode === 'agg' || mode === 'diff' || mode === 'blame') {
         if (!start.length)
             return { kind: 'read', q: null, res: [] };
         const { q, res } = await readIn(w, [fromRows(opStep, start.map((r) => r.id)), ...tail], mods, mode, agg);
@@ -708,7 +728,10 @@ export async function execBatch(w, plans) {
             const group = [];
             const seen = new Set();
             let j = i;
-            while (j < plans.length && pureKind(plans[j]) === 'keyed' && plans[j][0].op.kind === verb && plans[j][0].cls.name === head.cls.name) {
+            // одна причина на оператор: другая причина режет группу
+            const why = reasonFor(w, head);
+            while (j < plans.length && pureKind(plans[j]) === 'keyed' && plans[j][0].op.kind === verb && plans[j][0].cls.name === head.cls.name
+                && reasonFor(w, plans[j][0]) === why) {
                 const s = plans[j][0];
                 const id = idFor(s);
                 if (!id || (verb === 'upsert' && seen.has(id)))
@@ -717,6 +740,7 @@ export async function execBatch(w, plans) {
                 group.push({ at: j, s, id });
                 j++;
             }
+            await useReason(w, why);
             const input = group.map((g) => ({ d: g.s.op.data, t: tagsValue(g.s), o: g.s.ownerFilter ?? w.owner ?? null }));
             const conflict = verb === 'upsert'
                 ? 'on conflict (id) do update set data = excluded.data, links = excluded.links, tags = excluded.tags'
@@ -738,9 +762,11 @@ export async function execBatch(w, plans) {
         }
         else if (kind === 'keyless') {
             let j = i;
-            while (j < plans.length && pureKind(plans[j]) === 'keyless')
+            const why = reasonFor(w, head);
+            while (j < plans.length && pureKind(plans[j]) === 'keyless' && reasonFor(w, plans[j][0]) === why)
                 j++;
-            // однострочные вставки без ожидания ответа каждой — postgres.js шлёт их конвейером
+            // причина — до конвейера; однострочные вставки без ожидания ответа каждой — postgres.js шлёт их конвейером
+            await useReason(w, why);
             const rows = await Promise.all(plans.slice(i, j).map((p) => createOp(w, p, p[0], false)));
             rows.forEach((r, k) => (out[i + k] = r));
             i = j;
@@ -751,5 +777,6 @@ export async function execBatch(w, plans) {
             i++;
         }
     }
+    await useReason(w, w.txReason ?? '');
     return out;
 }

package/llms.txt

@@ -2,13 +2,16 @@
 
 > Versioned entity store for Node.js on PostgreSQL 18. Every change is a version in a journal (history, reads as of a date, cursor subscriptions). Integrity, tenant isolation and access rules are enforced by the database itself (triggers and row-level security), so they hold for raw SQL too. Data is read and written with chains like `db.Shop(shop).Product().rows()`.
 
-Key facts for writing code with letopis 1.0:
+Key facts for writing code with letopis 1.1:
 
 - ESM package, Node 22+, PostgreSQL 18+ with pgcrypto, database encoding UTF8. Runtime dependency: `postgres`. Zod 4 is an optional peer dependency needed only by `letopis/model`.
 - Install a schema with `up({ dsn, schema })` from an admin role; the schema is named `v2.<name>`. The application connects with a LOGIN role that is a member of `letopis_app`: `connect({ dsn, schema: 'v2.<name>', token | apiKey })`. A role that bypasses RLS is refused (`bypass_rls`) unless `allowBypassRls: true`.
 - Classes are hubs (objects) and links (relations with ends), described with `hub()`/`link()` from `letopis/model` and written to the database with `syncModels()` or `letopis sync`. A class with a key gets a deterministic UUID v5 id (`db.idOf`); uniqueness is the key.
 - Verbs return a chain; a terminal (`rows`, `first`, `ids`, `count`, …) executes the whole plan in one transaction. `create` only creates (a taken key is `exists`), `update` merges and never creates, `upsert` replaces the whole object (keyed classes only), `delete()` is a preview and `delete({ confirm: true })` deletes.
 - Money and counters: `update({ balance: inc(n) })` adds inside the statement; `update(patch, { rev })` fails with `conflict` if the row changed; `forUpdate()` locks rows inside `db.begin()`.
+- History: `versions()`, `diff({ from, to })` and `blame()` (who, when and why last changed each field); verbs, `db.begin()` and `db.batch()` take `{ reason }`.
+- Bulk loading from an admin connection: `db.load(rows)`; into an empty schema `db.load(rows, { initial: true })` — one transaction, indexes and triggers rebuilt at the end.
+- NOTIFY signals are visible to any database role: `up({ signals: 'class' | 'tenant' | 'opaque' | 'none' })` chooses what they reveal (default `class`).
 - Access rules are always on and deny by default; `up({ tenant })` or `createTenant()` creates a tenant with the rule "authenticated users may do everything" and its first user.
 - Errors carry a lowercase `err.code`: `exists`, `conflict`, `invalid_data` (`err.issues`), `target_not_found`, `acl_denied`, `no_session`, `removed` (0.21 API with its replacement), …
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letopis",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Letopis (летопись): versioned entity store on PostgreSQL 18 — integrity, history, tenants and access control enforced by the database itself, dot-notation chains on top",
   "keywords": [
     "postgres",
@@ -90,6 +90,7 @@
     "@electric-sql/pglite-socket": "^0.2.11",
     "@types/node": "^22.20.5",
     "letopis-0": "npm:letopis@0.21.0",
+    "letopis-1": "npm:letopis@1.0.1",
     "tsx": "^4.23.15",
     "typescript": "~5.9.3",
     "zod": "4.6.5"

package/sql/10-core.sql

@@ -86,6 +86,9 @@ create table if not exists @SCHEMA@.log (
   prev_hash  bytea,
   hash       bytea generated always as (@SCHEMA@.version_hash(prev_hash,
                @SCHEMA@.snapshot(id, rev, class, tenant, owner, links, data, tags, at, author, agent, op, reason, moved))) stored,
+  -- пути изменения против предыдущей версии (план 1.1, ревизия 6): производные, в снимок и хэш не входят;
+  -- null — не посчитано (создание, загрузчик, импорт), blame досчитывает сравнением
+  changed    jsonb,
   constraint log_id_rev unique (id, rev)
 );
 create index if not exists log_class_at on @SCHEMA@.log (class, at);
@@ -125,7 +128,11 @@ revoke all on @SCHEMA@.entity, @SCHEMA@.log, @SCHEMA@.secret from public, @APP@;
 grant select, delete on @SCHEMA@.entity to @APP@;
 grant insert (id, tenant, class, links, data, tags, owner) on @SCHEMA@.entity to @APP@;
 grant update (class, links, data, tags) on @SCHEMA@.entity to @APP@;
-grant select on @SCHEMA@.log to @APP@;
+-- журнал — без колонки changed (ревью №1 точки А плана 1.1): её пути описывают разницу с предыдущей версией, а та
+-- читателю может быть не видна (условие ACL скрыло её и пропустило следующую); blame получает пути через
+-- version_paths, которая проверяет видимость обеих версий (75-history.sql)
+grant select (seq, tx, id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, hash)
+  on @SCHEMA@.log to @APP@;
 alter table @SCHEMA@.entity enable row level security;
 alter table @SCHEMA@.log enable row level security;
 alter table @SCHEMA@.secret enable row level security;

package/sql/60-write.sql

@@ -260,34 +260,74 @@ language sql stable
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 return coalesce((@SCHEMA@.class_row(p_class, p_tenant)).data->'resolved'->>'history', 'true') <> 'false';
 
--- Сигнал с именами изменённых классов (§2.12, решение 9 точки А). Транзакция с NOTIFY фиксируется
--- под общей блокировкой кластера вместе с fsync, поэтому библиотека помечает свои транзакции
--- letopis.notify = 'deferred': имена копятся в letopis.changed, а библиотека после фиксации
--- отправляет их одной транзакцией без данных. Сырой SQL шлёт NOTIFY здесь же, вместе с фиксацией.
-create or replace function @SCHEMA@.signal(p_classes text[]) returns void
+-- Сигналы (план 1.1, §2.2): канал — имя схемы, нагрузка — по режиму установки '@SIGNALS@'
+-- (up({ signals })): class — имя класса; tenant — «Класс@токен арендатора»; opaque — «токен класса@токен
+-- арендатора»; none — сигналов нет. Сессии — session:<16 hex>, сброс — * (кроме none). Токен — первые
+-- 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
+return left(encode(@PGCRYPTO@.hmac(convert_to(p_purpose || ':' || p_value, 'UTF8'), p_key, 'sha256'), 'hex'), 24);
+
+-- Готовые нагрузки: сигналы записи от signal(), сессии и сброс. Транзакция с NOTIFY фиксируется под
+-- общей блокировкой кластера вместе с fsync, поэтому библиотека помечает свои транзакции
+-- letopis.notify = 'deferred': нагрузки копятся в letopis.changed, а библиотека после фиксации
+-- сбрасывает по ним свой кэш и отправляет их одной транзакцией без данных (в режиме none — не
+-- отправляет). Сырой SQL шлёт NOTIFY здесь же, вместе с фиксацией; в режиме none — ничего.
+create or replace function @SCHEMA@.signal_raw(p_payloads text[]) returns void
 language plpgsql volatile
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 declare
   acc text[];
-  cl text;
+  pl text;
 begin
-  if p_classes is null or cardinality(p_classes) = 0 then
+  p_payloads := array(select distinct x from unnest(p_payloads) x where x <> '' order by x);
+  if cardinality(p_payloads) = 0 then
     return;
   end if;
   if coalesce(current_setting('letopis.notify', true), '') = 'deferred' then
     acc := coalesce(string_to_array(nullif(current_setting('letopis.changed', true), ''), ','), '{}');
-    if not (acc @> p_classes) then
+    if not (acc @> p_payloads) then
       perform set_config('letopis.changed',
-        array_to_string(array(select distinct x from unnest(acc || p_classes) x order by x), ','), true);
+        array_to_string(array(select distinct x from unnest(acc || p_payloads) x order by x), ','), true);
     end if;
-  else
-    foreach cl in array p_classes loop
-      perform pg_notify('@SCHEMA_NAME@', cl);
+  elsif '@SIGNALS@' <> 'none' then
+    foreach pl in array p_payloads loop
+      perform pg_notify('@SCHEMA_NAME@', pl);
     end loop;
   end if;
 end $$;
 
+-- Сигнал записи: пары «класс, арендатор» изменённых строк (арендатор null — System) → нагрузки по
+-- режиму. Одинаковые пары склеиваются: транзакция, записавшая тысячу строк одного класса одного
+-- арендатора, посылает один сигнал.
+create or replace function @SCHEMA@.signal(p_classes text[], p_tenants uuid[]) returns void
+language plpgsql volatile
+set search_path = pg_catalog, @SCHEMA@, pg_temp
+as $$
+declare
+  k bytea;
+begin
+  if p_classes is null or cardinality(p_classes) = 0 then
+    return;
+  end if;
+  if '@SIGNALS@' in ('tenant', 'opaque') then
+    select @PGCRYPTO@.hmac(convert_to('letopis:signals', 'UTF8'), s.material, 'sha256') into k
+    from @SCHEMA@.secret s where s.id = '@SYSTEM@'::uuid and s.kind = 'KEY';
+  end if;
+  perform @SCHEMA@.signal_raw(array(
+    select case '@SIGNALS@'
+             when 'tenant' then p.c || '@' || @SCHEMA@.signal_token('tenant', p.t::text, k)
+             when 'opaque' then @SCHEMA@.signal_token('class', p.c, k) || '@' || @SCHEMA@.signal_token('tenant', p.t::text, k)
+             else p.c end
+    from (select distinct u.c, coalesce(u.t, '@SYSTEM@'::uuid) as t from unnest(p_classes, p_tenants) u(c, t) where u.c is not null) p));
+end $$;
+
 -- Версия одной строки в журнал и сигнал — для функций владельца, которые пишут строку сами
 -- (пересчёт потомков, снятие конца, перенос на новый id). Классы с history: false журнал не ведут,
 -- но сигнал посылают. Обычную запись журналируют триггеры после оператора — одной вставкой.
@@ -295,12 +335,19 @@ 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
-    insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash)
-    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);
-  end if;
-  perform @SCHEMA@.signal(array[e.class]);
+    -- пути изменения: против предыдущей версии 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);
+  end if;
+  perform @SCHEMA@.signal(array[e.class], array[e.tenant]);
 end $$;
 
 -- Новая версия строки от имени владельца (пересчёт описаний потомков, снятие конца при удалении):
@@ -383,13 +430,16 @@ begin
 end $$;
 
 -- Безопасно ли изменение описания класса (этап 1, п. 10): новые необязательные поля и концы,
--- метаданные, алиас, политика истории, кэш. Всё остальное — ужесточение с проверкой строк.
+-- метаданные, алиас, политика истории, кэш. Всё остальное — ужесточение с проверкой строк, в том числе
+-- любая правка условий 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->'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'
   and coalesce(o->'schema'->'required', '[]'::jsonb) @> coalesce(n->'schema'->'required', '[]'::jsonb)
   and not exists (select 1 from jsonb_each(coalesce(o->'schema'->'properties', '{}'::jsonb)) p
                   where n->'schema'->'properties'->p.key is distinct from p.value)
@@ -701,7 +751,8 @@ language plpgsql security definer
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 declare
-  cls text[];
+  sc text[];
+  st uuid[];
   bad text;
 begin
   if exists (select 1 from added n where n.links <> '{}'::jsonb) then
@@ -716,9 +767,10 @@ begin
   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;
-  select array_agg(distinct a.class) into cls from added a;
-  perform @SCHEMA@.signal(cls);
-  if cls && array['rule', 'Resource', 'member', 'Account', 'Class'] then
+  -- сигнал — по паре «класс, арендатор»
+  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);
+  if sc && array['rule', 'Resource', 'member', 'Account', 'Class'] then
     perform @SCHEMA@.acl_bump();
   end if;
   return null;
@@ -732,7 +784,8 @@ language plpgsql security definer
 set search_path = pg_catalog, @SCHEMA@, pg_temp
 as $$
 declare
-  cls text[];
+  sc text[];
+  st uuid[];
   o_row @SCHEMA@.entity;
   n_row @SCHEMA@.entity;
   cid uuid;
@@ -748,15 +801,20 @@ begin
   if bad is not null then
     perform @SCHEMA@.lt_fail('target_not_found', format('цель конца %s не найдена', 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, 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)
   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;
-  select array_agg(distinct n.class) into cls from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev;
-  perform @SCHEMA@.signal(cls);
-  if cls && array['rule', 'Resource', 'member', 'Account', 'Class'] then
+  -- сигнал — по парам нового и прежнего класса: при смене класса без ключа ответы прежнего класса в
+  -- кэше других процессов устарели бы (в 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;
+  perform @SCHEMA@.signal(sc, st);
+  if sc && array['rule', 'Resource', 'member', 'Account', 'Class'] then
     perform @SCHEMA@.acl_bump();
   end if;
   for cid in select n.id from new_rows n join old_rows o on o.id = n.id and o.rev <> n.rev
@@ -880,6 +938,8 @@ declare
   unsets uuid[];
   classes text[];
   lvl_classes text[];
+  pairs text[];
+  lvl_pairs text[];
   v_author uuid;
   v_reason text := nullif(current_setting('letopis.reason', true), '');
   newlinks jsonb;
@@ -910,16 +970,18 @@ begin
   end loop;
   v_author := coalesce(c.author, '@SYSTEM@'::uuid);
   -- надгробия: последний снимок следующей версией с видом delete — одной вставкой на уровень
-  insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash)
+  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
+         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;
+  -- пары «класс, арендатор» для сигнала — строкой «класс арендатор» (пробела нет ни в имени, ни в 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, accs, mems from gone g;
+    into lvl, classes, pairs, accs, mems from gone g;
   all_ids := lvl;
   while cardinality(lvl) > 0 loop
     -- кто ссылается на уровень: действие по правилам концов (общее с превью)
@@ -941,24 +1003,26 @@ 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)
+      insert into @SCHEMA@.log (id, rev, class, cv, tenant, owner, links, data, tags, at, author, agent, op, reason, moved, prev_hash, changed)
       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
+             greatest(@SCHEMA@.now_ts(), d.at + interval '1 microsecond'), v_author, c.agent, 'delete', v_reason, null, d.hash, '[]'::jsonb
       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
     )
     select coalesce(array_agg(d.id), '{}'), coalesce(array_agg(distinct d.class), '{}'),
+           coalesce(array_agg(distinct d.class || ' ' || d.tenant::text), '{}'),
            min(d.class) 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, denied, lvl_accs, lvl_mems from d;
+      into lvl, lvl_classes, lvl_pairs, denied, lvl_accs, lvl_mems from d;
     if denied is not null then
       perform @SCHEMA@.lt_fail('acl_denied', format('нет права DELETE на класс %s в каскаде удаления', denied));
     end if;
     accs := accs || lvl_accs;
     mems := mems || lvl_mems;
     classes := classes || lvl_classes;
+    pairs := pairs || lvl_pairs;
     -- 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
@@ -987,7 +1051,8 @@ begin
     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;
-  perform @SCHEMA@.signal(array(select distinct x from unnest(classes) x));
+  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
     perform @SCHEMA@.acl_bump();
   end if;
@@ -1356,7 +1421,7 @@ begin
     'links_replace(jsonb, uuid, uuid)', 'move_row(@SCHEMA@.entity, uuid, text, jsonb, jsonb, text)', 'reclass(uuid, text, jsonb)',
     'incoming_conflicts(uuid, text, uuid)', 'visible_detail(jsonb, uuid)', 'class_change_safe(jsonb, jsonb)',
     'family_conflicts(text[], uuid, boolean)', 'reserved_names()', 'class_admit(jsonb, uuid)',
-    'trg_entity_bi()', 'trg_entity_bu()', 'trg_entity_ai()', 'trg_entity_au()', 'history_on(text, uuid)', 'signal(text[])', 'class_evolve(@SCHEMA@.entity, @SCHEMA@.entity)',
+    '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
     execute format('alter function @SCHEMA@.%s owner to @OWNER@', f);
     execute format('revoke all on function @SCHEMA@.%s from public', f);