@verdeect/kit 0.0.0-stage → 1.0.0-rc.2

package/dist/testing/start-test-stack.js

@@ -0,0 +1,342 @@
+// startTestStack — globalSetup Vitest: контейнеры TEST_IMAGES раз на прогон, адреса через provide (prd.md §3.8, E1;
+// AC-1.12, AC-1.13). Эталоны — O test/support/global-setup.ts (minio, provide, teardown), I global-setup.ts (mailpit),
+// O setup-error.ts (текст ошибки в stderr до throw: Vite теряет текст ошибок globalSetup).
+// E4: при postgres — prepareDatabase и шаблон <svc>_template; migrations — runMigrations до копии.
+// Код БД — динамический import() (без pg /testing импортируется).
+// E5: rabbitmq — definitions.json (internal/rabbitmq-definitions, как CLI), vhost и пользователь на воркер (эталон B
+// test/support/broker.ts), удаление по префиксу <svc>-test-.
+// E8: redis — aclfile из internal/redis-acl (как CLI redis acl) + администратор теста; пользователей на воркер нет.
+import { randomBytes } from 'node:crypto';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { availableParallelism, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { loadPeer } from '../internal/peer.js';
+import { assertServiceName } from '../internal/service-name.js';
+import { buildRedisAclFile, redisPasswordHash } from '../internal/redis-acl.js';
+import { quoteIdentifier } from '../internal/sql-identifier.js';
+import { TEST_IMAGES } from './images.js';
+import { assertOutboxCoverage, setCoverageDir } from './outbox-coverage.js';
+import { deleteTestVhosts, prepareWorkerVhosts, RabbitAdmin, } from './rabbitmq-admin.js';
+const { GenericContainer, Wait } = await loadPeer('testcontainers', 'testing');
+const MINIO_USER = 'kit-test';
+const RABBIT_ADMIN = 'kit-admin';
+const REDIS_ADMIN = 'kit-test-admin';
+const REDIS_ACL_PATH = '/usr/local/etc/redis/users.acl';
+/** Ошибка шага подготовки БД: в stderr — имя шага и код, без текста pg (адрес, имя роли); у migrate — и текст SQL. */
+class PrepareStepError extends Error {
+    constructor(step, cause) {
+        const code = cause?.code;
+        const detail = step === 'migrate' ? `: ${errorMessage(cause)}` : '';
+        super(`шаг ${step}, код ${typeof code === 'string' ? code : 'нет'}${detail}`, { cause });
+    }
+}
+async function step(name, work) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        throw new PrepareStepError(name, error);
+    }
+}
+function withDatabase(base, database, user, password) {
+    const url = new URL(base);
+    url.pathname = `/${database}`;
+    if (user !== undefined && password !== undefined) {
+        url.username = user;
+        url.password = password;
+    }
+    return url.toString();
+}
+async function adminExec(pg, url, sql) {
+    const client = new pg.Client({ connectionString: url });
+    client.on('error', () => undefined);
+    await client.connect();
+    try {
+        await client.query(sql);
+    }
+    finally {
+        await client.end();
+    }
+}
+/**
+ * Подготовка БД стека (§3.8, AC-4.18): шаблон `<svc>_template` — prepareDatabase, миграции; копия `<svc>` — права
+ * уровня БД заново (при копировании не переносятся).
+ */
+async function prepareStackDatabase(adminUrl, service, migrations, project) {
+    const pg = (await loadPeer('pg', 'testing')).default;
+    const [{ prepareDatabase, grantDatabaseAccess }, { runMigrations }] = await Promise.all([
+        import('../database/prepare-database.js'),
+        import('../database/migrations.js'),
+    ]);
+    const ownerPassword = randomBytes(16).toString('hex');
+    const appPassword = randomBytes(16).toString('hex');
+    const template = `${service}_template`;
+    const templateAdmin = withDatabase(adminUrl, template);
+    await step('create-template', () => adminExec(pg, adminUrl, `CREATE DATABASE ${quoteIdentifier(template)}`));
+    await step('prepare', () => prepareDatabase({ service, adminUrl: templateAdmin, ownerPassword, appPassword }));
+    if (migrations !== undefined) {
+        await step('migrate', () => runMigrations({
+            url: withDatabase(adminUrl, template, `${service}_owner`, ownerPassword),
+            folder: resolve(migrations),
+            schema: service,
+        }));
+    }
+    await step('copy', async () => {
+        await adminExec(pg, adminUrl, `CREATE DATABASE ${quoteIdentifier(service)} TEMPLATE ${quoteIdentifier(template)}`);
+        const client = new pg.Client({ connectionString: adminUrl });
+        client.on('error', () => undefined);
+        await client.connect();
+        try {
+            await grantDatabaseAccess(client, service, service);
+        }
+        finally {
+            await client.end();
+        }
+    });
+    project.provide('kitDatabaseUrl', withDatabase(adminUrl, service, `${service}_app`, appPassword));
+    project.provide('kitDatabaseOwnerUrl', withDatabase(adminUrl, service, `${service}_owner`, ownerPassword));
+    project.provide('kitDatabaseAdminUrl', withDatabase(adminUrl, service));
+    project.provide('kitDatabaseService', service);
+    project.provide('kitDatabaseTemplate', template);
+}
+function postgresPart(labels, service, migrations) {
+    const password = randomBytes(16).toString('hex');
+    return {
+        name: 'postgres',
+        start: () => new GenericContainer(TEST_IMAGES.postgres)
+            .withLabels(labels)
+            .withEnvironment({
+            POSTGRES_USER: 'postgres',
+            POSTGRES_PASSWORD: password,
+            POSTGRES_DB: 'postgres',
+        })
+            .withExposedPorts(5432)
+            .withTmpFs({ '/var/lib/postgresql/data': 'rw' })
+            .withCommand([
+            'postgres',
+            '-c',
+            'fsync=off',
+            '-c',
+            'synchronous_commit=off',
+            '-c',
+            'full_page_writes=off',
+        ])
+            // Сообщение готовности выводится дважды: init-скрипт и рабочий старт.
+            .withWaitStrategy(Wait.forLogMessage(/database system is ready to accept connections/, 2))
+            .withStartupTimeout(120_000)
+            .start(),
+        provide: async (container, project) => {
+            const host = container.getHost();
+            const port = container.getMappedPort(5432);
+            const url = `postgres://postgres:${password}@${host}:${port}/postgres`;
+            project.provide('kitPostgresUrl', url);
+            await prepareStackDatabase(url, service, migrations, project);
+        },
+    };
+}
+function mailpitPart(labels) {
+    return {
+        name: 'mailpit',
+        start: () => new GenericContainer(TEST_IMAGES.mailpit)
+            .withLabels(labels)
+            .withExposedPorts(1025, 8025)
+            .withWaitStrategy(Wait.forHttp('/livez', 8025).forStatusCode(200))
+            .withStartupTimeout(120_000)
+            .start(),
+        provide: (container, project) => {
+            const host = container.getHost();
+            project.provide('kitSmtpUrl', `smtp://${host}:${container.getMappedPort(1025)}`);
+            project.provide('kitMailpitUrl', `http://${host}:${container.getMappedPort(8025)}`);
+        },
+    };
+}
+function minioPart(labels) {
+    const password = randomBytes(16).toString('hex');
+    return {
+        name: 'minio',
+        start: () => new GenericContainer(TEST_IMAGES.minio)
+            .withLabels(labels)
+            .withEnvironment({ MINIO_ROOT_USER: MINIO_USER, MINIO_ROOT_PASSWORD: password })
+            .withExposedPorts(9000)
+            .withCommand(['server', '/data'])
+            .withWaitStrategy(Wait.forHttp('/minio/health/live', 9000))
+            .withStartupTimeout(120_000)
+            .start(),
+        provide: (container, project) => {
+            project.provide('kitS3Endpoint', `http://${container.getHost()}:${container.getMappedPort(9000)}`);
+            project.provide('kitS3AccessKey', MINIO_USER);
+            project.provide('kitS3SecretKey', password);
+        },
+    };
+}
+/** Число воркеров прогона: `maxWorkers` проектов (число ≥ 1), иначе `os.availableParallelism()`. */
+export function maxWorkersOf(configs) {
+    const counts = configs
+        .map(({ maxWorkers }) => maxWorkers)
+        .filter((value) => typeof value === 'number' && value >= 1);
+    return counts.length === 0 ? Math.max(1, availableParallelism()) : Math.max(...counts);
+}
+function rabbitmqPart(labels, service) {
+    const password = randomBytes(16).toString('hex');
+    const prefix = `${service}-test-`;
+    let admin;
+    return {
+        name: 'rabbitmq',
+        start: () => new GenericContainer(TEST_IMAGES.rabbitmq)
+            .withLabels(labels)
+            .withEnvironment({
+            RABBITMQ_DEFAULT_USER: RABBIT_ADMIN,
+            RABBITMQ_DEFAULT_PASS: password,
+        })
+            .withExposedPorts(5672, 15672)
+            .withWaitStrategy(Wait.forLogMessage(/Server startup complete/))
+            .withStartupTimeout(120_000)
+            .start(),
+        provide: async (container, project) => {
+            const host = container.getHost();
+            const url = `amqp://${RABBIT_ADMIN}:${password}@${host}:${container.getMappedPort(5672)}`;
+            const managementUrl = `http://${host}:${container.getMappedPort(15672)}/`;
+            admin = new RabbitAdmin(managementUrl, RABBIT_ADMIN, password);
+            await admin.waitReady();
+            const workers = maxWorkersOf([
+                project.config,
+                ...project.vitest.projects.map((item) => item.config),
+            ]);
+            const prepared = await prepareWorkerVhosts(admin, {
+                service,
+                workers,
+                runId: randomBytes(4).toString('hex'),
+                amqpAdminUrl: url,
+            });
+            if (prepared.removed.length > 0) {
+                process.stderr.write(`[startTestStack] удалены vhost прошлых прогонов: ${prepared.removed.join(', ')}\n`);
+            }
+            project.provide('kitRabbitmqUrl', url);
+            project.provide('kitRabbitmqManagementUrl', managementUrl);
+            project.provide('kitRabbitmqWorkers', prepared.workers);
+        },
+        teardown: async () => {
+            if (admin === undefined) {
+                return;
+            }
+            const { vhosts, users } = await deleteTestVhosts(admin, prefix);
+            process.stderr.write(`[startTestStack] RabbitMQ: удалено vhost ${vhosts}, пользователей ${users}\n`);
+        },
+    };
+}
+function redisPart(labels, service) {
+    const password = randomBytes(16).toString('hex');
+    const adminPassword = randomBytes(16).toString('hex');
+    const aclfile = buildRedisAclFile({
+        users: [{ service, passwordHash: redisPasswordHash(password) }],
+        extra: [`user ${REDIS_ADMIN} on #${redisPasswordHash(adminPassword)} ~* &* +@all`],
+    });
+    return {
+        name: 'redis',
+        start: () => new GenericContainer(TEST_IMAGES.redis)
+            .withLabels(labels)
+            .withCopyContentToContainer([
+            { content: aclfile, target: REDIS_ACL_PATH, mode: 0o644 },
+        ])
+            .withCommand([
+            'redis-server',
+            '--aclfile',
+            REDIS_ACL_PATH,
+            '--save',
+            '',
+            '--appendonly',
+            'no',
+        ])
+            .withExposedPorts(6379)
+            .withWaitStrategy(Wait.forLogMessage(/Ready to accept connections/))
+            .withStartupTimeout(120_000)
+            .start(),
+        provide: (container, project) => {
+            const address = `${container.getHost()}:${container.getMappedPort(6379)}`;
+            project.provide('kitRedisUrl', `redis://${service}:${password}@${address}`);
+            project.provide('kitRedisAdminUrl', `redis://${REDIS_ADMIN}:${adminPassword}@${address}`);
+            project.provide('kitRedisService', service);
+        },
+    };
+}
+function errorMessage(reason) {
+    return reason instanceof Error ? reason.message : String(reason);
+}
+/** globalSetup Vitest: `export default startTestStack({...})`; teardown останавливает контейнеры (§3.8). */
+export function startTestStack(options) {
+    assertServiceName(options.service, 'startTestStack');
+    if (options.migrations !== undefined && options.postgres !== true) {
+        throw new TypeError('startTestStack: migrations требует postgres: true');
+    }
+    const labels = { 'verdeect.kit.service': options.service };
+    return async (project) => {
+        const parts = [
+            ...(options.postgres === true
+                ? [postgresPart(labels, options.service, options.migrations)]
+                : []),
+            ...(options.mailpit === true ? [mailpitPart(labels)] : []),
+            ...(options.minio === true ? [minioPart(labels)] : []),
+            ...(options.rabbitmq === true ? [rabbitmqPart(labels, options.service)] : []),
+            ...(options.redis === true ? [redisPart(labels, options.service)] : []),
+        ];
+        const results = await Promise.allSettled(parts.map((part) => part.start()));
+        const started = results.flatMap((result) => result.status === 'fulfilled' ? [result.value] : []);
+        const failed = parts.filter((_, index) => results[index]?.status === 'rejected');
+        const firstFailure = results.find((result) => result.status === 'rejected');
+        if (firstFailure !== undefined) {
+            await Promise.allSettled(started.map((container) => container.stop()));
+            const names = failed.map((part) => part.name).join(', ');
+            const message = `[startTestStack] не удалось запустить ${names}: ${errorMessage(firstFailure.reason)}`;
+            process.stderr.write(`${message}\n`);
+            throw new Error(message, { cause: firstFailure.reason });
+        }
+        let preparing = '';
+        try {
+            for (const [index, part] of parts.entries()) {
+                const container = started[index];
+                if (container !== undefined) {
+                    preparing = part.name;
+                    await part.provide(container, project);
+                }
+            }
+        }
+        catch (error) {
+            await Promise.allSettled(started.map((container) => container.stop()));
+            const message = `[startTestStack] не удалось подготовить ${preparing}: ${errorMessage(error)}`;
+            process.stderr.write(`${message}\n`);
+            throw new Error(message, {
+                cause: error,
+            });
+        }
+        const coverage = options.outboxEvents === undefined
+            ? undefined
+            : mkdtempSync(join(tmpdir(), `kit-outbox-${options.service}-`));
+        if (coverage !== undefined) {
+            setCoverageDir(coverage);
+            project.provide('kitOutboxCoverageDir', coverage);
+        }
+        return async () => {
+            try {
+                await stopParts();
+                // После освобождения ресурсов: ошибка покрытия выходит из teardown.
+                if (options.outboxEvents !== undefined && process.env.KIT_OUTBOX_COVERAGE === '1') {
+                    assertOutboxCoverage(options.outboxEvents);
+                }
+            }
+            finally {
+                setCoverageDir(undefined);
+                if (coverage !== undefined) {
+                    rmSync(coverage, { recursive: true, force: true });
+                }
+            }
+        };
+        async function stopParts() {
+            for (const part of parts) {
+                await part.teardown?.().catch((error) => {
+                    process.stderr.write(`[startTestStack] очистка ${part.name} не удалась: ${errorMessage(error)}\n`);
+                });
+            }
+            await Promise.all(started.map((container) => container.stop()));
+        }
+    };
+}

package/dist/testing/tcp-proxy.d.ts

@@ -0,0 +1,40 @@
+/** TCP-прокси с постоянным локальным портом на 127.0.0.1 (§3.8). */
+export declare class TcpProxy {
+    private server;
+    private readonly sockets;
+    /** Пары клиент → upstream с пересылкой (для freeze). */
+    private readonly links;
+    private port;
+    private blackholed;
+    private trigger;
+    private delay;
+    private readonly target;
+    /** upstreamUrl — URL цели с портом или схемой из DEFAULT_PORTS. */
+    constructor(upstreamUrl: string);
+    /** Исходный URL с хостом и портом прокси (учётные данные — как у исходного). */
+    get url(): string;
+    /** Начать слушать (порт выбирает ОС при первом запуске). */
+    start(): Promise<this>;
+    /** Разорвать все соединения и перестать слушать; новые соединения отклоняются. */
+    break(): Promise<void>;
+    /** Потеря пакетов: соединение устанавливается, но ответа нет (не «connection refused»). */
+    blackhole(): void;
+    /** Перестать пересылать байты, не закрывая соединений. */
+    freeze(): void;
+    /** blackhole() в момент, когда клиент отправит пакет, содержащий pattern (один раз). */
+    blackholeOn(pattern: RegExp): void;
+    /**
+     * Задержать пакеты клиента с совпадением на ms (первые count раз); для соединений после вызова:
+     * режим пересылки выбирается при приёме соединения, уже открытые соединения не меняются.
+     */
+    delayOn(pattern: RegExp, ms: number, count?: number): void;
+    /** Снять blackhole и обрыв, снова слушать тот же порт. */
+    restore(): Promise<void>;
+    /** Закрыть прокси и освободить порт. */
+    close(): Promise<void>;
+    private delayFor;
+    private destroySockets;
+    private listen;
+}
+/** Запущенный TCP-прокси к target (URL с портом или схемой из DEFAULT_PORTS). */
+export declare function tcpProxy(target: string): Promise<TcpProxy>;

package/dist/testing/tcp-proxy.js

@@ -0,0 +1,164 @@
+// TCP-прокси для обрывов и задержек в тестах (prd.md §3.8, E1); эталон — O test/support/tcp-proxy.ts (029c25c).
+// Без BrokerState/brokerReconnected и waitFor (только для брокера, при необходимости — E5).
+// break() рвёт все соединения и перестаёт слушать, restore() — снова слушает тот же порт. blackhole() — потеря пакетов:
+// рвёт текущие соединения, новые принимает, но ничего не передаёт. blackholeOn(pattern) — обрыв в момент запроса.
+// delayOn(pattern, ms, count) — пакет клиента с совпадением уходит на сервер через ms (первые count раз); действует на
+// соединения, принятые после вызова. freeze() — соединения остаются открытыми, но байты больше не пересылаются.
+import { createServer, connect as tcpConnect } from 'node:net';
+/** Порт цели по схеме URL, если порт не указан. */
+const DEFAULT_PORTS = {
+    'postgres:': 5432,
+    'postgresql:': 5432,
+    'amqp:': 5672,
+    'redis:': 6379,
+    'http:': 80,
+};
+/** TCP-прокси с постоянным локальным портом на 127.0.0.1 (§3.8). */
+export class TcpProxy {
+    server = null;
+    sockets = new Set();
+    /** Пары клиент → upstream с пересылкой (для freeze). */
+    links = new Set();
+    port = 0;
+    blackholed = false;
+    trigger = null;
+    delay = null;
+    target;
+    /** upstreamUrl — URL цели с портом или схемой из DEFAULT_PORTS. */
+    constructor(upstreamUrl) {
+        this.target = new URL(upstreamUrl);
+    }
+    /** Исходный URL с хостом и портом прокси (учётные данные — как у исходного). */
+    get url() {
+        const url = new URL(this.target.href);
+        url.hostname = '127.0.0.1';
+        url.port = String(this.port);
+        return url.href;
+    }
+    /** Начать слушать (порт выбирает ОС при первом запуске). */
+    async start() {
+        await this.listen(this.port);
+        return this;
+    }
+    /** Разорвать все соединения и перестать слушать; новые соединения отклоняются. */
+    async break() {
+        const server = this.server;
+        this.server = null;
+        this.destroySockets();
+        if (server !== null) {
+            await new Promise((resolve) => server.close(() => resolve()));
+        }
+    }
+    /** Потеря пакетов: соединение устанавливается, но ответа нет (не «connection refused»). */
+    blackhole() {
+        this.blackholed = true;
+        this.destroySockets();
+    }
+    /** Перестать пересылать байты, не закрывая соединений. */
+    freeze() {
+        this.blackholed = true;
+        for (const [client, upstream] of this.links) {
+            client.unpipe(upstream);
+            upstream.unpipe(client);
+        }
+        this.links.clear();
+    }
+    /** blackhole() в момент, когда клиент отправит пакет, содержащий pattern (один раз). */
+    blackholeOn(pattern) {
+        this.trigger = pattern;
+    }
+    /**
+     * Задержать пакеты клиента с совпадением на ms (первые count раз); для соединений после вызова:
+     * режим пересылки выбирается при приёме соединения, уже открытые соединения не меняются.
+     */
+    delayOn(pattern, ms, count = 1) {
+        this.delay = { pattern, ms, left: count };
+    }
+    /** Снять blackhole и обрыв, снова слушать тот же порт. */
+    async restore() {
+        this.blackholed = false;
+        this.trigger = null;
+        if (this.server === null) {
+            await this.listen(this.port);
+        }
+    }
+    /** Закрыть прокси и освободить порт. */
+    async close() {
+        await this.break();
+    }
+    delayFor(chunk) {
+        const rule = this.delay;
+        if (rule === null || rule.left <= 0 || !rule.pattern.test(chunk.toString('latin1'))) {
+            return 0;
+        }
+        rule.left -= 1;
+        return rule.ms;
+    }
+    destroySockets() {
+        for (const socket of this.sockets) {
+            socket.destroy();
+        }
+        this.sockets.clear();
+        this.links.clear();
+    }
+    async listen(port) {
+        const upstreamPort = Number(this.target.port) || (DEFAULT_PORTS[this.target.protocol] ?? 0);
+        const server = createServer((client) => {
+            if (this.blackholed) {
+                this.sockets.add(client);
+                client.on('error', () => client.destroy());
+                return;
+            }
+            const upstream = tcpConnect(upstreamPort, this.target.hostname);
+            this.sockets.add(client);
+            this.sockets.add(upstream);
+            const link = [client, upstream];
+            this.links.add(link);
+            if (this.delay === null) {
+                client.pipe(upstream).pipe(client);
+            }
+            else {
+                // Ручная пересылка в исходном порядке: задержанный пакет держит и следующие за ним.
+                upstream.pipe(client);
+                let queue = Promise.resolve();
+                client.on('data', (chunk) => {
+                    const ms = this.delayFor(chunk);
+                    queue = queue.then(async () => {
+                        if (ms > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, ms));
+                        }
+                        if (this.links.has(link) && !upstream.destroyed) {
+                            upstream.write(chunk);
+                        }
+                    });
+                });
+            }
+            // pipe уже передал пакет: сокеты закрываются синхронно, до ответа сервера.
+            client.on('data', (chunk) => {
+                if (this.trigger !== null && this.trigger.test(chunk.toString('latin1'))) {
+                    this.trigger = null;
+                    this.blackhole();
+                }
+            });
+            const drop = () => {
+                client.destroy();
+                upstream.destroy();
+                this.sockets.delete(client);
+                this.sockets.delete(upstream);
+                this.links.delete(link);
+            };
+            client.on('error', drop).on('close', drop);
+            upstream.on('error', drop).on('close', drop);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(port, '127.0.0.1', () => resolve());
+        });
+        this.port = server.address().port;
+        this.server = server;
+    }
+}
+/** Запущенный TCP-прокси к target (URL с портом или схемой из DEFAULT_PORTS). */
+export async function tcpProxy(target) {
+    return new TcpProxy(target).start();
+}

package/dist/testing/tenant-isolation.d.ts

@@ -0,0 +1,31 @@
+/** Соединение с методом `query` (`pg.Pool`, `pg.Client`, `PoolClient`). */
+export interface KitQueryable {
+    /** Запрос с параметрами; строки результата. */
+    query(text: string, values?: unknown[]): Promise<{
+        rows: unknown[];
+    }>;
+}
+/**
+ * Роль соединения — роль приложения, а не владелец (AC-4.6): не суперпользователь, без `BYPASSRLS`, не владеет
+ * схемами и таблицами, без `CREATE` на базе и схемах (KT-19 п. 1).
+ * @throws {Error} «assertAppRoleIsNotOwner: <роль>: <нарушения через «; »>».
+ */
+export declare function assertAppRoleIsNotOwner(db: KitQueryable): Promise<void>;
+/** Опции `assertStrictTenantIsolation`. */
+export interface KitTenantIsolationOptions {
+    /** Схема сервиса. */
+    readonly schema: string;
+    /**
+     * Таблицы, которые проверка пропускает целиком: только таблицы, где колонка `tenant` не означает компанию; каждое
+     * исключение — с причиной в тесте сервиса.
+     */
+    readonly except?: readonly string[];
+}
+/**
+ * Строгий RLS схемы сервиса (§3.8, AC-4.8) — соединение **роли приложения**: каждая таблица с колонкой `tenant` — RLS,
+ * `FORCE`, строгая политика (`tenantPolicy`; `idempotency_key` — `createIdempotencyTable`); `outbox` — исключение строгой
+ * модели: политика `createOutboxTable` (пустой тенант — все строки), RLS и FORCE обязательны; под пустым тенантом 0 строк (вызывать после вставки данных фабриками); при таблице идемпотентности —
+ * функция `idempotency_purge` `SECURITY DEFINER`, владелец `<svc>_directory`, `search_path`, без `EXECUTE` у `PUBLIC`.
+ * @throws {Error} «assertStrictTenantIsolation(<схема>): <нарушения через «; »>».
+ */
+export declare function assertStrictTenantIsolation(db: KitQueryable, options: KitTenantIsolationOptions): Promise<void>;