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

package/dist/messaging/envelope.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import type { KitEvent } from './define-event.js';
+/** Схема конверта события `01` §7.1 (не strict: новые поля конверта не ломают подписчиков). */
+export declare const EnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    version: z.ZodNumber;
+    occurredAt: z.ZodISODateTime;
+    tenant: z.ZodNullable<z.ZodString>;
+    actor: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    subject: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    traceId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type TenantOf<E extends KitEvent> = [E['tenant']] extends ['none'] ? null : [E['tenant']] extends ['required'] ? string : string | null;
+/** Конверт события `E`: `tenant` — `string` для `'required'`, `null` для `'none'`; `data` — выход схемы события. */
+export type Envelope<E extends KitEvent = KitEvent> = Omit<z.output<typeof EnvelopeSchema>, 'type' | 'data' | 'tenant' | 'version'> & {
+    readonly type: E['type'];
+    readonly version: number;
+    readonly data: z.output<E['data']>;
+    readonly tenant: TenantOf<E>;
+};
+/** Поля строки outbox, из которых relay собирает конверт. */
+export interface OutboxRowForEnvelope {
+    /** id события. */
+    readonly id: string;
+    /** Тип. */
+    readonly type: string;
+    /** Версия. */
+    readonly version: number;
+    /** Время события. */
+    readonly occurredAt: Date;
+    /** Тенант. */
+    readonly tenant: string | null;
+    /** Актор `DbContext`. */
+    readonly actor: Record<string, unknown> | null;
+    /** Вид субъекта — из `defineEvent.subject`. */
+    readonly subjectKind: string;
+    /** id субъекта. */
+    readonly subjectId: string;
+    /** Данные. */
+    readonly data: Record<string, unknown>;
+    /** traceId. */
+    readonly traceId: string | null;
+}
+/** Конверт из строки outbox (relay). */
+export declare function buildEnvelope(row: OutboxRowForEnvelope): Envelope;
+/** Итог разбора тела сообщения: `fields` — верхнеуровневые имена полей с ошибкой, без значений. */
+export type ParsedEnvelope = {
+    readonly ok: true;
+    readonly envelope: Envelope;
+} | {
+    readonly ok: false;
+    readonly reason: 'not-json' | 'envelope';
+    readonly fields: readonly string[];
+};
+/** Разбор тела входящего сообщения по `EnvelopeSchema`. */
+export declare function parseEnvelope(content: Buffer): ParsedEnvelope;
+/** Тенант конверта нарушает признак события: `'required'` без тенанта или `'none'` с тенантом (AC-5.15). */
+export declare function tenantViolation(event: KitEvent, envelope: {
+    readonly tenant: string | null;
+}): boolean;
+export {};

package/dist/messaging/envelope.js

@@ -0,0 +1,49 @@
+// Конверт события 01 §7.1 (prd.md §3.4, AC-5.2, AC-5.7, AC-5.15). Эталон — O/P/I event-envelope.ts (схема одинаковая);
+// по PRD все поля §7.1 обязательны, tenant/actor/traceId — nullable (П21), subject — {kind, id}.
+import { z } from 'zod';
+/** Схема конверта события `01` §7.1 (не strict: новые поля конверта не ломают подписчиков). */
+export const EnvelopeSchema = z.object({
+    id: z.string().min(1),
+    type: z.string().min(1),
+    version: z.number().int().min(1),
+    occurredAt: z.iso.datetime({ offset: true }),
+    tenant: z.string().min(1).nullable(),
+    actor: z.record(z.string(), z.unknown()).nullable(),
+    subject: z.object({ kind: z.string().min(1), id: z.string().min(1) }),
+    data: z.record(z.string(), z.unknown()),
+    traceId: z.string().min(1).nullable(),
+});
+/** Конверт из строки outbox (relay). */
+export function buildEnvelope(row) {
+    return {
+        id: row.id,
+        type: row.type,
+        version: row.version,
+        occurredAt: row.occurredAt.toISOString(),
+        tenant: row.tenant,
+        actor: row.actor,
+        subject: { kind: row.subjectKind, id: row.subjectId },
+        data: row.data,
+        traceId: row.traceId,
+    };
+}
+/** Разбор тела входящего сообщения по `EnvelopeSchema`. */
+export function parseEnvelope(content) {
+    let raw;
+    try {
+        raw = JSON.parse(content.toString('utf8'));
+    }
+    catch {
+        return { ok: false, reason: 'not-json', fields: [] };
+    }
+    const result = EnvelopeSchema.safeParse(raw);
+    if (!result.success) {
+        const fields = result.error.issues.map((issue) => issue.path.length === 0 ? '(root)' : String(issue.path[0]));
+        return { ok: false, reason: 'envelope', fields: [...new Set(fields)] };
+    }
+    return { ok: true, envelope: result.data };
+}
+/** Тенант конверта нарушает признак события: `'required'` без тенанта или `'none'` с тенантом (AC-5.15). */
+export function tenantViolation(event, envelope) {
+    return event.tenant === 'required' ? envelope.tenant === null : envelope.tenant !== null;
+}

package/dist/messaging/errors.d.ts

@@ -0,0 +1,45 @@
+import type { StartupFailure } from '../observability/fail-startup.js';
+/**
+ * Ожидаемый отказ обработки (например, зависимость временно недоступна): `warn` и повтор через `<svc>.retry` до 5 раз,
+ * затем DLQ с `x-dlq-reason` = `code`; в GlitchTip не отправляется. Сервис наследует класс со своим кодом.
+ */
+export declare abstract class ExpectedMessageError extends Error {
+    readonly code: string;
+    /**
+     * @param code Код отказа SCREAMING_SNAKE — значение `x-dlq-reason` после исчерпания повторов.
+     * @param message Текст для лога, без ПДн.
+     * @throws {TypeError} `code` не SCREAMING_SNAKE.
+     */
+    constructor(code: string, message: string);
+}
+/**
+ * Сообщение нельзя обработать никогда — сразу в `<svc>.dlq` без повторов, `x-dlq-reason` = `reason`. В `reason` —
+ * только пути полей и коды, без значений и ПДн; длиннее 200 символов обрезается.
+ */
+export declare class InvalidMessageError extends Error {
+    /** Код ошибки. */
+    readonly code = "INVALID_MESSAGE";
+    /** Причина отказа (≤ 200 символов) — значение `x-dlq-reason`. */
+    readonly reason: string;
+    /** @param reason Причина: пути полей и коды, без значений. */
+    constructor(reason: string);
+}
+/** Коды отказа запуска /messaging. */
+export type MessagingStartupCode = 'MESSAGING_TENANT_NOT_NULLABLE' | 'MESSAGING_RETRY_TTL_MISMATCH';
+/**
+ * Отказ запуска `/messaging` с кодом: `MESSAGING_TENANT_NOT_NULLABLE` — событие `tenant: 'none'` при NOT NULL `tenant`
+ * outbox; `MESSAGING_RETRY_TTL_MISMATCH` — `<svc>.retry` объявлена с другим TTL. `failStartup` пишет `startupCode` и
+ * `startupDetails()` — только имена (тип события, таблица, очередь), без значений окружения.
+ */
+export declare class MessagingStartupError extends Error implements StartupFailure {
+    readonly startupCode: MessagingStartupCode;
+    private readonly details;
+    /**
+     * @param startupCode Код отказа.
+     * @param message Текст для лога.
+     * @param details Имена (тип события, таблица, очередь).
+     */
+    constructor(startupCode: MessagingStartupCode, message: string, details: Readonly<Record<string, string>>);
+    /** Подробности отказа для лога: только имена. */
+    startupDetails(): Readonly<Record<string, string>>;
+}

package/dist/messaging/errors.js

@@ -0,0 +1,63 @@
+const CODE = /^[A-Z][A-Z0-9_]*$/;
+const MAX_REASON = 200;
+/**
+ * Ожидаемый отказ обработки (например, зависимость временно недоступна): `warn` и повтор через `<svc>.retry` до 5 раз,
+ * затем DLQ с `x-dlq-reason` = `code`; в GlitchTip не отправляется. Сервис наследует класс со своим кодом.
+ */
+export class ExpectedMessageError extends Error {
+    code;
+    /**
+     * @param code Код отказа SCREAMING_SNAKE — значение `x-dlq-reason` после исчерпания повторов.
+     * @param message Текст для лога, без ПДн.
+     * @throws {TypeError} `code` не SCREAMING_SNAKE.
+     */
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        if (!CODE.test(code)) {
+            throw new TypeError(`ExpectedMessageError: код «${code}» не SCREAMING_SNAKE`);
+        }
+        this.name = new.target.name;
+    }
+}
+/**
+ * Сообщение нельзя обработать никогда — сразу в `<svc>.dlq` без повторов, `x-dlq-reason` = `reason`. В `reason` —
+ * только пути полей и коды, без значений и ПДн; длиннее 200 символов обрезается.
+ */
+export class InvalidMessageError extends Error {
+    /** Код ошибки. */
+    code = 'INVALID_MESSAGE';
+    /** Причина отказа (≤ 200 символов) — значение `x-dlq-reason`. */
+    reason;
+    /** @param reason Причина: пути полей и коды, без значений. */
+    constructor(reason) {
+        const trimmed = reason.slice(0, MAX_REASON);
+        super(`сообщение отклонено: ${trimmed}`);
+        this.reason = trimmed;
+        this.name = 'InvalidMessageError';
+    }
+}
+/**
+ * Отказ запуска `/messaging` с кодом: `MESSAGING_TENANT_NOT_NULLABLE` — событие `tenant: 'none'` при NOT NULL `tenant`
+ * outbox; `MESSAGING_RETRY_TTL_MISMATCH` — `<svc>.retry` объявлена с другим TTL. `failStartup` пишет `startupCode` и
+ * `startupDetails()` — только имена (тип события, таблица, очередь), без значений окружения.
+ */
+export class MessagingStartupError extends Error {
+    startupCode;
+    details;
+    /**
+     * @param startupCode Код отказа.
+     * @param message Текст для лога.
+     * @param details Имена (тип события, таблица, очередь).
+     */
+    constructor(startupCode, message, details) {
+        super(message);
+        this.startupCode = startupCode;
+        this.details = details;
+        this.name = 'MessagingStartupError';
+    }
+    /** Подробности отказа для лога: только имена. */
+    startupDetails() {
+        return this.details;
+    }
+}

package/dist/messaging/inbox.d.ts

@@ -0,0 +1,4 @@
+import type { DbTx } from '../database/db.js';
+import type { KitInboxTable } from './tables.js';
+/** Занимает `id` события в транзакции обработчика; `false` — уже обработано (`duplicate`). */
+export declare function claimInbox(tx: DbTx, table: KitInboxTable, id: string, type: string): Promise<boolean>;

package/dist/messaging/inbox.js

@@ -0,0 +1,9 @@
+/** Занимает `id` события в транзакции обработчика; `false` — уже обработано (`duplicate`). */
+export async function claimInbox(tx, table, id, type) {
+    const rows = await tx
+        .insert(table)
+        .values({ id, type })
+        .onConflictDoNothing()
+        .returning({ id: table.id });
+    return rows.length > 0;
+}

package/dist/messaging/index.d.ts

@@ -0,0 +1,13 @@
+import './peer.js';
+export { defineEvent } from './define-event.js';
+export type { KitEvent, KitEventTenant } from './define-event.js';
+export { EnvelopeSchema } from './envelope.js';
+export type { Envelope } from './envelope.js';
+export { ExpectedMessageError, InvalidMessageError, MessagingStartupError } from './errors.js';
+export { KitMessagingModule } from './kit-messaging.module.js';
+export { OutboxStore } from './outbox-store.js';
+export { KitSubscriber } from './subscriber.js';
+export type { KitEventHandler, KitReplicaHandler } from './subscriber.js';
+export type { KitMessagingModuleOptions } from './kit-messaging.module.js';
+export { createInboxTable, createOutboxTable } from './tables.js';
+export type { KitInboxTable, KitOutboxTable, KitOutboxTableOptions } from './tables.js';

package/dist/messaging/index.js

@@ -0,0 +1,10 @@
+// Точка входа @verdeect/kit/messaging (prd.md §3.4, E5): явный список экспортов. Первый импорт — ./peer.js: без amqplib
+// или amqp-connection-manager ошибка AC-1.2 называет /messaging (requirePeer синхронно, без top-level await — П15).
+import './peer.js';
+export { defineEvent } from './define-event.js';
+export { EnvelopeSchema } from './envelope.js';
+export { ExpectedMessageError, InvalidMessageError, MessagingStartupError } from './errors.js';
+export { KitMessagingModule } from './kit-messaging.module.js';
+export { OutboxStore } from './outbox-store.js';
+export { KitSubscriber } from './subscriber.js';
+export { createInboxTable, createOutboxTable } from './tables.js';

package/dist/messaging/kit-messaging.module.d.ts

@@ -0,0 +1,39 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { KitEvent } from './define-event.js';
+import { type KitInboxTable, type KitOutboxTable } from './tables.js';
+/** Опции `KitMessagingModule.forRoot`. */
+export interface KitMessagingModuleOptions {
+    /** Имя экземпляра (`^[a-z][a-z0-9-]{1,31}$`): очереди `<svc>`, `<svc>.retry`, `<svc>.dlq`. */
+    readonly service: string;
+    /**
+     * Outbox: таблица `createOutboxTable(schema, {tenantNullable})` и все события, которые сервис публикует
+     * (`OutboxStore.add` события вне списка — `TypeError`). `tenantNullable` читается из таблицы.
+     */
+    readonly outbox?: {
+        readonly table: KitOutboxTable;
+        readonly events: readonly KitEvent[];
+    };
+    /**
+     * Подписчик; не задан — подписчика нет. `dedupe` по умолчанию `'inbox'` и требует `inbox: createInboxTable(schema)`;
+     * `'none'` — без БД и inbox (роль BFF).
+     */
+    readonly subscriber?: {
+        /** Защита от повторов подписчика. */
+        readonly dedupe?: 'inbox' | 'none';
+        /** Таблица inbox. */
+        readonly inbox?: KitInboxTable;
+    };
+}
+/**
+ * Сообщения сервиса (§3.4): соединение RabbitMQ, проба `rabbitmq`, outbox и relay, подписчик с inbox, очистка.
+ * Окружение — `envBase` и `envMessaging` из `KitConfigModule`; outbox и inbox требуют `KitDatabaseModule` и `pg`.
+ */
+export declare class KitMessagingModule {
+    /**
+     * Модуль сообщений; отказ — до прослушивания порта (`bootstrapService` → `failStartup`).
+     * @throws {TypeError} имя сервиса вне формата, несогласованные опции или таблицы, дубликат события.
+     * @throws {MessagingStartupError} событие `tenant: 'none'` при NOT NULL `tenant` (AC-5.15).
+     * @throws {Error} outbox или `dedupe: 'inbox'` без `pg` (AC-1.2).
+     */
+    static forRoot(options: KitMessagingModuleOptions): Promise<DynamicModule>;
+}

package/dist/messaging/kit-messaging.module.js

@@ -0,0 +1,309 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var KitMessagingModule_1;
+// KitMessagingModule.forRoot (prd.md §3.4, AC-1.2, AC-5.15, AC-5.20; П1, П5, П11). Эталон — O messaging.module.ts
+// (проба rabbitmq некритичная, соединение — шаг 4). pg — requirePeer только при outbox или dedupe: 'inbox', значения
+// database — динамическим import() здесь же (/messaging грузится без pg). Остановка — хуки Nest: соединение —
+// onApplicationShutdown (шаг 4), relay, подписчик, очистка — beforeApplicationShutdown (шаг 3); KitLifecycle не нужен.
+import { Inject, Injectable, Module, Optional, } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { getTableConfig } from 'drizzle-orm/pg-core';
+import { requirePeer } from '../internal/peer.js';
+import { assertServiceName } from '../internal/service-name.js';
+import { KIT_LOGGER, KIT_METRICS } from '../internal/tokens.js';
+import { HealthRegistry } from '../observability/health-registry.js';
+import { MessagingCleanup } from './cleanup.js';
+import { MessagingStartupError } from './errors.js';
+import { OutboxRelay } from './outbox-relay.js';
+import { OutboxStore } from './outbox-store.js';
+import { KitSubscriber } from './subscriber.js';
+import { RabbitConnection, nestLog } from './rabbit-connection.js';
+import { outboxTenantNullable } from './tables.js';
+import { handlersDeadlineMs } from './topology.js';
+import { KIT_MESSAGING_ENV, KIT_MESSAGING_LOG, KIT_MESSAGING_OPTIONS, KIT_RABBIT_CONNECTION, } from './config.js';
+function messagingEnv(config) {
+    if (config === undefined) {
+        throw new Error('KitMessagingModule: модуль сервиса не импортирует KitConfigModule.forRoot({schema}) с envBase и envMessaging');
+    }
+    return {
+        RABBITMQ_URL: config.getOrThrow('RABBITMQ_URL'),
+        RABBITMQ_RETRY_SECONDS: config.getOrThrow('RABBITMQ_RETRY_SECONDS'),
+        REPLICA_ID: config.getOrThrow('REPLICA_ID'),
+        SHUTDOWN_TIMEOUT_MS: config.getOrThrow('SHUTDOWN_TIMEOUT_MS'),
+        SHUTDOWN_DRAIN_MS: config.getOrThrow('SHUTDOWN_DRAIN_MS'),
+    };
+}
+function schemaOf(tables) {
+    const schemas = new Set();
+    for (const table of tables) {
+        if (table !== undefined) {
+            schemas.add(getTableConfig(table).schema);
+        }
+    }
+    if (schemas.size === 0) {
+        return undefined;
+    }
+    const [schema] = [...schemas];
+    if (schemas.size > 1 || schema === undefined) {
+        throw new TypeError('KitMessagingModule: таблицы outbox и inbox — одной схемы сервиса (createOutboxTable(pgSchema(…)))');
+    }
+    assertServiceName(schema, 'KitMessagingModule');
+    return schema;
+}
+function eventsOf(options, schema) {
+    const events = new Map();
+    const outbox = options.outbox;
+    if (outbox === undefined) {
+        return events;
+    }
+    const nullable = outboxTenantNullable(outbox.table);
+    for (const event of outbox.events) {
+        if (events.has(event.type)) {
+            throw new TypeError(`KitMessagingModule: событие ${event.type} указано дважды`);
+        }
+        if (event.tenant === 'none' && !nullable) {
+            throw new MessagingStartupError('MESSAGING_TENANT_NOT_NULLABLE', `KitMessagingModule: событие ${event.type} без компании (tenant: 'none') требует createOutboxTable(схема, {tenantNullable: true})`, { event: event.type, table: `${schema ?? ''}.outbox` });
+        }
+        events.set(event.type, event);
+    }
+    return events;
+}
+/** Старт соединения, проба `/health` и шаг 4 остановки (внутренний). */
+let MessagingLifecycle = class MessagingLifecycle {
+    connection;
+    config;
+    log;
+    health;
+    constructor(connection, config, log, health) {
+        this.connection = connection;
+        this.config = config;
+        this.log = log;
+        this.health = health;
+    }
+    /** Соединение в фоне; проба `rabbitmq` некритичная (П11). */
+    async onModuleInit() {
+        await this.connection.start();
+        this.health?.register('rabbitmq', () => Promise.resolve(this.connection.isConnected() && this.connection.topologyReady()), { critical: false });
+        this.log.debug({
+            service: this.config.service,
+            outbox: this.config.outbox !== undefined,
+            subscriber: this.config.subscriber ? this.config.dedupe : 'off',
+        }, 'messaging: модуль собран');
+    }
+    /** Шаг 4 остановки: соединение после relay и подписчика. */
+    async onApplicationShutdown() {
+        await this.connection.onApplicationShutdown();
+    }
+};
+MessagingLifecycle = __decorate([
+    Injectable(),
+    __param(0, Inject(KIT_RABBIT_CONNECTION)),
+    __param(1, Inject(KIT_MESSAGING_OPTIONS)),
+    __param(2, Inject(KIT_MESSAGING_LOG)),
+    __param(3, Optional()),
+    __metadata("design:paramtypes", [RabbitConnection, Object, Object, HealthRegistry])
+], MessagingLifecycle);
+/** Relay и `OutboxStore` при `outbox`: один объект — фабрика relay строит store, store будит relay. */
+function outboxProviders(config) {
+    const { outbox, database } = config;
+    if (outbox === undefined || database === undefined) {
+        return [];
+    }
+    return [
+        {
+            provide: OutboxRelay,
+            useFactory: (db, connection, log, metrics) => {
+                const store = new OutboxStore({
+                    db,
+                    table: outbox,
+                    events: config.events,
+                    wake: () => {
+                        relay.wake();
+                    },
+                    log,
+                });
+                const relay = new OutboxRelay({
+                    db,
+                    store,
+                    connection,
+                    events: config.events,
+                    metrics,
+                    log,
+                });
+                relayStores.set(relay, store);
+                return relay;
+            },
+            inject: [
+                database.Db,
+                KIT_RABBIT_CONNECTION,
+                KIT_MESSAGING_LOG,
+                { token: KIT_METRICS, optional: true },
+            ],
+        },
+        {
+            provide: OutboxStore,
+            useFactory: (relay) => {
+                const store = relayStores.get(relay);
+                if (store === undefined) {
+                    throw new Error('KitMessagingModule: OutboxStore без relay');
+                }
+                return store;
+            },
+            inject: [OutboxRelay],
+        },
+    ];
+}
+/** Подписчик при `subscriber`; `Db` — только при `dedupe: 'inbox'`. */
+function subscriberProviders(config) {
+    if (!config.subscriber) {
+        return [];
+    }
+    const withDb = config.dedupe === 'inbox' && config.database !== undefined;
+    return [
+        {
+            provide: KitSubscriber,
+            useFactory: (env, connection, log, metrics, db) => new KitSubscriber({
+                service: config.service,
+                replica: env.REPLICA_ID,
+                dedupe: config.dedupe,
+                ...(config.inbox === undefined ? {} : { inbox: config.inbox }),
+                ...(db === undefined ? {} : { db }),
+                connection,
+                retrySeconds: env.RABBITMQ_RETRY_SECONDS,
+                metrics,
+                log,
+            }),
+            inject: [
+                KIT_MESSAGING_ENV,
+                KIT_RABBIT_CONNECTION,
+                KIT_MESSAGING_LOG,
+                { token: KIT_METRICS, optional: true },
+                ...(withDb && config.database !== undefined ? [config.database.Db] : []),
+            ],
+        },
+    ];
+}
+/** Очистка при outbox или inbox (BFF без БД — без очистки). */
+function cleanupProviders(config) {
+    const { database, schema } = config;
+    if (database === undefined || schema === undefined) {
+        return [];
+    }
+    if (config.outbox === undefined && config.inbox === undefined) {
+        return [];
+    }
+    return [
+        {
+            provide: MessagingCleanup,
+            useFactory: (db, log, metrics) => new MessagingCleanup({
+                db,
+                database: {
+                    runExclusive: database.runExclusive,
+                    deleteInBatches: database.deleteInBatches,
+                },
+                schema,
+                tables: {
+                    ...(config.outbox === undefined ? {} : { outbox: config.outbox }),
+                    ...(config.inbox === undefined ? {} : { inbox: config.inbox }),
+                },
+                metrics,
+                log,
+            }),
+            inject: [database.Db, KIT_MESSAGING_LOG, { token: KIT_METRICS, optional: true }],
+        },
+    ];
+}
+/** Store, построенный фабрикой relay. */
+const relayStores = new WeakMap();
+/**
+ * Сообщения сервиса (§3.4): соединение RabbitMQ, проба `rabbitmq`, outbox и relay, подписчик с inbox, очистка.
+ * Окружение — `envBase` и `envMessaging` из `KitConfigModule`; outbox и inbox требуют `KitDatabaseModule` и `pg`.
+ */
+let KitMessagingModule = KitMessagingModule_1 = class KitMessagingModule {
+    /**
+     * Модуль сообщений; отказ — до прослушивания порта (`bootstrapService` → `failStartup`).
+     * @throws {TypeError} имя сервиса вне формата, несогласованные опции или таблицы, дубликат события.
+     * @throws {MessagingStartupError} событие `tenant: 'none'` при NOT NULL `tenant` (AC-5.15).
+     * @throws {Error} outbox или `dedupe: 'inbox'` без `pg` (AC-1.2).
+     */
+    static async forRoot(options) {
+        assertServiceName(options.service, 'KitMessagingModule');
+        const dedupe = options.subscriber?.dedupe ?? 'inbox';
+        const subscriber = options.subscriber !== undefined;
+        const needsDb = options.outbox !== undefined || (subscriber && dedupe === 'inbox');
+        if (subscriber && dedupe === 'inbox' && options.subscriber?.inbox === undefined) {
+            throw new TypeError("KitMessagingModule: subscriber с dedupe: 'inbox' требует inbox: createInboxTable(schema)");
+        }
+        if (dedupe === 'none' && options.subscriber?.inbox !== undefined) {
+            throw new TypeError("KitMessagingModule: inbox не используется при dedupe: 'none'");
+        }
+        const schema = schemaOf([options.outbox?.table, options.subscriber?.inbox]);
+        const events = eventsOf(options, schema);
+        let database;
+        if (needsDb) {
+            requirePeer('pg', 'messaging');
+            database = await import('../database/index.js');
+        }
+        const config = {
+            service: options.service,
+            schema,
+            dedupe,
+            subscriber,
+            events,
+            outbox: options.outbox?.table,
+            inbox: options.subscriber?.inbox,
+            database,
+        };
+        const outbox = outboxProviders(config);
+        const subscriberList = subscriberProviders(config);
+        return {
+            module: KitMessagingModule_1,
+            global: true,
+            providers: [
+                { provide: KIT_MESSAGING_OPTIONS, useValue: config },
+                {
+                    provide: KIT_MESSAGING_ENV,
+                    useFactory: messagingEnv,
+                    inject: [{ token: ConfigService, optional: true }],
+                },
+                {
+                    provide: KIT_MESSAGING_LOG,
+                    useFactory: (logger) => logger ?? nestLog('KitMessaging'),
+                    inject: [{ token: KIT_LOGGER, optional: true }],
+                },
+                {
+                    provide: KIT_RABBIT_CONNECTION,
+                    useFactory: (env, log) => new RabbitConnection({
+                        url: env.RABBITMQ_URL,
+                        retrySeconds: env.RABBITMQ_RETRY_SECONDS,
+                        deadlineMs: handlersDeadlineMs(env),
+                        log,
+                    }),
+                    inject: [KIT_MESSAGING_ENV, KIT_MESSAGING_LOG],
+                },
+                MessagingLifecycle,
+                ...outbox,
+                ...subscriberList,
+                ...cleanupProviders(config),
+            ],
+            exports: [
+                ...(outbox.length > 0 ? [OutboxStore] : []),
+                ...(subscriberList.length > 0 ? [KitSubscriber] : []),
+            ],
+        };
+    }
+};
+KitMessagingModule = KitMessagingModule_1 = __decorate([
+    Module({})
+], KitMessagingModule);
+export { KitMessagingModule };