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

package/dist/messaging/rabbit-connection.d.ts

@@ -0,0 +1,144 @@
+import type { ChannelWrapper, Options } from 'amqp-connection-manager';
+import type { ConfirmChannel, ConsumeMessage, Message, Options as AmqpOptions } from 'amqplib';
+/** Опции канала. */
+export interface ChannelOptions {
+    /** Имя канала (уникально в соединении). */
+    readonly name: string;
+    /** Канал с подтверждениями брокера. */
+    readonly confirm: boolean;
+    /** Таймаут подтверждения публикации, мс. */
+    readonly publishTimeout?: number;
+    /**
+     * Настройка канала после проверки exchange; вызывается при каждом (пере)подключении. `MessagingStartupError` —
+     * фатальная ошибка: канал не повторяется.
+     */
+    readonly setup?: (channel: ConfirmChannel) => Promise<void>;
+}
+/** Логгер фоновых операций /messaging: pino экземпляра (`service`, `replica` в `base`) или адаптер логгера Nest. */
+export interface MessagingLog {
+    /** Уровень debug. */
+    debug(fields: object, message: string): void;
+    /** Уровень info. */
+    info(fields: object, message: string): void;
+    /** Уровень warn. */
+    warn(fields: object, message: string): void;
+    /** Уровень error. */
+    error(fields: object, message: string): void;
+}
+/** Адаптер логгера Nest (приложение без KIT_LOGGER). */
+export declare function nestLog(context: string): MessagingLog;
+/** Опции соединения. */
+export interface RabbitConnectionOptions {
+    /** Логгер; по умолчанию — логгер Nest. */
+    readonly log?: MessagingLog;
+    /** RABBITMQ_URL. */
+    readonly url: string;
+    /** Пауза переподключения и повтора настройки канала, с (RABBITMQ_RETRY_SECONDS). */
+    readonly retrySeconds: number;
+    /** Общий срок обработчиков остановки, мс (handlersDeadlineMs). */
+    readonly deadlineMs: number;
+}
+/** Первый исход настройки канала после createChannel. */
+export type ChannelOutcome = {
+    readonly kind: 'ready';
+} | {
+    readonly kind: 'fatal';
+    readonly error: Error;
+} | {
+    readonly kind: 'failed';
+    readonly error: Error;
+};
+/** host:port адреса брокера, без учётных данных и vhost. */
+export declare function brokerEndpoint(url: string): string;
+/**
+ * Канал relay и подписчика: ссылка не меняется, когда RabbitConnection заменяет ChannelWrapper после сбоя настройки;
+ * потребители переносятся. Delivery tag действует только в канале amqplib, выдавшем доставку: каждое открытие —
+ * новое поколение; ack/nack прошлого поколения не отправляются (чужой tag дал бы 406 и закрыл новый канал).
+ */
+export declare class ManagedChannel {
+    readonly name: string;
+    private current;
+    private readonly onClose;
+    private readonly logger;
+    private readonly consumers;
+    private readonly deliveries;
+    private generation;
+    private closed;
+    constructor(name: string, current: ChannelWrapper, onClose: () => void, logger?: MessagingLog);
+    /** Открыт новый канал amqplib (в начале setup, до переподписки потребителей). */
+    markOpened(): void;
+    /** Доставка пришла через текущий канал amqplib (или не отслеживается). */
+    isCurrent(message: Message): boolean;
+    /** Публикация (на confirm-канале — Promise подтверждения). */
+    publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): Promise<boolean>;
+    /** Публикация в очередь. */
+    sendToQueue(queue: string, content: Buffer, options?: Options.Publish): Promise<boolean>;
+    /** Потребитель; переносится на следующий wrapper. */
+    consume(queue: string, onMessage: (msg: ConsumeMessage) => void, options?: AmqpOptions.Consume): Promise<unknown>;
+    /** ack; устаревшая доставка пропускается. */
+    ack(message: Message): void;
+    /** nack; устаревшая доставка пропускается. */
+    nack(message: Message, allUpTo?: boolean, requeue?: boolean): void;
+    /** Снять всех потребителей (basic.cancel): канал открыт — ack/nack доставок в работе ещё уходят. */
+    cancelConsumers(): Promise<void>;
+    /** Не дольше CHANNEL_CLOSE_TIMEOUT_MS: брокер молчит — канал бросается, его закроет закрытие соединения. */
+    close(): Promise<void>;
+    /** Новый wrapper вместо старого; false — канал уже закрыт владельцем. */
+    replace(next: ChannelWrapper): Promise<boolean>;
+    private isStale;
+}
+/** Соединение сервиса с брокером: одно на relay и подписчика, ленивое (`start`), переподключение и heartbeat. */
+export declare class RabbitConnection {
+    private readonly options;
+    private readonly logger;
+    private manager;
+    private starting;
+    private first;
+    private readonly endpoint;
+    private readonly channels;
+    private readonly readyListeners;
+    /** Ошибка exchange уже отправлена (сбрасывается, когда все каналы настроены). */
+    private exchangeMissingReported;
+    /** Каналы, чьё исключение обработчика готовности уже отправлено. */
+    private readonly readyFailureReported;
+    private retryTimer;
+    /** Остановка началась: таймер повтора больше не взводится. */
+    private stopped;
+    private stopDeadline;
+    constructor(options: RabbitConnectionOptions);
+    /** Загружает amqp-connection-manager и запускает соединение в фоне (без ожидания подключения); идемпотентный. */
+    start(): Promise<void>;
+    /** Первый исход подключения после `start`: `connected` или `failed`. */
+    firstAttempt(): Promise<'connected' | 'failed'>;
+    /** Соединение установлено. */
+    isConnected(): boolean;
+    /** Все созданные каналы настроены; без каналов — `true` (проба отражает только соединение). */
+    topologyReady(): boolean;
+    /** Канал с этим именем настроен. */
+    isChannelReady(name: string): boolean;
+    /** Подписка на каждую успешную настройку канала; возвращает отписку. */
+    onChannelReady(name: string, listener: () => void): () => void;
+    /**
+     * Общий срок остановки обмена с брокером: отсчёт — с первого вызова в beforeApplicationShutdown (relay,
+     * подписчик), resolve(false) через `deadlineMs`. Nest вызывает хуки по очереди — у каждого свой срок сложился бы.
+     */
+    shutdownDeadline(): Promise<false>;
+    /** Первый исход настройки канала: готов, фатальная ошибка `setup` или прочая ошибка стадии. */
+    channelOutcome(name: string): Promise<ChannelOutcome>;
+    /** Канал; `start()` должен быть завершён. */
+    createChannel(options: ChannelOptions): ManagedChannel;
+    /** Шаг 4 остановки: закрытие соединения не дольше CONNECTION_CLOSE_TIMEOUT_MS. */
+    onApplicationShutdown(): Promise<void>;
+    private open;
+    private openWrapper;
+    private runStage;
+    private markAllNotReady;
+    private onSetupDone;
+    /** Брокер закрыл настроенный канал: ChannelWrapper сам его не пересоздаст — заменяем, как после сбоя настройки. */
+    private onClosedByBroker;
+    private onSetupFailed;
+    private reportStageFailure;
+    /** Один таймер на соединение; повтор заменяет только каналы в ошибке (кроме фатальных). */
+    private scheduleRetry;
+    private retryFailedChannels;
+}

package/dist/messaging/rabbit-connection.js

@@ -0,0 +1,472 @@
+// RabbitConnection, ManagedChannel (prd.md §3.4 «соединение — основа O», AC-5.4, AC-5.11, AC-5.19). Эталон — O
+// rabbit-connection.ts (P — без cancelConsumers/stopped). Отличия: фабрика модуля вместо DI, amqp-connection-manager —
+// loadPeer в start() (без top-level await, AC-1.2), срок остановки из SHUTDOWN_TIMEOUT_MS (П9), captureError пакета,
+// фатальная ошибка настройки (MessagingStartupError, 406 TTL .retry) без повторов (AC-5.19, П8), topologyReady без
+// каналов — true, первый исход подключения и настройки канала (firstAttempt, channelOutcome). Exchange
+// verdeect.events — только checkExchange. В лог идёт только host:port: RABBITMQ_URL содержит пароль.
+import { setTimeout as sleep } from 'node:timers/promises';
+import { Logger } from '@nestjs/common';
+import { loadPeer } from '../internal/peer.js';
+import { sanitizeError } from '../observability/sanitize-error.js';
+import { captureError } from '../observability/sentry.js';
+import { MessagingStartupError } from './errors.js';
+import { CHANNEL_CLOSE_TIMEOUT_MS, CONNECTION_CLOSE_TIMEOUT_MS, EVENTS_EXCHANGE, HEARTBEAT_SECONDS, } from './topology.js';
+/** Адаптер логгера Nest (приложение без KIT_LOGGER). */
+export function nestLog(context) {
+    const logger = new Logger(context);
+    return {
+        debug: (fields, message) => logger.debug(fields, message),
+        info: (fields, message) => logger.log(fields, message),
+        warn: (fields, message) => logger.warn(fields, message),
+        error: (fields, message) => logger.error(fields, message),
+    };
+}
+/** host:port адреса брокера, без учётных данных и vhost. */
+export function brokerEndpoint(url) {
+    try {
+        const parsed = new URL(url);
+        // URL не хранит порт по умолчанию: amqps — 5671, amqp — 5672.
+        const port = parsed.port || (parsed.protocol === 'amqps:' ? '5671' : '5672');
+        return `${parsed.hostname}:${port}`;
+    }
+    catch {
+        return '(invalid url)';
+    }
+}
+/** true — операция завершилась (успехом или ошибкой) не позже срока. */
+async function settlesWithin(operation, timeoutMs) {
+    return Promise.race([
+        operation.then(() => true, () => true),
+        sleep(timeoutMs, false, { ref: false }),
+    ]);
+}
+/** Канал закрыт разрывом соединения: менеджер переподключится и повторит setup сам. */
+function isConnectionLoss(error) {
+    return error instanceof Error && error.name === 'IllegalOperationError';
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+/**
+ * Канал relay и подписчика: ссылка не меняется, когда RabbitConnection заменяет ChannelWrapper после сбоя настройки;
+ * потребители переносятся. Delivery tag действует только в канале amqplib, выдавшем доставку: каждое открытие —
+ * новое поколение; ack/nack прошлого поколения не отправляются (чужой tag дал бы 406 и закрыл новый канал).
+ */
+export class ManagedChannel {
+    name;
+    current;
+    onClose;
+    logger;
+    consumers = [];
+    deliveries = new WeakMap();
+    generation = 0;
+    closed = false;
+    constructor(name, current, onClose, logger = nestLog('ManagedChannel')) {
+        this.name = name;
+        this.current = current;
+        this.onClose = onClose;
+        this.logger = logger;
+    }
+    /** Открыт новый канал amqplib (в начале setup, до переподписки потребителей). */
+    markOpened() {
+        this.generation += 1;
+    }
+    /** Доставка пришла через текущий канал amqplib (или не отслеживается). */
+    isCurrent(message) {
+        const generation = this.deliveries.get(message);
+        return generation === undefined || generation === this.generation;
+    }
+    /** Публикация (на confirm-канале — Promise подтверждения). */
+    publish(exchange, routingKey, content, options) {
+        return this.current.publish(exchange, routingKey, content, options);
+    }
+    /** Публикация в очередь. */
+    sendToQueue(queue, content, options) {
+        return this.current.sendToQueue(queue, content, options);
+    }
+    /** Потребитель; переносится на следующий wrapper. */
+    consume(queue, onMessage, options) {
+        const tracked = (msg) => {
+            this.deliveries.set(msg, this.generation);
+            onMessage(msg);
+        };
+        this.consumers.push({ queue, onMessage: tracked, options });
+        return this.current.consume(queue, tracked, options);
+    }
+    /** ack; устаревшая доставка пропускается. */
+    ack(message) {
+        if (this.isStale(message, 'ack')) {
+            return;
+        }
+        this.current.ack(message);
+    }
+    /** nack; устаревшая доставка пропускается. */
+    nack(message, allUpTo, requeue) {
+        if (this.isStale(message, 'nack')) {
+            return;
+        }
+        this.current.nack(message, allUpTo, requeue);
+    }
+    /** Снять всех потребителей (basic.cancel): канал открыт — ack/nack доставок в работе ещё уходят. */
+    async cancelConsumers() {
+        this.consumers.length = 0;
+        await this.current.cancelAll().catch(() => undefined);
+    }
+    /** Не дольше CHANNEL_CLOSE_TIMEOUT_MS: брокер молчит — канал бросается, его закроет закрытие соединения. */
+    async close() {
+        this.closed = true;
+        this.onClose();
+        if (!(await settlesWithin(this.current.close(), CHANNEL_CLOSE_TIMEOUT_MS))) {
+            this.logger.warn({ channel: this.name, timeoutMs: CHANNEL_CLOSE_TIMEOUT_MS }, 'rabbitmq: брокер не ответил на закрытие канала, канал брошен');
+        }
+    }
+    /** Новый wrapper вместо старого; false — канал уже закрыт владельцем. */
+    async replace(next) {
+        if (this.closed) {
+            await next.close();
+            return false;
+        }
+        const previous = this.current;
+        this.current = next;
+        await previous.close().catch(() => undefined);
+        for (const consumer of this.consumers) {
+            // Без соединения consume только регистрирует потребителя: он подключится при connect.
+            void next
+                .consume(consumer.queue, consumer.onMessage, consumer.options)
+                .catch(() => undefined);
+        }
+        return true;
+    }
+    isStale(message, action) {
+        if (this.isCurrent(message)) {
+            return false;
+        }
+        this.logger.debug({ channel: this.name, action, generation: this.deliveries.get(message) }, 'rabbitmq: подтверждение устаревшей доставки пропущено');
+        return true;
+    }
+}
+/** Соединение сервиса с брокером: одно на relay и подписчика, ленивое (`start`), переподключение и heartbeat. */
+export class RabbitConnection {
+    options;
+    logger;
+    manager = null;
+    starting = null;
+    first = null;
+    endpoint;
+    channels = new Map();
+    readyListeners = new Map();
+    /** Ошибка exchange уже отправлена (сбрасывается, когда все каналы настроены). */
+    exchangeMissingReported = false;
+    /** Каналы, чьё исключение обработчика готовности уже отправлено. */
+    readyFailureReported = new Set();
+    retryTimer;
+    /** Остановка началась: таймер повтора больше не взводится. */
+    stopped = false;
+    stopDeadline = null;
+    constructor(options) {
+        this.options = options;
+        this.endpoint = brokerEndpoint(options.url);
+        this.logger = options.log ?? nestLog('RabbitConnection');
+    }
+    /** Загружает amqp-connection-manager и запускает соединение в фоне (без ожидания подключения); идемпотентный. */
+    start() {
+        this.starting ??= this.open();
+        return this.starting;
+    }
+    /** Первый исход подключения после `start`: `connected` или `failed`. */
+    firstAttempt() {
+        if (this.first === null) {
+            throw new Error('RabbitConnection: start() не вызван');
+        }
+        return this.first;
+    }
+    /** Соединение установлено. */
+    isConnected() {
+        return this.manager?.isConnected() ?? false;
+    }
+    /** Все созданные каналы настроены; без каналов — `true` (проба отражает только соединение). */
+    topologyReady() {
+        return [...this.channels.values()].every((state) => state.ready);
+    }
+    /** Канал с этим именем настроен. */
+    isChannelReady(name) {
+        return this.channels.get(name)?.ready ?? false;
+    }
+    /** Подписка на каждую успешную настройку канала; возвращает отписку. */
+    onChannelReady(name, listener) {
+        let listeners = this.readyListeners.get(name);
+        if (listeners === undefined) {
+            listeners = new Set();
+            this.readyListeners.set(name, listeners);
+        }
+        listeners.add(listener);
+        return () => {
+            this.readyListeners.get(name)?.delete(listener);
+        };
+    }
+    /**
+     * Общий срок остановки обмена с брокером: отсчёт — с первого вызова в beforeApplicationShutdown (relay,
+     * подписчик), resolve(false) через `deadlineMs`. Nest вызывает хуки по очереди — у каждого свой срок сложился бы.
+     */
+    shutdownDeadline() {
+        this.stopDeadline ??= sleep(this.options.deadlineMs, false, { ref: false });
+        return this.stopDeadline;
+    }
+    /** Первый исход настройки канала: готов, фатальная ошибка `setup` или прочая ошибка стадии. */
+    channelOutcome(name) {
+        const state = this.channels.get(name);
+        if (state === undefined) {
+            throw new Error(`RabbitConnection: канала ${name} нет`);
+        }
+        return state.outcome;
+    }
+    /** Канал; `start()` должен быть завершён. */
+    createChannel(options) {
+        const name = options.name;
+        let settle = () => undefined;
+        const outcome = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const state = {
+            options,
+            channel: undefined,
+            ready: false,
+            fatal: false,
+            raw: null,
+            lastBrokerError: null,
+            outcome,
+            settle: (value) => {
+                settle(value);
+                state.settle = () => undefined;
+            },
+        };
+        this.channels.set(name, state);
+        const channel = new ManagedChannel(name, this.openWrapper(options), () => {
+            this.channels.delete(name);
+        }, this.logger);
+        state.channel = channel;
+        return channel;
+    }
+    /** Шаг 4 остановки: закрытие соединения не дольше CONNECTION_CLOSE_TIMEOUT_MS. */
+    async onApplicationShutdown() {
+        this.stopped = true;
+        clearTimeout(this.retryTimer);
+        this.retryTimer = undefined;
+        this.readyListeners.clear();
+        this.readyFailureReported.clear();
+        await this.starting?.catch(() => undefined);
+        const manager = this.manager;
+        if (manager === null) {
+            return;
+        }
+        this.manager = null;
+        this.channels.clear();
+        if (!(await settlesWithin(manager.close(), CONNECTION_CLOSE_TIMEOUT_MS))) {
+            this.logger.warn({ broker: this.endpoint, timeoutMs: CONNECTION_CLOSE_TIMEOUT_MS }, 'rabbitmq: брокер не ответил на закрытие соединения, соединение брошено');
+            return;
+        }
+        this.logger.info({ broker: this.endpoint }, 'rabbitmq: соединение закрыто');
+    }
+    async open() {
+        const acm = await loadPeer('amqp-connection-manager', 'messaging');
+        if (this.stopped) {
+            return;
+        }
+        const manager = acm.connect([this.options.url], {
+            heartbeatIntervalInSeconds: HEARTBEAT_SECONDS,
+            reconnectTimeInSeconds: this.options.retrySeconds,
+        });
+        this.first = new Promise((resolve) => {
+            manager.once('connect', () => resolve('connected'));
+            manager.once('connectFailed', () => resolve('failed'));
+        });
+        manager.on('connect', () => {
+            this.logger.info({ broker: this.endpoint }, 'rabbitmq: соединение установлено');
+        });
+        manager.on('disconnect', ({ err }) => {
+            this.markAllNotReady();
+            this.logger.warn({ broker: this.endpoint, err: sanitizeError(err) }, 'rabbitmq: соединение потеряно');
+        });
+        manager.on('connectFailed', ({ err }) => {
+            this.logger.debug({ broker: this.endpoint, error: err.message }, 'rabbitmq: попытка подключения не удалась');
+        });
+        // Без обработчика 'error' EventEmitter бросил бы исключение процессу.
+        manager.on('error', (err) => {
+            this.logger.warn({ broker: this.endpoint, err: sanitizeError(err) }, 'rabbitmq: ошибка соединения');
+        });
+        this.manager = manager;
+    }
+    openWrapper(options) {
+        if (this.manager === null) {
+            throw new Error('RabbitConnection: createChannel до завершения start()');
+        }
+        const name = options.name;
+        const channelOptions = {
+            name,
+            confirm: options.confirm,
+            json: false,
+            setup: async (channel) => {
+                this.channels.get(name)?.channel.markOpened();
+                // Брокер закрывает канал так: 'error' (код канала), затем 'close'. Разрыв соединения, замена канала и
+                // остановка дают только 'close'.
+                let closedByBroker = false;
+                channel.on('error', (err) => {
+                    closedByBroker = true;
+                    const state = this.channels.get(name);
+                    if (state !== undefined) {
+                        state.lastBrokerError = err;
+                    }
+                    this.logger.debug({ channel: name, error: err.message }, 'rabbitmq: канал закрыт с ошибкой');
+                });
+                channel.on('close', () => {
+                    if (closedByBroker) {
+                        this.onClosedByBroker(name, channel);
+                    }
+                });
+                await this.runStage(name, channel, 'exchange', () => channel.checkExchange(EVENTS_EXCHANGE));
+                await this.runStage(name, channel, 'setup', () => options.setup ? options.setup(channel) : Promise.resolve());
+                await this.runStage(name, channel, 'ready', () => {
+                    this.onSetupDone(name, channel);
+                    return Promise.resolve();
+                });
+            },
+        };
+        if (options.publishTimeout !== undefined) {
+            channelOptions.publishTimeout = options.publishTimeout;
+        }
+        const wrapper = this.manager.createChannel(channelOptions);
+        wrapper.on('error', (err, info) => {
+            this.logger.debug({ channel: info.name, error: err instanceof Error ? err.message : String(err) }, 'rabbitmq: ошибка канала');
+        });
+        return wrapper;
+    }
+    async runStage(name, channel, stage, work) {
+        try {
+            await work();
+        }
+        catch (error) {
+            this.onSetupFailed(name, stage, error);
+            // Ошибка брокера уже закрыла канал; ошибка кода — нет: закрываем, чтобы повтор открыл новый.
+            await channel.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    markAllNotReady() {
+        for (const state of this.channels.values()) {
+            state.ready = false;
+            state.raw = null;
+        }
+    }
+    onSetupDone(name, channel) {
+        const state = this.channels.get(name);
+        if (state !== undefined) {
+            state.ready = true;
+            state.raw = channel;
+        }
+        try {
+            // Синхронно: до отката готовности при исключении никто не увидит канал готовым.
+            for (const listener of this.readyListeners.get(name) ?? []) {
+                listener();
+            }
+        }
+        catch (error) {
+            if (state !== undefined) {
+                state.ready = false;
+                state.raw = null;
+            }
+            throw error;
+        }
+        state?.settle({ kind: 'ready' });
+        this.readyFailureReported.delete(name);
+        this.logger.info({ channel: name }, 'rabbitmq: канал готов');
+        if (!this.topologyReady()) {
+            return;
+        }
+        this.exchangeMissingReported = false;
+        clearTimeout(this.retryTimer);
+        this.retryTimer = undefined;
+    }
+    /** Брокер закрыл настроенный канал: ChannelWrapper сам его не пересоздаст — заменяем, как после сбоя настройки. */
+    onClosedByBroker(name, channel) {
+        const state = this.channels.get(name);
+        if (state === undefined || state.raw !== channel || this.manager === null) {
+            return;
+        }
+        state.raw = null;
+        state.ready = false;
+        this.logger.warn({ channel: name }, 'rabbitmq: канал закрыт брокером');
+        this.scheduleRetry();
+    }
+    onSetupFailed(name, stage, error) {
+        const state = this.channels.get(name);
+        if (state !== undefined) {
+            state.ready = false;
+        }
+        if (isConnectionLoss(error)) {
+            this.logger.debug({ channel: name }, 'rabbitmq: канал закрыт разрывом соединения');
+            return;
+        }
+        const safeError = sanitizeError(error);
+        if (error instanceof MessagingStartupError) {
+            // Фатально (406 TTL .retry): повтор не изменит объявление очереди брокера (AC-5.19, П8).
+            if (state !== undefined) {
+                state.fatal = true;
+                state.settle({ kind: 'fatal', error });
+            }
+            this.logger.error({ channel: name, code: error.startupCode, err: safeError }, 'rabbitmq: фатальная ошибка настройки канала, повторов не будет');
+            captureError(error);
+            return;
+        }
+        state?.settle({ kind: 'failed', error: state.lastBrokerError ?? asError(error) });
+        this.reportStageFailure(name, stage, safeError);
+        this.scheduleRetry();
+    }
+    reportStageFailure(name, stage, safeError) {
+        if (stage !== 'exchange') {
+            this.logger.warn({ channel: name, stage, err: safeError }, 'rabbitmq: сбой настройки канала');
+            if (stage === 'ready' && !this.readyFailureReported.has(name)) {
+                // Ошибка кода, не брокера: одно событие GlitchTip на серию повторов канала.
+                captureError(safeError);
+                this.readyFailureReported.add(name);
+            }
+            return;
+        }
+        if (this.exchangeMissingReported) {
+            this.logger.warn({ channel: name, exchange: EVENTS_EXCHANGE }, 'rabbitmq: exchange verdeect.events всё ещё отсутствует');
+            return;
+        }
+        // Exchange объявляет definitions.json инфраструктуры до запуска сервиса (§3.4).
+        this.logger.error({ channel: name, exchange: EVENTS_EXCHANGE, err: safeError }, 'rabbitmq: exchange verdeect.events отсутствует');
+        captureError(safeError);
+        this.exchangeMissingReported = true;
+    }
+    /** Один таймер на соединение; повтор заменяет только каналы в ошибке (кроме фатальных). */
+    scheduleRetry() {
+        if (this.stopped || this.retryTimer !== undefined) {
+            return;
+        }
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = undefined;
+            void this.retryFailedChannels();
+        }, this.options.retrySeconds * 1000);
+        this.retryTimer.unref();
+    }
+    async retryFailedChannels() {
+        if (this.stopped || this.manager === null || !this.manager.isConnected()) {
+            // Нет соединения: после переподключения менеджер сам повторит setup всех каналов.
+            return;
+        }
+        for (const [name, state] of this.channels) {
+            if (state.ready || state.fatal) {
+                continue;
+            }
+            this.logger.debug({ channel: name }, 'rabbitmq: канал открывается заново');
+            try {
+                await state.channel.replace(this.openWrapper(state.options));
+            }
+            catch (error) {
+                this.logger.warn({ channel: name, err: sanitizeError(error) }, 'rabbitmq: открыть канал заново не удалось');
+            }
+        }
+    }
+}

package/dist/messaging/redelivery.d.ts

@@ -0,0 +1,6 @@
+/** Решение после сбоя текущей доставки. */
+export type RedeliveryDecision = 'retry' | 'dlq';
+/** Сколько раз сообщение уходило из `queue` с `reason: rejected` (`x-death`); нет заголовка — 0. */
+export declare function retryCount(headers: Record<string, unknown> | undefined, queue: string): number;
+/** Повторить, пока повторов меньше MAX_RETRIES, иначе — DLQ. */
+export declare function decideRedelivery(headers: Record<string, unknown> | undefined, queue: string): RedeliveryDecision;

package/dist/messaging/redelivery.js

@@ -0,0 +1,17 @@
+// Решение о повторной доставке (prd.md §3.4 «5 повторов по x-death», AC-5.7): сколько раз сообщение уже отклонялось из
+// основной очереди и прошло <svc>.retry. Эталон — O redelivery.ts; из B — очередь параметром.
+import { MAX_RETRIES } from './topology.js';
+/** Сколько раз сообщение уходило из `queue` с `reason: rejected` (`x-death`); нет заголовка — 0. */
+export function retryCount(headers, queue) {
+    const deaths = headers?.['x-death'];
+    if (!Array.isArray(deaths)) {
+        return 0;
+    }
+    const rejected = deaths.find((entry) => entry.queue === queue && entry.reason === 'rejected');
+    const count = Number(rejected?.count ?? 0);
+    return Number.isFinite(count) ? count : 0;
+}
+/** Повторить, пока повторов меньше MAX_RETRIES, иначе — DLQ. */
+export function decideRedelivery(headers, queue) {
+    return retryCount(headers, queue) < MAX_RETRIES ? 'retry' : 'dlq';
+}