letopis 1.1.0 → 1.3.0

package/dist/admin.d.ts

@@ -4,7 +4,7 @@
  * сами сверяют права (letopis.* — системный администратор или администраторское подключение).
  */
 import type postgres from 'postgres';
-import type { Registry } from './registry.js';
+import type { AggregateInfo, Registry } from './registry.js';
 import { type Executor, type TxContext } from './tx.js';
 type Sql = postgres.Sql<Record<string, unknown>>;
 export interface VerifyIssue {
@@ -29,7 +29,7 @@ export interface MaintainOptions {
     limit?: number;
 }
 export interface MaintainReport {
-    /** Другой процесс уже обслуживает установку (advisory-блокировка): этот вызов ничего не делал. */
+    /** Другой процесс уже обслуживает установку (держит строку-замок обслуживания): этот вызов ничего не делал. */
     skipped: boolean;
     /** Удалено истёкших и погашенных сессий и одноразовых кодов. */
     sessions: number;
@@ -84,6 +84,10 @@ export interface ModelDescription {
             ttl?: number;
         };
         meta: Record<string, unknown>;
+        /** Производный класс: строки пишет только проектор с этим именем (план 1.1, §2.4). */
+        derivedBy?: string;
+        /** Агрегатные поля: сумма или число живых строк класса-источника, их считает база (план 1.1, §2.4). */
+        aggregate?: Record<string, AggregateInfo>;
     }[];
     methods: {
         chain: readonly string[];
@@ -106,8 +110,9 @@ export declare function verify(a: AdminCtx, opts?: {
 /**
  * Обслуживание: истёкшие сессии и коды, прореживание журнала пачками (каждая — своя транзакция,
  * долгих блокировок нет), заполнение очереди сигналов. Из нескольких процессов работает один: пачка
- * первым делом берёт транзакционную advisory-блокировку (pg_try_advisory_xact_lock), и та снимается
- * с фиксацией пачки. Сеансовая блокировка за пулом в режиме транзакций (PgBouncer) оставалась бы на
+ * первым делом берёт строку-замок обслуживания (lock_try в maintain() базы: for update skip locked строки
+ * secret, которую посторонняя роль не займёт), и та снимается с фиксацией пачки. Сеансовая блокировка
+ * за пулом в режиме транзакций (PgBouncer) оставалась бы на
  * серверном соединении, которое пул отдаёт другим клиентам, — и обслуживание молча вставало бы
  * (skipped у всех). Блокировку держит другой процесс: до первой пачки — skipped; между пачками —
  * вызов останавливается (продолжит тот процесс), отчёт — о сделанном, more: true.
@@ -135,6 +140,17 @@ export declare function trimHistory(a: AdminCtx, target: string | string[] | {
 }[], before: string | Date): Promise<number>;
 /** Новый ключ класса (этап 6, п. 7): строки семейства переносятся на новые id. Возвращает их число. */
 export declare function rekeyClass(a: AdminCtx, cls: string, key: string[]): Promise<number>;
+/**
+ * Ремонт агрегатов (план 1.1, §2.4): поля класса и его потомков во всех арендаторах — заново из живых источников,
+ * под исключительными блокировками семейств целей и источников (запись в них ждёт). Версия пишется только там, где
+ * значение изменилось; возвращает число исправленных строк. Функция владельца — от его роли (set local role), как
+ * загрузчик; подключение проверил вызывающий (admin_required).
+ */
+export declare function rebuildAggregates(env: {
+    sql: Sql;
+    S: string;
+    ownerRole: string;
+}, cls: string): Promise<number>;
 /** Машинное описание модели арендатора вместе с метаданными классов (этап 6, п. 12). */
 export declare function describe(a: AdminCtx): ModelDescription;
 /** Описание модели текстом для языковых моделей (llms.txt). */

package/dist/admin.js

@@ -1,4 +1,4 @@
-import { LetopisError } from './errors.js';
+import { LetopisError, fromDbError } from './errors.js';
 import { runTx } from './tx.js';
 import { CHAIN_METHODS, DB_METHODS } from './types.js';
 const SYSTEM_CLASSES = new Set(['Class', 'Account', 'member', 'Resource', 'rule']);
@@ -7,13 +7,12 @@ export async function verify(a, opts = {}) {
     const r = await one(a, `select ${a.S}.verify($1::boolean) as v`, [opts.data === true]);
     return r.v;
 }
-/** Ключ advisory-блокировки обслуживания: форма с двумя int4, своё пространство (19541). */
-const MAINTAIN_LOCK = (schema) => [19541, schema];
 /**
  * Обслуживание: истёкшие сессии и коды, прореживание журнала пачками (каждая — своя транзакция,
  * долгих блокировок нет), заполнение очереди сигналов. Из нескольких процессов работает один: пачка
- * первым делом берёт транзакционную advisory-блокировку (pg_try_advisory_xact_lock), и та снимается
- * с фиксацией пачки. Сеансовая блокировка за пулом в режиме транзакций (PgBouncer) оставалась бы на
+ * первым делом берёт строку-замок обслуживания (lock_try в maintain() базы: for update skip locked строки
+ * secret, которую посторонняя роль не займёт), и та снимается с фиксацией пачки. Сеансовая блокировка
+ * за пулом в режиме транзакций (PgBouncer) оставалась бы на
  * серверном соединении, которое пул отдаёт другим клиентам, — и обслуживание молча вставало бы
  * (skipped у всех). Блокировку держит другой процесс: до первой пачки — skipped; между пачками —
  * вызов останавливается (продолжит тот процесс), отчёт — о сделанном, more: true.
@@ -23,12 +22,10 @@ export async function maintain(a, opts = {}) {
         throw new LetopisError('invalid_query', 'maintain() — пачками в своих транзакциях, не внутри db.begin()');
     const now = opts.now === undefined ? null : opts.now instanceof Date ? opts.now.toISOString() : opts.now;
     const report = { skipped: false, sessions: 0, codes: 0, thinned: 0, batches: 0, more: false, queue: 0 };
-    const [k1, k2] = MAINTAIN_LOCK(a.schema);
     const max = opts.batches ?? 100;
     for (let i = 0; i < max; i++) {
-        // блокировка и пачка — одним оператором: case вычисляет maintain() только при взятой блокировке
-        const [{ r }] = await runTx(a.txc, (q) => q.unsafe(`select case when pg_try_advisory_xact_lock($1::int, hashtext($2::text))
-        then ${a.S}.maintain($3::text::timestamptz, $4::int) end as r`, [k1, k2, now, opts.limit ?? 10_000]));
+        // блокировку берёт сама maintain() базы — строку-замок, которую посторонняя роль не займёт; занята — null
+        const [{ r }] = await runTx(a.txc, (q) => q.unsafe(`select ${a.S}.maintain($1::text::timestamptz, $2::int) as r`, [now, opts.limit ?? 10_000]));
         if (r === null) {
             if (i === 0)
                 return { ...report, skipped: true };
@@ -122,6 +119,25 @@ export async function rekeyClass(a, cls, key) {
     const r = await one(a, `select ${a.S}.rekey_class($1, $2::jsonb) as n`, [name, key]);
     return r.n;
 }
+/**
+ * Ремонт агрегатов (план 1.1, §2.4): поля класса и его потомков во всех арендаторах — заново из живых источников,
+ * под исключительными блокировками семейств целей и источников (запись в них ждёт). Версия пишется только там, где
+ * значение изменилось; возвращает число исправленных строк. Функция владельца — от его роли (set local role), как
+ * загрузчик; подключение проверил вызывающий (admin_required).
+ */
+export async function rebuildAggregates(env, cls) {
+    if (typeof cls !== 'string' || !cls)
+        throw new LetopisError('invalid_data', 'rebuildAggregates(класс): имя класса');
+    const role = `"${env.ownerRole.replace(/"/g, '""')}"`;
+    return env.sql.begin(async (q) => {
+        await q.unsafe(`set local role ${role}`);
+        await q.unsafe(`select set_config('letopis.reason', 'rebuildAggregates', true)`);
+        const [{ n }] = await q.unsafe(`select ${env.S}.rebuild_aggregates($1) as n`, [cls]);
+        return n;
+    }).catch((e) => {
+        throw fromDbError(e);
+    });
+}
 /** Машинное описание модели арендатора вместе с метаданными классов (этап 6, п. 12). */
 export function describe(a) {
     const classes = a.registry().all().map((c) => ({
@@ -142,6 +158,8 @@ export function describe(a) {
         ownerDefault: c.ownerDefault,
         ...(c.cache ? { cache: c.cache } : {}),
         meta: c.meta,
+        ...(c.derivedBy ? { derivedBy: c.derivedBy } : {}),
+        ...(c.aggregate ? { aggregate: c.aggregate } : {}),
     })).sort((x, y) => Number(x.system) - Number(y.system) || x.name.localeCompare(y.name));
     return { schema: a.schema, tenant: a.tenant(), classes, methods: { chain: CHAIN_METHODS, db: DB_METHODS } };
 }
@@ -170,6 +188,12 @@ export function describeText(d) {
         });
         if (ends.length)
             out.push(`- концы: ${ends.join(', ')}`);
+        if (c.derivedBy)
+            out.push(`- производный: строки пишет проектор ${c.derivedBy}, приложение только читает`);
+        for (const [field, a] of Object.entries(c.aggregate ?? {})) {
+            const what = a.sum !== undefined ? `сумма ${a.sum}` : 'число';
+            out.push(`- агрегат ${field} = ${what} строк ${a.of} по концу ${a.via}${a.where ? `, условие ${JSON.stringify(a.where)}` : ''}; поле считает база, приложение его не пишет`);
+        }
         out.push('');
     }
     return out.join('\n');

package/dist/cli.js

@@ -13,6 +13,8 @@
  *   letopis import --from <строка 0.21> --from-schema v1.x --dsn … --schema v2.x [--tenant <имя>] [--keyless C]…
  *     [--rename Старое=Новое]… [--update] [--commit-every N] [--partition p] [--initial]   — код 1, если verify нашёл расхождения
  *   --initial — первая заливка (план 1.1, §2.3): пустая схема, одна транзакция, индексы и триггеры — после загрузки
+ *   letopis mcp --dsn … --schema v2.x --token … [--write]   — сервер MCP по stdio (план 1.1, §2.5); dsn, schema и
+ *     token — ещё из LETOPIS_DSN, LETOPIS_SCHEMA, LETOPIS_TOKEN; только токен пользователя: --api-key — отказ
  */
 import { parseArgs } from 'node:util';
 import { readFile, writeFile } from 'node:fs/promises';
@@ -30,7 +32,9 @@ letopis verify --dsn <строка> --schema <v2.имя> [--token <токен> |
 letopis maintain --dsn <строка> --schema <v2.имя> [--token <токен> | --api-key <ключ>] [--batches <N>]
 letopis describe --dsn <строка> --schema <v2.имя> (--token <токен> | --api-key <ключ>) [--format json|text] [--out <файл>]
 letopis import --from <строка 0.21> --from-schema <v1.имя> --dsn <строка> --schema <v2.имя> [--tenant <имя>] [--keyless <Класс>]…
-  [--rename <Старое>=<Новое>]… [--update] [--commit-every <N>] [--partition <имя>] [--initial]`;
+  [--rename <Старое>=<Новое>]… [--update] [--commit-every <N>] [--partition <имя>] [--initial]
+letopis mcp --dsn <строка> --schema <v2.имя> --token <токен пользователя> [--write]
+  (или LETOPIS_DSN, LETOPIS_SCHEMA, LETOPIS_TOKEN; ключ сервиса --api-key не принимается)`;
 const isModel = (v) => typeof v === 'object' && v !== null && typeof v.describe === 'function' && typeof v.name === 'string';
 export async function main(argv) {
     const { values, positionals } = parseArgs({
@@ -44,10 +48,16 @@ export async function main(argv) {
             format: { type: 'string' },
             from: { type: 'string' }, 'from-schema': { type: 'string' }, tenant: { type: 'string' }, partition: { type: 'string' },
             keyless: { type: 'string', multiple: true }, rename: { type: 'string', multiple: true }, update: { type: 'boolean' },
-            initial: { type: 'boolean' },
+            initial: { type: 'boolean' }, write: { type: 'boolean' },
         },
     });
     const [cmd, arg] = positionals;
+    // клиенты MCP передают строку подключения и токен окружением (план 1.1, §2.5) — только для этой команды
+    if (cmd === 'mcp') {
+        values.dsn ??= process.env.LETOPIS_DSN || undefined;
+        values.schema ??= process.env.LETOPIS_SCHEMA || undefined;
+        values.token ??= process.env.LETOPIS_TOKEN || undefined;
+    }
     if (values.help || !cmd || !values.dsn || !values.schema) {
         console.log(USAGE);
         return cmd ? 2 : 0;
@@ -75,10 +85,13 @@ export async function main(argv) {
         console.log(JSON.stringify(r, null, 2));
         return r.verify.ok ? 0 : 1;
     }
+    if (cmd === 'mcp')
+        return mcp(values);
     // загрузчику нужно администраторское подключение (§2.6, п. 1)
     const db = await connect({ dsn: values.dsn, schema: values.schema, token: values.token, apiKey: values['api-key'], max: 2,
-        // verify и maintain работают и на администраторском подключении без сессии
-        ...(cmd === 'load' || cmd === 'verify' || cmd === 'maintain' ? { allowBypassRls: true } : {}) });
+        // verify и maintain работают и на администраторском подключении без сессии; производные классы (derivedBy)
+        // синхронизирует администраторское подключение с сессией арендатора
+        ...(cmd === 'load' || cmd === 'verify' || cmd === 'maintain' || cmd === 'sync' ? { allowBypassRls: true } : {}) });
     try {
         if (cmd === 'sync') {
             if (!arg) {
@@ -157,6 +170,42 @@ export async function main(argv) {
         await db.close();
     }
 }
+/**
+ * letopis mcp (план 1.1, §2.5): сервер MCP по stdio от имени одного пользователя. Только токен сессии пользователя —
+ * ключ сервиса даёт все права auth.* (имперсонация, выпуск сессий) и лежал бы на машине агента. Модуль mcp.js и SDK
+ * грузятся только здесь: letopis --help и прочие команды работают без SDK. В stdout — только протокол (предупреждения
+ * connect() идут в stderr); процесс живёт, пока клиент не закроет stdin.
+ */
+async function mcp(v) {
+    if (v['api-key'] !== undefined) {
+        console.error('letopis: user_session_required: letopis mcp принимает только токен сессии пользователя (--token или LETOPIS_TOKEN): ключ сервиса даёт все права auth.* и не должен лежать на машине агента');
+        return 2;
+    }
+    if (!v.token) {
+        console.error('letopis: user_session_required: letopis mcp — нужен токен сессии пользователя: --token или LETOPIS_TOKEN');
+        return 2;
+    }
+    const { createMcpServer } = await import('./mcp.js');
+    const db = await connect({ dsn: v.dsn, schema: v.schema, token: v.token, max: 4 });
+    try {
+        const opts = { write: v.write === true };
+        // учётные данные — до начала протокола: отказ виден кодом выхода и текстом в stderr
+        await createMcpServer(db, opts);
+        const { serveStdio } = await import('@modelcontextprotocol/server/stdio');
+        const closed = new Promise((resolve) => {
+            process.stdin.once('end', resolve);
+            process.stdin.once('close', resolve);
+        });
+        // экземпляр сервера — на соединение (и на пробу server/discover): ревизию протокола выбирает клиент
+        const handle = serveStdio(() => createMcpServer(db, opts), { onerror: (e) => console.error(`letopis mcp: ${e.message}`) });
+        await closed;
+        await handle.close();
+        return 0;
+    }
+    finally {
+        await db.close();
+    }
+}
 // Запущен ли файл как программа. Сравниваются реальные пути: на Linux и macOS `node_modules/.bin/letopis`
 // (npx, скрипты package.json) — симлинк, `process.argv[1]` указывает на него, а `import.meta.url` — на сам файл.
 function isMain() {

package/dist/errors.js

@@ -35,7 +35,8 @@ const LT_NAMES = {
     LT006: 'acl_denied', LT007: 'id_mismatch', LT008: 'id_from_db', LT009: 'immutable_key', LT010: 'invalid_class',
     LT011: 'use_reclass', LT012: 'reclass_denied', LT013: 'tightening_conflict', LT014: 'isolation_level',
     LT015: 'recreated_in_statement', LT016: 'cursor_expired', LT017: 'delete_restricted', LT018: 'not_deleted',
-    LT019: 'reset_disabled', LT020: 'confirm_mismatch',
+    LT019: 'reset_disabled', LT020: 'confirm_mismatch', LT021: 'derived_class', LT022: 'aggregate_field',
+    LT023: 'projector_pending',
 };
 /**
  * Ошибка базы → LetopisError (ValidationError для invalid_data с нарушениями). Детали из DETAIL
@@ -64,7 +65,8 @@ export function fromDbError(e) {
     if (name === 'invalid_data' && Array.isArray(issues)) {
         const cls = /класса (\S+)/.exec(text)?.[1] ?? '?';
         const v = new ValidationError(cls, issues);
-        return Object.assign(v, { cause: e });
+        // текст базы целиком: в нём бывает больше, чем имя класса (у проектора — арендатор и id строки)
+        return Object.assign(v, { cause: e, ...(text ? { message: `letopis: invalid_data: ${text}` } : {}) });
     }
     return Object.assign(new LetopisError(name, text, detail), { cause: e });
 }

package/dist/index.d.ts

@@ -17,12 +17,13 @@ import { type Batch, type Chain, type StepFn } from './chain.js';
 import type { QueryEvent, Row } from './types.js';
 import { type CacheOptions, type CacheStats } from './cache.js';
 import { Subscription, type WatchOptions } from './watch.js';
+import { Projector, type ProjectorOptions } from './project.js';
 import { type MaintainOptions, type MaintainReport, type ModelDescription, type ResetOptions, type ResetResult, type VerifyResult } from './admin.js';
 import type { AnyModelLike, StepsOf } from './typed.js';
 export { DDL_REVISION } from './types.js';
 export { uuidv5, v5Name, v5Id, idOf, type KeyedClass } from './uuid.js';
 export { LetopisError, ValidationError, fromDbError, type Issue } from './errors.js';
-export { Registry, type ClassInfo, type EndInfo, type LeafType } from './registry.js';
+export { Registry, type AggregateInfo, type ClassInfo, type EndInfo, type LeafType } from './registry.js';
 export { compileValidator, applyDefaults, type Validator } from './validate.js';
 export { syncModels, generateTypes, schemaToTs, type SyncResult } from './sync.js';
 export { ne, gt, gte, lt, lte, between, inList, like, ilike, starts, ends, has, hasAny, hasAll, exists, isNull, not, or, isOp } from './ops.js';
@@ -38,6 +39,7 @@ export type { DiffChange, DiffResult, DiffOptions, BlameField, BlameResult, Blam
 export type { CacheOptions, CacheStats } from './cache.js';
 export type { SignalMode } from './signals.js';
 export type { WatchOptions, WatchEvent, Subscription } from './watch.js';
+export type { Projector, ProjectorOptions, ProjectorChange, ProjectorOut, ProjectorRow, ProjectorReport, ProjectorStatus, ProjectorFailure } from './project.js';
 export type { VerifyResult, VerifyIssue, MaintainOptions, MaintainReport, ResetOptions, ResetResult, ModelDescription } from './admin.js';
 export { describeText } from './admin.js';
 export { up, createTenant, type UpOptions, type UpResult, type HistoryPolicy, type TenantOptions, type TenantResult } from './up.js';
@@ -81,7 +83,7 @@ export interface ConnectOptions {
     listen?: boolean;
     /** Кэш результатов (§2.12): срок по умолчанию, размер, ttlOnly; false — выключен. */
     cache?: CacheOptions | false;
-    /** Запускать maintain() по расписанию ('1h', '15m', мс) под advisory-блокировкой: работает один процесс. */
+    /** Запускать maintain() по расписанию ('1h', '15m', мс) под блокировкой обслуживания: работает один процесс. */
     maintain?: string | number;
 }
 export interface DbCore {
@@ -151,6 +153,18 @@ export interface DbCore {
      * целям вне загрузки. Только на администраторском подключении (иначе admin_required).
      */
     load(input: LoadInput, opts?: LoadOptions): Promise<LoadReport>;
+    /**
+     * Проектор из журнала (план 1.1, §2.4): строит строки производных классов (derivedBy: имя) из изменений
+     * классов from; run() — догнать журнал и следовать за ним, rebuild() — перестроить с текущего состояния.
+     * Только на администраторском подключении (иначе admin_required).
+     */
+    projector(name: string, opts: ProjectorOptions): Projector;
+    /**
+     * Ремонт агрегатов в базе (план 1.1, §2.4): поля класса (с потомками) во всех арендаторах — заново из живых строк
+     * источников, под исключительными блокировками; версия — только у исправленных. Возвращает их число. Только на
+     * администраторском подключении (иначе admin_required).
+     */
+    rebuildAggregates(cls: string): Promise<number>;
     /**
      * Именованная очередь планов фасада: batch.Класс(…).create(…); batch.run() — одной транзакцией. У корня,
      * у каждого db.as() и у каждой db.begin() очереди свои: план исполняется от имени фасада, который его поставил.

package/dist/index.js

@@ -12,6 +12,7 @@ import { LetopisError, fromDbError, removed } from './errors.js';
 import { Registry } from './registry.js';
 import { AclPasses, ExplicitTx, Notifier, poolExecutor, runTx } from './tx.js';
 import { checkReason } from './write.js';
+import { registerDb } from './internal.js';
 import { makeAuth } from './auth.js';
 import { makeAcl } from './acl.js';
 import { idOf as idOfClass } from './uuid.js';
@@ -20,8 +21,9 @@ import { makeBatch, startEntity, startStep } from './chain.js';
 import { DDL_REVISION } from './types.js';
 import { ACL_CLASSES, ResultCache } from './cache.js';
 import { Subscription } from './watch.js';
+import { Projector } from './project.js';
 import { SIGNAL_MODES, Signals, bucket, throttle } from './signals.js';
-import { describe as describeModel, maintain as runMaintain, rekeyClass as runRekeyClass, reset as runReset, scheduleMaintain, trimHistory as runTrim, verify as runVerify, } from './admin.js';
+import { describe as describeModel, maintain as runMaintain, rebuildAggregates as runRebuildAggregates, rekeyClass as runRekeyClass, reset as runReset, scheduleMaintain, trimHistory as runTrim, verify as runVerify, } from './admin.js';
 export { DDL_REVISION } from './types.js';
 export { uuidv5, v5Name, v5Id, idOf } from './uuid.js';
 export { LetopisError, ValidationError, fromDbError } from './errors.js';
@@ -140,12 +142,22 @@ function makeDb(sh, scope, exec, owner, tx) {
             }
             // имперсонация и арендатор проверяются базой сразу: ошибка — здесь, а не на первой цепочке
             const scoped = { ...txc, account: id ?? txc.account, tenant: o?.tenant ?? (id === undefined ? txc.tenant : undefined) };
-            const [r] = await runTx(scoped, (q) => q.unsafe(`select account, tenant from ${sh.S}.ctx()`), { read: true });
+            let [r] = await runTx(scoped, (q) => q.unsafe(`select account, tenant from ${sh.S}.ctx()`), { read: true });
             if (!r?.account)
                 throw new LetopisError('no_session', 'db.as(): нет действующей сессии');
-            const tenant = r.tenant;
-            const registry = await sh.registryFor(tenant, scoped);
-            return makeDb(sh, { txc: scoped, tenant: () => tenant, registry: () => registry, root: false }, poolExecutor(scoped), nextOwner);
+            // контекст сессии между запросами ушёл из арендатора (сменился или кончился): реестр не загружен и не
+            // кэширован (хвост ревью безопасности №3) — контекст читается заново, не больше трёх раз
+            for (let attempt = 1;; attempt++) {
+                const tenant = r.tenant;
+                const registry = await sh.registryFor(tenant, scoped);
+                if (registry)
+                    return makeDb(sh, { txc: scoped, tenant: () => tenant, registry: () => registry, root: false }, poolExecutor(scoped), nextOwner);
+                if (attempt === 3)
+                    throw new LetopisError('no_session', 'db.as(): контекст сессии меняется — реестр арендатора не загружен');
+                [r] = await runTx(scoped, (q) => q.unsafe(`select account, tenant from ${sh.S}.ctx()`), { read: true });
+                if (!r?.account)
+                    throw new LetopisError('no_session', 'db.as(): нет действующей сессии');
+            }
         },
         begin: async (o) => {
             if (tx)
@@ -160,6 +172,23 @@ function makeDb(sh, scope, exec, owner, tx) {
                 throw new LetopisError('invalid_query', 'load() — своей транзакцией, не внутри db.begin()');
             return load({ sql: sh.sql, schema: sh.schema, tenant: scope.tenant(), admin: sh.admin, ownerRole: sh.ownerRole }, input, o);
         },
+        projector: (name, o) => {
+            if (tx)
+                throw new LetopisError('invalid_query', 'projector() — от корня подключения, а не внутри db.begin()');
+            if (!sh.admin)
+                throw new LetopisError('admin_required', 'проектору нужно администраторское подключение (connect({ allowBypassRls: true }) роли, которая может стать владельцем схемы)');
+            return new Projector({
+                sql: sh.sql, schema: sh.schema, S: sh.S, ownerRole: sh.ownerRole,
+                ...(sh.listen ? { onSignal: (fn) => { sh.signals.add(fn); return () => void sh.signals.delete(fn); } } : {}),
+            }, name, o);
+        },
+        rebuildAggregates: async (cls) => {
+            if (tx)
+                throw new LetopisError('invalid_query', 'rebuildAggregates() — своей транзакцией, не внутри db.begin()');
+            if (!sh.admin)
+                throw new LetopisError('admin_required', 'ремонту агрегатов нужно администраторское подключение (connect({ allowBypassRls: true }) роли, которая может стать владельцем схемы)');
+            return runRebuildAggregates({ sql: sh.sql, S: sh.S, ownerRole: sh.ownerRole }, cls);
+        },
         batch: (name, o) => {
             let q = batches.get(name);
             if (!q)
@@ -171,7 +200,7 @@ function makeDb(sh, scope, exec, owner, tx) {
         rollback: async (tr) => (tr ? tr.rollback() : tx ? tx.rollback() : noTx('rollback()')),
         close: () => (tx ? tx.rollback() : sh.close()),
     };
-    return new Proxy(core, {
+    const facade = new Proxy(core, {
         get(t, prop, r) {
             if (typeof prop === 'symbol' || prop in t)
                 return Reflect.get(t, prop, r);
@@ -191,6 +220,9 @@ function makeDb(sh, scope, exec, owner, tx) {
             return startStep(chainCtx, prop);
         },
     });
+    // модули пакета (letopis/mcp) узнают обход RLS по самому подключению, а не со слов вызывающего (internal.ts)
+    registerDb(facade, { allTenants: sh.allTenants, explicit: Boolean(tx) });
+    return facade;
 }
 export async function connect(opts) {
     if (!SCHEMA_NAME.test(opts.schema))
@@ -263,32 +295,60 @@ export async function connect(opts) {
         const ctx = { sql, token, notifier: mode === 'none' ? null : notifier, passes, after: touch,
             ...(cache ? { onChanged: (names, raw) => cache.changed(names, raw) } : {}) };
         const root = { tenant: null, registry: new Registry() };
-        const loadClasses = (txc) => runTx(txc, (q) => q.unsafe(`select tenant, rev, data from ${S}.entity where class = 'Class' and tenant in (${S}.ctx_tenant(), '${SYSTEM_ID}')`), { read: true });
+        // классы арендатора tenant под контекстом txc; null — контекст уже не в этом арендаторе (сессия кончилась,
+        // пользователь выбыл из арендатора): тогда прежний реестр остаётся, а не пустеет (доработки после точки Б)
+        const loadClasses = (txc, tenant) => runTx(txc, async (q) => {
+            const [t] = await q.unsafe(`select ${S}.ctx_tenant() as t`);
+            if (String(t?.t ?? '').toLowerCase() !== tenant.toLowerCase())
+                return null;
+            return q.unsafe(`select tenant, rev, data from ${S}.entity where class = 'Class' and tenant in (${S}.ctx_tenant(), '${SYSTEM_ID}')`);
+        }, { read: true });
+        // реестры db.as() — общие на арендатора; txc — контекст последнего успешного as() этого арендатора
         const others = new Map();
+        const loading = new Map();
         // токены классов (режим opaque) — по именам всех реестров подключения
         const tokens = () => sig.setClasses([root.registry, ...[...others.values()].map((o) => o.registry)].flatMap((r) => r.all().map((c) => c.name)));
-        const refresh = async () => {
+        // only — токены арендаторов из сигналов Class (режимы tenant и opaque): реестры db.as() только этих арендаторов
+        const refresh = async (only) => {
             const rows = await runTx(ctx, async (q) => {
                 const [t] = await q.unsafe(`select ${S}.ctx_tenant() as t`);
                 root.tenant = t?.t ?? null;
                 return q.unsafe(`select tenant, rev, data from ${S}.entity where class = 'Class' and tenant in (${S}.ctx_tenant(), '${SYSTEM_ID}')`);
             });
             root.registry.load(rows);
-            for (const o of others.values())
-                o.registry.load(await loadClasses(o.txc).catch(() => []));
+            for (const [tenant, o] of others) {
+                if (only && !only.has(sig.tenantToken(tenant) ?? ''))
+                    continue;
+                const loaded = await loadClasses(o.txc, tenant).catch(() => null);
+                if (loaded)
+                    o.registry.load(loaded);
+            }
             tokens();
         };
+        // фасад db.as() не делит реестр с корнем, даже в том же арендаторе: корень после auth.switch() перечитывает свой
+        // реестр классами нового арендатора (хвост ревью безопасности №3)
         const registryFor = async (tenant, txc) => {
-            if (tenant === root.tenant)
-                return root.registry;
             const known = others.get(tenant);
-            if (known)
+            if (known) {
+                known.txc = txc;
                 return known.registry;
-            const registry = new Registry();
-            registry.load(await loadClasses(txc));
-            others.set(tenant, { registry, txc });
-            tokens();
-            return registry;
+            }
+            // одновременные as() нового арендатора получают один реестр
+            let pending = loading.get(tenant);
+            if (!pending) {
+                pending = (async () => {
+                    const rows = await loadClasses(txc, tenant);
+                    if (!rows)
+                        return null;
+                    const registry = new Registry();
+                    registry.load(rows);
+                    others.set(tenant, { registry, txc });
+                    tokens();
+                    return registry;
+                })().finally(() => loading.delete(tenant));
+                loading.set(tenant, pending);
+            }
+            return pending;
         };
         // ключ сигналов (режимы tenant и opaque) — сессии с правом letopis.signals; без права процесс
         // работает без ключа: арендатора (а в opaque — и класса) в сигнале не различает
@@ -311,7 +371,7 @@ export async function connect(opts) {
         // поддельными сигналами) не становится потоком перечитываний
         const resync = throttle(() => {
             passes.clear();
-            void fetchKey().then(refresh).catch(() => { });
+            void fetchKey().then(() => refresh()).catch(() => { });
         }, 5000);
         // сигнал Class — реестр сразу, как в 1.0: правка описания доходит без задержки; пока идёт перечитывание, новые
         // сигналы сливаются в одно следующее. Три перечитывания подряд — сразу, дальше не чаще раза в 5 с: заливка
@@ -319,17 +379,28 @@ export async function connect(opts) {
         // точки А)
         let reloading = false;
         let again = false;
+        // какие реестры db.as() перечитать: токены арендаторов из сигналов или все (сигнал без арендатора)
+        let reloadAll = false;
+        const reloadTokens = new Set();
         const startReload = bucket(() => {
             reloading = true;
-            void refresh().catch(() => { }).finally(() => {
+            const only = reloadAll ? null : new Set(reloadTokens);
+            reloadAll = false;
+            reloadTokens.clear();
+            void refresh(only).catch(() => { }).finally(() => {
                 reloading = false;
                 if (again) {
                     again = false;
-                    reload();
+                    reload(undefined);
                 }
             });
         }, 3, 5000);
-        const reload = () => {
+        // tenant: null — все реестры, строка — токен арендатора сигнала, undefined — то, что уже накоплено
+        const reload = (tenant) => {
+            if (tenant === null)
+                reloadAll = true;
+            else if (tenant !== undefined)
+                reloadTokens.add(tenant);
             if (reloading) {
                 again = true;
                 return;
@@ -343,7 +414,7 @@ export async function connect(opts) {
             if (s.kind === 'class' && ACL_CLASSES.has(s.cls))
                 passes.clear();
             if (s.kind === 'class' && s.cls === 'Class')
-                reload();
+                reload(s.tenant);
             else if (s.kind === 'all' || s.kind === 'opaque' || s.kind === 'unknown' || s.kind === 'foreign')
                 resync();
             cache?.signal(s);

package/dist/internal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Внутренний канал между модулями пакета (план 1.1, этап 5): свойства подключения, которых нет в публичном API.
+ * Модуля нет в exports package.json — снаружи пакета его не импортировать; letopis/mcp узнаёт по нему, что
+ * фасад db обходит RLS, не полагаясь на то, что сообщает о себе сам вызывающий.
+ */
+/** Что фасад db (корень, db.as(), db.begin()) сообщает модулям пакета. */
+export interface DbInternals {
+    /** Подключение в обход RLS (суперпользователь, BYPASSRLS, член роли-владельца): видит строки всех арендаторов. */
+    readonly allTenants: boolean;
+    /** Фасад явной транзакции db.begin(). */
+    readonly explicit: boolean;
+}
+/** Запомнить фасад (зовёт makeDb для каждого фасада, который отдаёт наружу). */
+export declare function registerDb(db: object, info: DbInternals): void;
+/** Свойства фасада; undefined — объект не фасад connect() этого пакета. */
+export declare function internalsOf(db: unknown): DbInternals | undefined;

package/dist/internal.js

@@ -0,0 +1,14 @@
+/**
+ * Внутренний канал между модулями пакета (план 1.1, этап 5): свойства подключения, которых нет в публичном API.
+ * Модуля нет в exports package.json — снаружи пакета его не импортировать; letopis/mcp узнаёт по нему, что
+ * фасад db обходит RLS, не полагаясь на то, что сообщает о себе сам вызывающий.
+ */
+const facades = new WeakMap();
+/** Запомнить фасад (зовёт makeDb для каждого фасада, который отдаёт наружу). */
+export function registerDb(db, info) {
+    facades.set(db, info);
+}
+/** Свойства фасада; undefined — объект не фасад connect() этого пакета. */
+export function internalsOf(db) {
+    return db !== null && (typeof db === 'object' || typeof db === 'function') ? facades.get(db) : undefined;
+}