itd-api 0.7.2 → 0.9.0

package/dist/shared/{websocket-C_eI4H2o.cjs → events-FZfnEez0.cjs}

@@ -1,6 +1,6 @@
-const require_url = require("./url-BaMCQpYH.cjs");
-const require_errors = require("./errors-DfU8M5eS.cjs");
-const require_cookies = require("./cookies-DZwFq6kr.cjs");
+const require_url = require("./url-Bsb3xE5U.cjs");
+const require_errors = require("./errors-BmP3TKoW.cjs");
+const require_redact = require("./redact-BP00URmQ.cjs");
 //#region src/core/emitter.ts
 /**
 * Минимальный типизированный источник событий.
@@ -26,7 +26,7 @@ var Emitter = class {
 	*
 	* @example
 	* ```ts
-	* const off = realtime.on('notification', (event) => console.log(event));
+	* const off = events.on('notification', (event) => console.log(event));
 	* off();
 	* ```
 	*/
@@ -84,33 +84,33 @@ function reportListenerError(logger, scope, error) {
 	else console.error(`[itd-api] ${message}`, error);
 }
 //#endregion
-//#region src/realtime/middleware.ts
-const REALTIME_MIDDLEWARE_SNAPSHOT = Symbol("itd-api.realtime.middlewareSnapshot");
+//#region src/events/middleware.ts
+const EVENT_MIDDLEWARE_SNAPSHOT = Symbol("itd-api.events.middlewareSnapshot");
 /** @internal */
-function captureRealtimeMiddleware(middleware) {
-	const capture = middleware[REALTIME_MIDDLEWARE_SNAPSHOT];
+function captureEventMiddleware(middleware) {
+	const capture = middleware[EVENT_MIDDLEWARE_SNAPSHOT];
 	if (!capture) return middleware;
 	const snapshot = capture();
 	if (typeof snapshot !== "function") throw new TypeError("Снимок промежуточного обработчика должен быть функцией");
 	return snapshot;
 }
 /** @internal */
-function withRealtimeMiddlewareSnapshot(middleware, capture) {
-	Object.defineProperty(middleware, REALTIME_MIDDLEWARE_SNAPSHOT, { value: capture });
+function withEventMiddlewareSnapshot(middleware, capture) {
+	Object.defineProperty(middleware, EVENT_MIDDLEWARE_SNAPSHOT, { value: capture });
 	return middleware;
 }
 /** Создаёт отложенный промежуточный обработчик для объекта. @internal */
-function deferRealtimeMiddleware(source) {
+function deferEventMiddleware(source) {
 	const capture = () => {
 		const middleware = source.middleware();
-		if (typeof middleware !== "function") throw new require_errors.ItdConfigError("realtime middleware() должен возвращать функцию обработки");
-		return captureRealtimeMiddleware(middleware);
+		if (typeof middleware !== "function") throw new require_errors.ItdConfigError("events middleware() должен возвращать функцию обработки");
+		return captureEventMiddleware(middleware);
 	};
 	const deferred = (context, next) => capture()(context, next);
-	return withRealtimeMiddlewareSnapshot(deferred, capture);
+	return withEventMiddlewareSnapshot(deferred, capture);
 }
 /** Выполняет промежуточные обработчики по порядку и запрещает повторный вызов `next()`. */
-async function runRealtimeMiddleware(middleware, context, terminal) {
+async function runEventMiddleware(middleware, context, terminal) {
 	let lastIndex = -1;
 	const dispatch = async (index) => {
 		if (index <= lastIndex) throw new Error("next() в промежуточном обработчике вызван повторно");
@@ -148,7 +148,7 @@ async function runRealtimeMiddleware(middleware, context, terminal) {
 	await dispatch(0);
 }
 /** Планирует нормализованные обновления и отслеживает незавершённые обработчики. */
-var RealtimeDispatcher = class {
+var EventDispatcher = class {
 	#options;
 	#hooks;
 	#middleware = [];
@@ -189,7 +189,7 @@ var RealtimeDispatcher = class {
 		let middleware;
 		try {
 			keys = this.#keysFor(context);
-			middleware = this.#middleware.map(captureRealtimeMiddleware);
+			middleware = this.#middleware.map(captureEventMiddleware);
 		} catch (error) {
 			this.#hooks.middlewareError(error, context);
 			return;
@@ -246,7 +246,7 @@ var RealtimeDispatcher = class {
 	}
 	async #run(work) {
 		try {
-			await runRealtimeMiddleware(work.middleware, work.context, async () => {
+			await runEventMiddleware(work.middleware, work.context, async () => {
 				for (const { predicate, handler } of work.handlers) try {
 					if (predicate(work.context)) await handler(work.context);
 				} catch (error) {
@@ -269,7 +269,7 @@ var RealtimeDispatcher = class {
 	}
 };
 //#endregion
-//#region src/realtime/reconnect.ts
+//#region src/events/reconnect.ts
 /**
 * Паузы перед попытками переподключения, мс.
 *
@@ -301,7 +301,7 @@ function reconnectDelay(attempt, options = {}, random = Math.random) {
 	return Math.max(0, Math.round(base + spread));
 }
 //#endregion
-//#region src/realtime/transports/transport.ts
+//#region src/events/transports/transport.ts
 /** Ошибка, по которой видно, что сервер отверг авторизацию потока. */
 var UnauthorizedStreamError = class extends Error {
 	constructor() {
@@ -310,113 +310,56 @@ var UnauthorizedStreamError = class extends Error {
 	}
 };
 //#endregion
-//#region src/realtime/updates.ts
-/** Типы нормализованных обновлений потока. */
-const RealtimeUpdateType = Object.freeze({
-	Notification: "notification",
-	UnreadCount: "unreadCount",
-	Unknown: "unknown"
-});
-/** Источники нормализованных обновлений потока. */
-const RealtimeUpdateOrigin = Object.freeze({
-	Stream: "stream",
-	Sync: "sync"
-});
-/** Проверяет форму фильтра уведомлений. */
-function validateNotificationSelector(selector) {
-	if (typeof selector === "string") {
-		if (selector.length === 0) throw new require_errors.ItdConfigError("Тип уведомления не должен быть пустым");
-		return;
-	}
-	if (Array.isArray(selector)) {
-		if (selector.length === 0 || selector.some((type) => typeof type !== "string" || !type)) throw new require_errors.ItdConfigError("Список типов уведомлений должен содержать непустые строки");
-		return;
-	}
-	if (typeof selector !== "object" || selector === null) throw new require_errors.ItdConfigError("Фильтр уведомлений должен быть строкой, списком или объектом");
-	const filter = selector;
-	if (filter.type !== void 0) validateNotificationSelector(filter.type);
-	if (filter.actorId !== void 0 && typeof filter.actorId !== "string") throw new require_errors.ItdConfigError("Фильтр уведомлений: actorId должен быть строкой");
-	for (const field of ["entityId", "parentEntityId"]) {
-		const value = filter[field];
-		if (value !== void 0 && value !== null && typeof value !== "string") throw new require_errors.ItdConfigError(`Фильтр уведомлений: ${field} должен быть строкой или null`);
-	}
-	if (filter.predicate !== void 0 && typeof filter.predicate !== "function") throw new require_errors.ItdConfigError("Фильтр уведомлений: predicate должен быть функцией");
-}
-/** Преобразует транспортный кадр в одно логическое обновление. */
-function readRealtimeUpdate(event) {
-	if (event.name === "notification") return {
-		type: RealtimeUpdateType.Notification,
-		data: require_url.readNotificationEvent(event.data)
-	};
-	if (event.name === "unread_count") {
-		const count = require_url.readUnreadCountEvent(event.data);
-		return count === void 0 ? void 0 : {
-			type: RealtimeUpdateType.UnreadCount,
-			data: count
-		};
-	}
-	return {
-		type: RealtimeUpdateType.Unknown,
-		name: event.name,
-		data: event.data
-	};
-}
-/** Проверяет объектный или краткий фильтр уведомления. */
-function matchesNotification(context, selector) {
-	const notification = context.update.data.notification;
-	if (typeof selector === "string") return notification.type === selector;
-	if (Array.isArray(selector)) return selector.includes(notification.type);
-	const filter = selector;
-	const types = filter.type === void 0 ? void 0 : [filter.type].flat();
-	if (types && !types.includes(notification.type)) return false;
-	if (filter.actorId !== void 0 && !notification.actors.some(({ id }) => id === filter.actorId)) return false;
-	if (filter.entityId !== void 0 && notification.entityId !== filter.entityId) return false;
-	if (filter.parentEntityId !== void 0 && notification.parentEntityId !== filter.parentEntityId) return false;
-	return filter.predicate?.(context) ?? true;
+//#region src/events/engine.ts
+const EVENT_CHANNEL_GIVEUP_HOOKS = /* @__PURE__ */ new WeakMap();
+/** Регистрирует обработчик окончательной остановки канала. @internal */
+function setEventChannelGiveUpHook(channel, hook) {
+	EVENT_CHANNEL_GIVEUP_HOOKS.set(channel, hook);
 }
-/** Сужает произвольный контекст потока до контекста уведомления. */
-function isNotificationContext(context) {
-	return context.update.type === RealtimeUpdateType.Notification;
-}
-//#endregion
-//#region src/realtime/engine.ts
 /** Проверяет настройки общей механики потока. */
-function validateRealtimeEngineOptions(options) {
+function resolveEventChannelOptions(options = {}) {
 	const positiveInteger = (value, name) => {
 		if (value === void 0) return;
-		if (!Number.isInteger(value) || value < 0) throw new require_errors.ItdConfigError(`realtime.${name} должен быть целым неотрицательным числом, получено: ${value}`);
+		if (!Number.isInteger(value) || value < 0) throw new require_errors.ItdConfigError(`events.${name} должен быть целым неотрицательным числом, получено: ${value}`);
 	};
 	const duration = (value, name) => {
-		if (!Number.isFinite(value) || value < 0) throw new require_errors.ItdConfigError(`realtime.${name} должен быть числом не меньше 0, получено: ${value}`);
+		if (!Number.isFinite(value) || value < 0) throw new require_errors.ItdConfigError(`events.${name} должен быть числом не меньше 0, получено: ${value}`);
 	};
 	positiveInteger(options.maxAttempts, "maxAttempts");
 	positiveInteger(options.concurrency, "concurrency");
-	if (options.concurrency === 0) throw new require_errors.ItdConfigError("realtime.concurrency должен быть больше нуля");
-	if (options.jitter !== void 0 && !(options.jitter >= 0 && options.jitter <= 1)) throw new require_errors.ItdConfigError(`realtime.jitter должен быть в диапазоне 0…1, получено: ${options.jitter}`);
+	if (options.concurrency === 0) throw new require_errors.ItdConfigError("events.concurrency должен быть больше нуля");
+	if (options.jitter !== void 0 && !(options.jitter >= 0 && options.jitter <= 1)) throw new require_errors.ItdConfigError(`events.jitter должен быть в диапазоне 0…1, получено: ${options.jitter}`);
 	if (options.backoff !== void 0) {
-		if (!Array.isArray(options.backoff) || options.backoff.length === 0) throw new require_errors.ItdConfigError("realtime.backoff должен быть непустым списком пауз");
+		if (!Array.isArray(options.backoff) || options.backoff.length === 0) throw new require_errors.ItdConfigError("events.backoff должен быть непустым списком пауз");
 		for (const delay of options.backoff) duration(delay, "backoff");
 	}
-	if (options.sequentialize !== void 0 && typeof options.sequentialize !== "function") throw new require_errors.ItdConfigError("realtime.sequentialize должен быть функцией");
+	if (options.sequentialize !== void 0 && typeof options.sequentialize !== "function") throw new require_errors.ItdConfigError("events.sequentialize должен быть функцией");
+	return Object.freeze({
+		...options,
+		...options.backoff ? { backoff: Object.freeze([...options.backoff]) } : {}
+	});
 }
 /**
-* Общая механика потока событий: соединение, переподключение с backoff, обновление
+* Общая механика потока событий: соединение, переподключение с задержкой, обновление
 * токена, реакция на среду, статусы и очередь обработчиков.
 *
 * Ничего не знает о домене: что считать обновлением, как собрать контекст и кому его
-* доставить, решают {@link RealtimeEngineDeps}. Поэтому один и тот же движок несёт
+* доставить, решают {@link EventChannelDeps}. Поэтому один и тот же движок несёт
 * и поток уведомлений, и любой другой.
 *
-* @internal
 */
-var RealtimeEngine = class {
+var EventChannel = class {
 	#deps;
 	#options;
 	#dispatcher;
 	#emitter;
 	#clock;
 	#maxAttempts;
-	#controller;
+	/** Остановленные сессии, чьи подготовка или транспорт ещё освобождают ресурсы. */
+	#retiredSessions = /* @__PURE__ */ new Set();
+	/** Фоновые операции канала вне сессии, например обновление авторизации. */
+	#backgroundTasks = /* @__PURE__ */ new Set();
+	#session;
 	/**
 	* Хочет ли вызывающий код, чтобы соединение было живо.
 	*
@@ -426,20 +369,20 @@ var RealtimeEngine = class {
 	* и соединение поднялось бы уже после отмены.
 	*/
 	#wanted = false;
-	#status = require_url.RealtimeStatus.Disconnected;
+	#status = require_url.EventChannelStatus.Disconnected;
 	#attempt = 0;
 	#generation = 0;
 	#starting;
 	#cancelTimer;
 	#detachEnvironment;
 	constructor(deps, options = {}) {
-		validateRealtimeEngineOptions(options);
+		options = resolveEventChannelOptions(options);
 		this.#deps = deps;
 		this.#options = options;
 		this.#clock = deps.clock ?? require_url.systemClock;
 		this.#maxAttempts = options.maxAttempts ?? 15;
-		this.#emitter = new Emitter((error) => reportListenerError(deps.logger, "realtime", error));
-		this.#dispatcher = new RealtimeDispatcher({
+		this.#emitter = new Emitter((error) => reportListenerError(deps.logger, "событий", error));
+		this.#dispatcher = new EventDispatcher({
 			concurrency: options.concurrency ?? 1,
 			...options.sequentialize ? { sequentialize: options.sequentialize } : {}
 		}, {
@@ -476,8 +419,8 @@ var RealtimeEngine = class {
 	/** Добавляет промежуточный обработчик. @returns функция его удаления */
 	use(middleware) {
 		if (typeof middleware === "function") return this.#dispatcher.use(middleware);
-		if (typeof middleware !== "object" || middleware === null || typeof middleware.middleware !== "function") throw new require_errors.ItdConfigError("realtime.use() принимает функцию обработки или объект с middleware()");
-		return this.#dispatcher.use(deferRealtimeMiddleware(middleware));
+		if (typeof middleware !== "object" || middleware === null || typeof middleware.middleware !== "function") throw new require_errors.ItdConfigError("events.use() принимает функцию обработки или объект с middleware()");
+		return this.#dispatcher.use(deferEventMiddleware(middleware));
 	}
 	/** Подписывает обработчик обновлений, подходящих под условие. */
 	onUpdate(predicate, handler) {
@@ -490,17 +433,17 @@ var RealtimeEngine = class {
 	* сразу после запуска: соединение живёт в фоне.
 	*/
 	async connect() {
-		if (this.#wanted) return;
+		this.#deps.connectGuard?.();
+		if (this.#wanted) return this.#starting;
 		this.#wanted = true;
-		const generation = ++this.#generation;
-		const starting = {};
-		this.#starting = starting;
-		this.#deps.onConnect?.();
 		this.#attachEnvironmentListeners();
-		await this.#sync("initial", generation, starting);
-		if (this.#starting !== starting) return;
-		this.#starting = void 0;
-		if (this.#isCurrentGeneration(generation)) this.#run(generation);
+		const starting = this.#startAttempt("initial");
+		this.#starting = starting;
+		try {
+			await starting;
+		} finally {
+			if (this.#starting === starting) this.#starting = void 0;
+		}
 	}
 	/** Закрывает соединение и отменяет запланированные попытки. */
 	disconnect() {
@@ -513,16 +456,27 @@ var RealtimeEngine = class {
 		}
 		this.#detachEnvironment?.();
 		this.#detachEnvironment = void 0;
-		this.#controller?.abort();
-		this.#controller = void 0;
+		this.#abortSession(new require_errors.ItdAbortError("Событийное соединение остановлено"));
 		this.#attempt = 0;
 		this.#dispatcher.clearPending();
-		this.#setStatus(require_url.RealtimeStatus.Disconnected);
-		this.#deps.onClose?.();
+		this.#setStatus(require_url.EventChannelStatus.Disconnected);
 	}
-	/** Ждёт завершения всех принятых обновлений. */
-	drain() {
-		return this.#dispatcher.drain();
+	/**
+	* Ждёт обработчики и полное завершение уже остановленной сессии соединения.
+	*
+	* Работающий транспорт намеренно не блокирует `drain()`: сначала владелец вызывает
+	* {@link disconnect}, который синхронно отменяет сессию. После этого `drain()` ждёт
+	* завершения подготовки, транспорта и фонового обновления авторизации, включая их
+	* асинхронное освобождение ресурсов.
+	*/
+	async drain() {
+		const sessions = [...this.#retiredSessions];
+		const background = [...this.#backgroundTasks];
+		await Promise.all([
+			this.#dispatcher.drain(),
+			...sessions,
+			...background
+		]);
 	}
 	/** Пропускает актуальное обновление через цепочку обработчиков. */
 	#dispatch(update, raw, origin) {
@@ -534,70 +488,102 @@ var RealtimeEngine = class {
 	* когда обработчики разберут очередь.
 	*/
 	#handleOverflow() {
-		const controller = this.#controller;
-		if (!this.#wanted || !controller) return;
-		const generation = this.#generation;
-		controller.abort();
-		this.#controller = void 0;
-		this.#setStatus(require_url.RealtimeStatus.Error);
+		const session = this.#session;
+		if (!this.#wanted || !session) return;
+		const generation = session.generation;
+		this.#abortSession(new require_errors.ItdAbortError("Очередь событий переполнена"));
+		this.#setStatus(require_url.EventChannelStatus.Error);
 		const error = /* @__PURE__ */ new Error("Обработчики не успевают за потоком: очередь обновлений переполнена");
 		this.#dispatcher.drain().then(() => {
-			if (this.#isCurrentGeneration(generation) && !this.#controller) this.#scheduleReconnect(error);
+			if (this.#isCurrentGeneration(generation) && !this.#session) this.#scheduleReconnect(error);
 		});
 	}
-	/** Выполняет доменную синхронизацию, не роняя подключение из-за её ошибки. */
-	async #sync(reason, generation, starting) {
-		if (!this.#deps.sync) return;
+	/** Создаёт новую попытку соединения и выполняет её подготовку. */
+	async #startAttempt(reason) {
+		if (!this.#wanted) return;
+		this.#abortSession(new require_errors.ItdAbortError("Событийное соединение заменено новой попыткой"));
+		const session = this.#createSession(++this.#generation);
+		this.#session = session;
 		try {
-			await this.#deps.sync(reason, (update) => {
-				if (this.#starting !== starting || !this.#isCurrentGeneration(generation)) return;
-				this.#dispatch(update, void 0, RealtimeUpdateOrigin.Sync);
-			});
+			if (this.#deps.openBeforeInitialize) {
+				this.#runTransport(session);
+				await session.handle.opened;
+				await this.#initialize(reason, session);
+				this.#openGate(session);
+			} else {
+				await this.#initialize(reason, session);
+				this.#openGate(session);
+				if (this.#isCurrentSession(session)) this.#runTransport(session);
+			}
+		} catch (error) {
+			if (!this.#isCurrentSession(session)) return;
+			this.#abortSession(error);
+			if (reason === "initial" && this.#deps.initializationRequired) {
+				this.#wanted = false;
+				this.#detachEnvironment?.();
+				this.#detachEnvironment = void 0;
+				this.#setStatus(require_url.EventChannelStatus.Disconnected);
+				throw error;
+			}
+			this.#handleFailure(error);
+		}
+	}
+	async #initialize(reason, session) {
+		const initialize = this.#deps.initialize;
+		if (!initialize) return;
+		const task = this.#runSessionTask(session, () => initialize(reason, session.handle));
+		try {
+			await task;
 		} catch (error) {
+			if (this.#deps.initializationRequired) throw error;
 			this.#deps.logger?.debug(`не удалось синхронизировать поток (${reason})`, error);
 		}
 	}
-	/** Запускает попытку подключения; повторы планирует сам. */
-	#run(generation = this.#generation) {
-		if (!this.#isCurrentGeneration(generation)) return;
-		this.#controller?.abort();
-		const controller = new AbortController();
-		this.#controller = controller;
-		this.#setStatus(require_url.RealtimeStatus.Connecting);
-		this.#deps.transport.connect({
-			baseUrl: this.#deps.baseUrl,
-			authorize: this.#deps.authorize,
-			fetch: this.#deps.fetch,
-			request: this.#deps.request,
-			baseHeaders: this.#deps.baseHeaders,
-			getToken: this.#deps.getToken,
-			signal: controller.signal,
+	/** Запускает транспорт одной попытки. */
+	#runTransport(session) {
+		if (!this.#isCurrentSession(session)) return;
+		this.#setStatus(require_url.EventChannelStatus.Connecting);
+		this.#runSessionTask(session, () => Promise.resolve(this.#deps.transport.connect({
+			...this.#deps.connection,
+			signal: session.controller.signal,
 			onOpen: () => {
-				if (!this.#isCurrentConnection(controller, generation)) return;
+				if (!this.#isCurrentSession(session)) return;
 				this.#attempt = 0;
-				this.#setStatus(require_url.RealtimeStatus.Connected);
+				session.resolveOpened();
+				this.#setStatus(require_url.EventChannelStatus.Connected);
 			},
 			onEvent: (event) => {
-				if (this.#isCurrentConnection(controller, generation)) this.#handleEvent(event);
+				if (this.#isCurrentSession(session)) this.#handleEvent(session, event);
 			},
 			onParseError: (error, raw) => {
-				if (this.#isCurrentConnection(controller, generation)) this.#emitEngine("parseError", {
+				if (this.#isCurrentSession(session)) this.#emitEngine("parseError", {
 					error,
 					raw
 				});
 			}
-		}).then(() => {
-			if (this.#isCurrentConnection(controller, generation)) this.#handleFailure(/* @__PURE__ */ new Error("Соединение с потоком событий закрыто"));
+		})).then(() => {
+			if (this.#isCurrentSession(session)) this.#handleFailure(/* @__PURE__ */ new Error("Соединение с потоком событий закрыто"));
 		}, (error) => {
-			if (this.#isCurrentConnection(controller, generation)) this.#handleFailure(error);
-		});
+			if (this.#isCurrentSession(session)) this.#handleFailure(error);
+		}));
 	}
-	#handleEvent(event) {
+	#handleEvent(session, event) {
 		if (!this.#wanted) return;
 		this.#emitEngine("message", event);
+		if (!session.ready && (this.#deps.bufferFrame?.(event) ?? true)) {
+			if (session.buffer.length >= 256) {
+				this.#handleOverflow();
+				return;
+			}
+			session.buffer.push(event);
+			return;
+		}
+		this.#dispatchFrame(event);
+	}
+	#dispatchFrame(event) {
 		if (this.#deps.handleFrame?.(event)) return;
 		const update = this.#deps.readUpdate(event);
-		if (update !== void 0) this.#dispatch(update, event, RealtimeUpdateOrigin.Stream);
+		if (update !== void 0) this.#dispatch(update, event, this.#deps.streamOrigin);
 	}
 	#reportDispatchError(event, error, context) {
 		if (this.#emitter.listenerCount(event) > 0) {
@@ -612,23 +598,20 @@ var RealtimeEngine = class {
 		else console.error(`[itd-api] ${message}`, error);
 	}
 	#handleFailure(error) {
-		this.#controller = void 0;
+		this.#abortSession(error);
 		if (error instanceof UnauthorizedStreamError) {
-			this.#refreshAndReconnect(error);
+			this.#runBackgroundTask(() => this.#refreshAndReconnect(error));
 			return;
 		}
-		this.#setStatus(require_url.RealtimeStatus.Error);
+		this.#setStatus(require_url.EventChannelStatus.Error);
 		this.#scheduleReconnect(error);
 	}
 	/** Обновляет токен и переподключается; при неудаче прекращает попытки. */
 	async #refreshAndReconnect(error) {
 		const generation = this.#generation;
-		const starting = {};
-		this.#starting = starting;
-		this.#setStatus(require_url.RealtimeStatus.Error);
-		const refreshed = await this.#deps.refresh().catch(() => false);
-		if (this.#starting !== starting || !this.#isCurrentGeneration(generation)) return;
-		this.#starting = void 0;
+		this.#setStatus(require_url.EventChannelStatus.Error);
+		const refreshed = await this.#deps.connection.refreshAuth().catch(() => false);
+		if (!this.#isCurrentGeneration(generation)) return;
 		if (!refreshed) {
 			this.#giveUp(error);
 			return;
@@ -659,28 +642,28 @@ var RealtimeEngine = class {
 	/** Догон через REST идёт до сокета: он же обновляет протухший токен. */
 	async #reconnect() {
 		if (!this.#wanted || this.#starting) return;
-		const generation = this.#generation;
-		const starting = {};
+		const starting = this.#startAttempt("reconnect");
 		this.#starting = starting;
-		await this.#sync("reconnect", generation, starting);
-		if (this.#starting !== starting) return;
-		this.#starting = void 0;
-		if (this.#isCurrentGeneration(generation)) this.#run(generation);
+		try {
+			await starting;
+		} finally {
+			if (this.#starting === starting) this.#starting = void 0;
+		}
 	}
 	/**
 	* Завершает автоматические попытки переподключения.
 	*
-	* Владелец узнаёт об этом так же, как при {@link disconnect}. `onClose` вызывается
-	* до событий: обработчик `giveup` может тут же вызвать `connect()`.
+	* Владелец узнаёт об этом через `giveup` и может тут же вызвать `connect()`.
 	*/
 	#giveUp(error) {
 		this.#wanted = false;
 		this.#generation += 1;
 		this.#starting = void 0;
 		this.#attempt = 0;
+		this.#abortSession(error);
 		this.#detachEnvironment?.();
 		this.#detachEnvironment = void 0;
-		this.#deps.onClose?.();
+		EVENT_CHANNEL_GIVEUP_HOOKS.get(this)?.();
 		this.#emitEngine("error", {
 			error,
 			willReconnect: false
@@ -698,8 +681,8 @@ var RealtimeEngine = class {
 		const target = globalThis;
 		if (typeof target.addEventListener !== "function") return;
 		const wake = () => {
-			if (this.#controller || this.#cancelTimer || this.#starting) return;
-			if (this.#status === require_url.RealtimeStatus.Disconnected) return;
+			if (this.#session || this.#cancelTimer || this.#starting) return;
+			if (this.#status === require_url.EventChannelStatus.Disconnected) return;
 			this.#attempt = 0;
 			this.#reconnect();
 		};
@@ -722,8 +705,103 @@ var RealtimeEngine = class {
 	#isCurrentGeneration(generation) {
 		return this.#wanted && this.#generation === generation;
 	}
-	#isCurrentConnection(controller, generation) {
-		return this.#isCurrentGeneration(generation) && this.#controller === controller && !controller.signal.aborted;
+	#isCurrentSession(session) {
+		return this.#isCurrentGeneration(session.generation) && this.#session === session && !session.controller.signal.aborted;
+	}
+	#createSession(generation) {
+		const controller = new AbortController();
+		let resolveOpened;
+		let rejectOpened;
+		let resolveDrained;
+		const opened = new Promise((resolve, reject) => {
+			resolveOpened = resolve;
+			rejectOpened = reject;
+		});
+		const drained = new Promise((resolve) => {
+			resolveDrained = resolve;
+		});
+		opened.catch(() => {});
+		const session = {};
+		const handle = Object.freeze({
+			signal: controller.signal,
+			opened,
+			enqueue: (update, options) => {
+				if (!this.#isCurrentSession(session)) return;
+				this.#dispatch(update, options.raw, options.origin);
+			}
+		});
+		Object.assign(session, {
+			generation,
+			controller,
+			handle,
+			resolveOpened,
+			rejectOpened,
+			buffer: [],
+			tasks: /* @__PURE__ */ new Set(),
+			drained,
+			resolveDrained,
+			retired: false,
+			ready: false
+		});
+		return session;
+	}
+	/**
+	* Учитывает работу, принадлежащую одной сессии соединения.
+	*
+	* Маркер добавляется до синхронного входа в операцию: она может повторным вызовом
+	* остановить канал из `onOpen` или подготовки, и такая сессия всё равно должна
+	* остаться в `drain()` до завершения операции.
+	*/
+	#runSessionTask(session, operation) {
+		return this.#runTrackedTask(session.tasks, operation, () => {
+			if (session.retired && session.tasks.size === 0) session.resolveDrained();
+		});
+	}
+	/** Учитывает работу канала до синхронного входа в операцию вне сессии транспорта. */
+	#runBackgroundTask(operation) {
+		this.#runTrackedTask(this.#backgroundTasks, operation);
+	}
+	/** Запускает операцию без окна между входом в неё и регистрацией маркера завершения. */
+	#runTrackedTask(tasks, operation, afterFinish) {
+		let finish;
+		const marker = new Promise((resolve) => {
+			finish = resolve;
+		});
+		tasks.add(marker);
+		let task;
+		try {
+			task = Promise.resolve(operation());
+		} catch (error) {
+			task = Promise.reject(error);
+		}
+		const settle = () => {
+			tasks.delete(marker);
+			finish();
+			afterFinish?.();
+		};
+		task.then(settle, settle);
+		return task;
+	}
+	#openGate(session) {
+		if (!this.#isCurrentSession(session) || session.ready) return;
+		session.ready = true;
+		const buffered = session.buffer.splice(0);
+		for (const event of buffered) {
+			if (!this.#isCurrentSession(session)) break;
+			this.#dispatchFrame(event);
+		}
+	}
+	#abortSession(reason) {
+		const session = this.#session;
+		if (!session) return;
+		this.#session = void 0;
+		session.buffer.length = 0;
+		session.retired = true;
+		this.#retiredSessions.add(session.drained);
+		session.drained.then(() => this.#retiredSessions.delete(session.drained));
+		session.rejectOpened(reason);
+		session.controller.abort(reason);
+		if (session.tasks.size === 0) session.resolveDrained();
 	}
 	/** Рассылает событие из общей части карты, не теряя доменные события типа `E`. */
 	#emitEngine(event, payload) {
@@ -731,7 +809,7 @@ var RealtimeEngine = class {
 	}
 };
 //#endregion
-//#region src/realtime/transports/poll.ts
+//#region src/events/transports/poll.ts
 /**
 * Запасной транспорт: обычный опрос REST вместо потока.
 *
@@ -747,19 +825,19 @@ var PollTransport = class {
 	#interval;
 	#limit;
 	#clock;
-	constructor(options = {}) {
+	#request;
+	constructor(options) {
+		this.#request = options.request;
 		this.#clock = options.clock ?? require_url.systemClock;
 		this.#interval = options.interval ?? 15e3;
 		this.#limit = options.limit ?? 20;
 	}
 	async connect(context) {
-		const request = context.request;
-		if (!request) throw new require_errors.ItdConfigError("опрос уведомлений выполняется через конвейер клиента; создайте поток вызовом itd.realtime()");
 		const seen = /* @__PURE__ */ new Set();
 		let firstRun = true;
 		let lastUnreadCount;
 		while (!context.signal.aborted) {
-			const payload = await this.#readUpdates(request, context.signal);
+			const payload = await this.#readUpdates(this.#request, context.signal);
 			context.onOpen();
 			const items = require_url.pickArray(payload, "notifications");
 			for (const item of [...items].reverse()) {
@@ -775,7 +853,7 @@ var PollTransport = class {
 				const excess = [...seen].slice(0, seen.size - this.#limit * 2);
 				for (const id of excess) seen.delete(id);
 			}
-			const count = await this.#readCount(request, context.signal);
+			const count = await this.#readCount(this.#request, context.signal);
 			if (count !== void 0 && count !== lastUnreadCount) {
 				lastUnreadCount = count;
 				context.onEvent({
@@ -790,7 +868,7 @@ var PollTransport = class {
 	async #readUpdates(request, signal) {
 		try {
 			return await request({
-				operationId: "realtime.poll.updates",
+				operationId: "events.notifications.poll.updates",
 				path: "/api/notifications/",
 				query: {
 					limit: this.#limit,
@@ -806,7 +884,7 @@ var PollTransport = class {
 	async #readCount(request, signal) {
 		try {
 			const payload = await request({
-				operationId: "realtime.poll.unread",
+				operationId: "events.notifications.poll.unread",
 				path: "/api/notifications/count",
 				signal
 			});
@@ -927,7 +1005,7 @@ ${value2}`, dataLines++;
 		}
 		if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
 			const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
-			id = value2.includes("\0") ? void 0 : value2;
+			value2.includes("\0") || (id = value2);
 			return;
 		}
 		if (firstCharCode === 58) {
@@ -955,7 +1033,7 @@ ${value2}`, dataLines++;
 ${value}`, dataLines++;
 				break;
 			case "id":
-				id = value.includes("\0") ? void 0 : value;
+				value.includes("\0") || (id = value);
 				break;
 			case "retry":
 				/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
@@ -998,7 +1076,7 @@ function isEventPrefix(chunk, i, firstCharCode) {
 	return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
 }
 //#endregion
-//#region src/realtime/transports/sse.ts
+//#region src/events/transports/sse.ts
 /** Путь потока уведомлений. */
 const STREAM_PATH = "/api/notifications/stream";
 /**
@@ -1027,7 +1105,7 @@ var SseTransport = class {
 	async connect(context) {
 		const token = context.authorize ? await context.getToken() : null;
 		if (context.authorize && !token) throw new UnauthorizedStreamError();
-		const url = require_cookies.joinUrl(context.baseUrl, STREAM_PATH);
+		const url = require_redact.joinUrl(context.baseUrl, STREAM_PATH);
 		const headers = await context.baseHeaders(url);
 		headers.set("Accept", "text/event-stream");
 		if (token) headers.set("Authorization", `Bearer ${token}`);
@@ -1109,9 +1187,78 @@ var SseTransport = class {
 	}
 };
 //#endregion
-//#region src/realtime/stream.ts
+//#region src/events/updates.ts
+/** Типы нормализованных обновлений потока. */
+const NotificationUpdateType = Object.freeze({
+	Notification: "notification",
+	UnreadCount: "unreadCount",
+	Unknown: "unknown"
+});
+/** Источники нормализованных обновлений потока. */
+const NotificationUpdateOrigin = Object.freeze({
+	Stream: "stream",
+	Sync: "sync"
+});
+/** Проверяет форму фильтра уведомлений. */
+function validateNotificationSelector(selector) {
+	if (typeof selector === "string") {
+		if (selector.length === 0) throw new require_errors.ItdConfigError("Тип уведомления не должен быть пустым");
+		return;
+	}
+	if (Array.isArray(selector)) {
+		if (selector.length === 0 || selector.some((type) => typeof type !== "string" || !type)) throw new require_errors.ItdConfigError("Список типов уведомлений должен содержать непустые строки");
+		return;
+	}
+	if (typeof selector !== "object" || selector === null) throw new require_errors.ItdConfigError("Фильтр уведомлений должен быть строкой, списком или объектом");
+	const filter = selector;
+	if (filter.type !== void 0) validateNotificationSelector(filter.type);
+	if (filter.actorId !== void 0 && typeof filter.actorId !== "string") throw new require_errors.ItdConfigError("Фильтр уведомлений: actorId должен быть строкой");
+	for (const field of ["entityId", "parentEntityId"]) {
+		const value = filter[field];
+		if (value !== void 0 && value !== null && typeof value !== "string") throw new require_errors.ItdConfigError(`Фильтр уведомлений: ${field} должен быть строкой или null`);
+	}
+	if (filter.predicate !== void 0 && typeof filter.predicate !== "function") throw new require_errors.ItdConfigError("Фильтр уведомлений: predicate должен быть функцией");
+}
+/** Преобразует транспортный кадр в одно логическое обновление. */
+function readNotificationEventsUpdate(event) {
+	if (event.name === "notification") return {
+		type: NotificationUpdateType.Notification,
+		data: require_url.readNotificationEvent(event.data)
+	};
+	if (event.name === "unread_count") {
+		const count = require_url.readUnreadCountEvent(event.data);
+		return count === void 0 ? void 0 : {
+			type: NotificationUpdateType.UnreadCount,
+			data: count
+		};
+	}
+	return {
+		type: NotificationUpdateType.Unknown,
+		name: event.name,
+		data: event.data
+	};
+}
+/** Проверяет объектный или краткий фильтр уведомления. */
+function matchesNotification(context, selector) {
+	const notification = context.update.data.notification;
+	if (typeof selector === "string") return notification.type === selector;
+	if (Array.isArray(selector)) return selector.includes(notification.type);
+	const filter = selector;
+	const types = filter.type === void 0 ? void 0 : [filter.type].flat();
+	if (types && !types.includes(notification.type)) return false;
+	if (filter.actorId !== void 0 && !notification.actors.some(({ id }) => id === filter.actorId)) return false;
+	if (filter.entityId !== void 0 && notification.entityId !== filter.entityId) return false;
+	if (filter.parentEntityId !== void 0 && notification.parentEntityId !== filter.parentEntityId) return false;
+	return filter.predicate?.(context) ?? true;
+}
+/** Сужает произвольный контекст потока до контекста уведомления. */
+function isNotificationContext(context) {
+	return context.update.type === NotificationUpdateType.Notification;
+}
+//#endregion
+//#region src/events/stream.ts
 /** Способ получения событий. */
-const RealtimeTransportKind = Object.freeze({
+const NotificationEventsTransport = Object.freeze({
 	/** Поток событий, если среда умеет читать тело по частям, иначе опрос. */
 	Auto: "auto",
 	/** Поток `text/event-stream`. */
@@ -1120,34 +1267,39 @@ const RealtimeTransportKind = Object.freeze({
 	Poll: "poll"
 });
 /** Проверяет настройки потока. @throws {ItdConfigError} при некорректных значениях */
-function validateRealtimeOptions(options) {
+function resolveNotificationEventsOptions(options = {}) {
+	resolveEventChannelOptions(options);
 	const duration = (value, name, min) => {
 		if (value === void 0) return;
-		if (!Number.isFinite(value) || value < min) throw new require_errors.ItdConfigError(`realtime.${name} должен быть числом не меньше ${min}, получено: ${value}`);
+		if (!Number.isFinite(value) || value < min) throw new require_errors.ItdConfigError(`events.notifications.${name} должен быть числом не меньше ${min}, получено: ${value}`);
 	};
 	duration(options.pollInterval, "pollInterval", 1);
 	duration(options.idleTimeout, "idleTimeout", 0);
 	duration(options.handshakeTimeout, "handshakeTimeout", 0);
+	return Object.freeze({
+		...options,
+		...options.backoff ? { backoff: Object.freeze([...options.backoff]) } : {}
+	});
 }
-const REALTIME_CONNECT_GUARDS = /* @__PURE__ */ new WeakMap();
-/** Связывает поток с lifecycle создавшего его клиента. @internal */
-function setRealtimeConnectGuard(stream, guard) {
-	REALTIME_CONNECT_GUARDS.set(stream, guard);
+const EVENT_CONNECT_GUARDS = /* @__PURE__ */ new WeakMap();
+/** Регистрирует проверку состояния создавшего поток клиента. @internal */
+function setNotificationEventsConnectGuard(stream, guard) {
+	EVENT_CONNECT_GUARDS.set(stream, guard);
 }
 /**
 * Поток уведомлений в реальном времени.
 *
-* Получается вызовом `itd.realtime()`. Соединение поднимается методом {@link connect}
+* Доступен как стабильное свойство `itd.notifications.events`. Соединение поднимается методом {@link connect}
 * и держится само: обрывы, обновление токена и повторные попытки библиотека берёт на себя.
 *
 * Параметр типа задаёт форму контекста: плагин может расширить её своими полями
-* (`ItdRealtime<RealtimeContext & SessionFlavor<S>>`) и типизировать обработчики.
+* (`NotificationEvents<NotificationEventContext & SessionFlavor<S>>`) и типизировать обработчики.
 *
 * @example
 * ```ts
 * import { NotificationType } from 'itd-api';
 *
-* const stream = itd.realtime();
+* const stream = itd.notifications.events;
 *
 * stream.onNotification(NotificationType.PostComment, async ({ update }) => {
 *   await saveCommentNotification(update.data.notification);
@@ -1160,28 +1312,23 @@ function setRealtimeConnectGuard(stream, guard) {
 * await stream.drain();
 * ```
 */
-var ItdRealtime = class {
+var NotificationEvents = class {
 	#deps;
 	#engine;
+	#lifecycleActive = false;
+	/** @internal */
 	constructor(deps, options = {}) {
-		validateRealtimeOptions(options);
+		options = resolveNotificationEventsOptions(options);
 		this.#deps = deps;
-		this.#engine = new RealtimeEngine({
-			baseUrl: deps.baseUrl,
-			authorize: deps.authorize ?? true,
-			fetch: deps.fetch,
-			request: deps.request,
+		this.#engine = new EventChannel({
+			connection: deps.connection,
 			clock: deps.clock,
-			baseHeaders: deps.baseHeaders,
-			getToken: deps.getToken,
-			refresh: deps.refresh,
-			onConnect: deps.onConnect,
-			onClose: deps.onClose,
 			logger: deps.logger,
 			transport: createTransport(deps, options),
+			streamOrigin: NotificationUpdateOrigin.Stream,
 			handleFrame: (event) => this.#handleFrame(event),
-			readUpdate: readRealtimeUpdate,
-			coalesceKey: (update) => update.type === RealtimeUpdateType.UnreadCount ? update.type : void 0,
+			readUpdate: readNotificationEventsUpdate,
+			coalesceKey: (update) => update.type === NotificationUpdateType.UnreadCount ? update.type : void 0,
 			createContext: (update, raw, origin) => ({
 				update,
 				stream: this,
@@ -1189,8 +1336,9 @@ var ItdRealtime = class {
 				origin
 			}),
 			deliver: (update) => this.#deliver(update),
-			...options.syncCount === false ? {} : { sync: (reason, dispatch) => this.#syncUnreadCount(reason, dispatch) }
+			...options.syncCount === false ? {} : { initialize: (reason, session) => this.#syncUnreadCount(reason, session.signal, (update) => session.enqueue(update, { origin: NotificationUpdateOrigin.Sync })) }
 		}, options);
+		setEventChannelGiveUpHook(this.#engine, () => this.#closeLifecycle());
 	}
 	/** Текущее состояние соединения. */
 	get status() {
@@ -1202,7 +1350,7 @@ var ItdRealtime = class {
 	}
 	/** Базовый URL клиента, создавшего поток. @internal */
 	get baseUrl() {
-		return this.#deps.baseUrl;
+		return this.#deps.connection.baseUrl;
 	}
 	/** Идентификаторы аккаунта и сессии клиента, создавшего поток. @internal */
 	getAuthIdentity() {
@@ -1234,8 +1382,8 @@ var ItdRealtime = class {
 	onUpdate(selectorOrHandler, selectedHandler) {
 		const selectAll = selectedHandler === void 0;
 		const handler = selectAll ? selectorOrHandler : selectedHandler;
-		if (typeof handler !== "function") throw new require_errors.ItdConfigError("realtime.onUpdate() принимает функцию обработчика");
-		if (!selectAll && typeof selectorOrHandler !== "function" && !Object.values(RealtimeUpdateType).includes(selectorOrHandler)) throw new require_errors.ItdConfigError(`Неизвестный тип обновления потока: ${String(selectorOrHandler)}`);
+		if (typeof handler !== "function") throw new require_errors.ItdConfigError("events.onUpdate() принимает функцию обработчика");
+		if (!selectAll && typeof selectorOrHandler !== "function" && !Object.values(NotificationUpdateType).includes(selectorOrHandler)) throw new require_errors.ItdConfigError(`Неизвестный тип обновления потока: ${String(selectorOrHandler)}`);
 		let predicate;
 		if (selectAll) predicate = () => true;
 		else {
@@ -1245,7 +1393,7 @@ var ItdRealtime = class {
 		return this.#engine.onUpdate(predicate, handler);
 	}
 	onNotification(selector, handler) {
-		if (typeof handler !== "function") throw new require_errors.ItdConfigError("realtime.onNotification() принимает функцию обработчика");
+		if (typeof handler !== "function") throw new require_errors.ItdConfigError("events.onNotification() принимает функцию обработчика");
 		if (typeof selector !== "function") validateNotificationSelector(selector);
 		const predicate = (context) => {
 			if (!isNotificationContext(context)) return false;
@@ -1264,14 +1412,23 @@ var ItdRealtime = class {
 	* @throws если создавший поток клиент уже освобождён
 	*/
 	async connect() {
-		REALTIME_CONNECT_GUARDS.get(this)?.();
-		return this.#engine.connect();
+		EVENT_CONNECT_GUARDS.get(this)?.();
+		if (this.#lifecycleActive) return this.#engine.connect();
+		this.#lifecycleActive = true;
+		try {
+			this.#deps.onConnect?.();
+			await this.#engine.connect();
+		} catch (error) {
+			this.#closeLifecycle();
+			throw error;
+		}
 	}
 	/** Закрывает соединение и отменяет запланированные попытки. */
 	disconnect() {
 		this.#engine.disconnect();
+		this.#closeLifecycle();
 	}
-	/** Ждёт завершения всех принятых обновлений. */
+	/** Ждёт завершения принятых обновлений и освобождения ресурсов остановленной сессии. */
 	drain() {
 		return this.#engine.drain();
 	}
@@ -1279,6 +1436,11 @@ var ItdRealtime = class {
 	removeAllListeners() {
 		this.#engine.removeAllListeners();
 	}
+	#closeLifecycle() {
+		if (!this.#lifecycleActive) return;
+		this.#lifecycleActive = false;
+		this.#deps.onClose?.();
+	}
 	/** Кадр `connected` — не обновление, а подтверждение подключения. */
 	#handleFrame(event) {
 		if (event.name !== "connected") return false;
@@ -1291,36 +1453,40 @@ var ItdRealtime = class {
 	* Только при первом подключении: поток присылает счётчик сам, а лишний запрос
 	* на каждой попытке переподключения нагружал бы сервер во время недоступности сети.
 	*/
-	async #syncUnreadCount(reason, dispatch) {
+	async #syncUnreadCount(reason, signal, dispatch) {
 		if (reason !== "initial") return;
-		const count = await this.#deps.fetchUnreadCount();
+		const count = await this.#deps.fetchUnreadCount(signal);
 		dispatch({
-			type: RealtimeUpdateType.UnreadCount,
+			type: NotificationUpdateType.UnreadCount,
 			data: count
 		});
 	}
 	#deliver(update) {
-		if (update.type === RealtimeUpdateType.Notification) {
+		if (update.type === NotificationUpdateType.Notification) {
 			this.#engine.emit("notification", update.data);
 			if (update.data.unreadCount !== void 0) this.#engine.emit("unreadCount", update.data.unreadCount);
 			return;
 		}
-		if (update.type === RealtimeUpdateType.UnreadCount) {
+		if (update.type === NotificationUpdateType.UnreadCount) {
 			this.#engine.emit("unreadCount", update.data);
 			return;
 		}
-		if (update.type === RealtimeUpdateType.Unknown) return;
+		if (update.type === NotificationUpdateType.Unknown) return;
 		assertNeverUpdate(update);
 	}
 };
 /** Выбирает транспорт по настройкам и возможностям среды. */
 function createTransport(deps, options) {
-	const kind = options.transport ?? RealtimeTransportKind.Auto;
+	const kind = options.transport ?? NotificationEventsTransport.Auto;
 	if (typeof kind === "object") return kind;
-	if (kind === RealtimeTransportKind.Poll || kind === RealtimeTransportKind.Auto && !require_url.supportsStreamingBody()) return new PollTransport({
-		...deps.clock ? { clock: deps.clock } : {},
-		...options.pollInterval !== void 0 ? { interval: options.pollInterval } : {}
-	});
+	if (kind === NotificationEventsTransport.Poll || kind === NotificationEventsTransport.Auto && !require_redact.supportsStreamingBody()) {
+		if (!deps.request) throw new require_errors.ItdConfigError("Poll transport requires a notification request adapter");
+		return new PollTransport({
+			request: deps.request,
+			...deps.clock ? { clock: deps.clock } : {},
+			...options.pollInterval !== void 0 ? { interval: options.pollInterval } : {}
+		});
+	}
 	return new SseTransport({
 		...deps.clock ? { clock: deps.clock } : {},
 		...options.idleTimeout !== void 0 ? { idleTimeout: options.idleTimeout } : {},
@@ -1331,261 +1497,42 @@ function assertNeverUpdate(update) {
 	throw new TypeError(`Необработанное обновление потока: ${String(update)}`);
 }
 //#endregion
-//#region src/realtime/router.ts
-/**
-* Направляет обновления потока в именованные цепочки промежуточных обработчиков.
-*
-* @example
-* ```ts
-* import { RealtimeRouter, RealtimeUpdateType } from 'itd-api';
-*
-* const router = new RealtimeRouter((context) => context.update.type);
-* router.route(RealtimeUpdateType.Notification, async (context, next) => {
-*   if (context.update.type === RealtimeUpdateType.Notification) {
-*     await handleNotification(context.update.data.notification);
-*   }
-*   await next();
-* });
-* stream.use(router);
-* ```
-*/
-var RealtimeRouter = class {
-	#selector;
-	#routes = /* @__PURE__ */ new Map();
-	#fallback = [];
-	constructor(selector) {
-		if (typeof selector !== "function") throw new require_errors.ItdConfigError("RealtimeRouter принимает функцию выбора маршрута");
-		this.#selector = selector;
-	}
-	/** Добавляет промежуточные обработчики к маршруту и возвращает функцию их удаления. */
-	route(key, ...middleware) {
-		if (!isPropertyKey(key)) throw new require_errors.ItdConfigError("Ключ realtime route должен быть PropertyKey");
-		const registration = this.#registration(middleware);
-		const registrations = this.#routes.get(key) ?? [];
-		registrations.push(registration);
-		this.#routes.set(key, registrations);
-		return () => {
-			const current = this.#routes.get(key);
-			if (!current) return;
-			const index = current.indexOf(registration);
-			if (index >= 0) current.splice(index, 1);
-			if (current.length === 0) this.#routes.delete(key);
-		};
-	}
-	/** Добавляет промежуточные обработчики для обновлений без зарегистрированного маршрута. */
-	otherwise(...middleware) {
-		const registration = this.#registration(middleware);
-		this.#fallback.push(registration);
-		return () => {
-			const index = this.#fallback.indexOf(registration);
-			if (index >= 0) this.#fallback.splice(index, 1);
-		};
-	}
-	/** Возвращает снимок маршрутов для `stream.use(router)` или ручной композиции. */
-	middleware() {
-		const middleware = (context, next) => this.#captureMiddleware()(context, next);
-		return withRealtimeMiddlewareSnapshot(middleware, () => this.#captureMiddleware());
-	}
-	#captureMiddleware() {
-		const routes = /* @__PURE__ */ new Map();
-		for (const [key, registrations] of this.#routes) routes.set(key, registrations.flatMap(({ middleware }) => middleware).map(captureRealtimeMiddleware));
-		const fallback = this.#fallback.flatMap(({ middleware }) => middleware).map(captureRealtimeMiddleware);
-		return async (context, next) => {
-			const key = await this.#selector(context);
-			if (key != null && !isPropertyKey(key)) throw new require_errors.ItdConfigError("Функция выбора маршрута должна возвращать PropertyKey, null или undefined");
-			const route = key == null ? void 0 : routes.get(key);
-			const chain = route && route.length > 0 ? route : fallback;
-			if (chain.length === 0) {
-				await next();
-				return;
-			}
-			await runRealtimeMiddleware(chain, context, next);
-		};
-	}
-	#registration(middleware) {
-		if (middleware.length === 0) throw new require_errors.ItdConfigError("Маршрут должен содержать хотя бы один обработчик");
-		for (const item of middleware) if (typeof item !== "function") throw new require_errors.ItdConfigError("Маршрут принимает только функции обработки");
-		return { middleware: [...middleware] };
-	}
-};
-function isPropertyKey(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
-}
-//#endregion
-//#region src/realtime/composer.ts
-function middlewareFunction(middleware) {
-	if (typeof middleware === "function") return middleware;
-	if (typeof middleware !== "object" || middleware === null || typeof middleware.middleware !== "function") throw new require_errors.ItdConfigError("RealtimeComposer принимает функцию обработки или объект с middleware()");
-	return deferRealtimeMiddleware(middleware);
-}
-function middlewareGroup(group) {
-	const middleware = Array.isArray(group) ? group : [group];
-	if (middleware.length === 0) throw new require_errors.ItdConfigError("Ветка RealtimeComposer должна содержать хотя бы один middleware");
-	return middleware.map((item) => middlewareFunction(item));
-}
-function boundaryContinuation() {
-	let called = false;
-	let duplicate;
-	return {
-		next: () => {
-			if (!called) {
-				called = true;
-				return Promise.resolve();
-			}
-			const failure = Promise.reject(/* @__PURE__ */ new Error("next() в обработчике realtime error boundary вызван повторно"));
-			duplicate = Promise.all(duplicate ? [duplicate, failure] : [failure]).then(() => void 0);
-			return failure;
-		},
-		called: () => called,
-		settled: async () => {
-			await duplicate;
-		}
-	};
-}
-async function runBoundaryStep(run, continuation) {
-	let failure;
-	try {
-		await run();
-	} catch (error) {
-		failure = { error };
-	}
-	try {
-		await continuation.settled();
-	} catch (error) {
-		failure ??= { error };
-	}
-	if (failure) throw failure.error;
-}
-/**
-* Собирает переиспользуемый feature-модуль из realtime middleware.
-*
-* Composer не открывает соединение и не планирует конкурентность: готовый объект подключается
-* через `stream.use(composer)`, а выполнение остаётся обязанностью существующего dispatcher.
-* Для каждого принятого update используется снимок всей вложенной структуры composer.
-*
-* @example
-* ```ts
-* const feature = new RealtimeComposer<AppRealtimeContext>();
-* const safe = feature.errorBoundary(reportFeatureError);
-* safe.filter(isPostUpdate).use(handlePost);
-* stream.use(feature);
-* ```
-*/
-var RealtimeComposer = class RealtimeComposer {
-	#middleware = [];
-	constructor(...middleware) {
-		this.use(...middleware);
-	}
-	/** Добавляет middleware в конец текущей onion-цепочки. */
-	use(...middleware) {
-		const normalized = middleware.map(middlewareFunction);
-		this.#middleware.push(...normalized);
-		return this;
-	}
-	filter(predicate, ...middleware) {
-		if (typeof predicate !== "function") throw new require_errors.ItdConfigError("RealtimeComposer.filter() принимает функцию условия");
-		const child = new RealtimeComposer(...middleware);
-		this.#middleware.push(deferRealtimeMiddleware({ middleware: () => {
-			const nested = captureRealtimeMiddleware(child.middleware());
-			return async (context, next) => {
-				if (await predicate(context)) await nested(context, next);
-				else await next();
-			};
-		} }));
-		return child;
-	}
-	/**
-	* Направляет контекст в одну именованную ветку.
-	*
-	* Неизвестный ключ без fallback пропускает update следующему внешнему middleware. Для
-	* динамической регистрации и числовых ключей используйте {@link RealtimeRouter} напрямую.
-	*/
-	route(selector, routes, fallback) {
-		if (typeof routes !== "object" || routes === null || Array.isArray(routes)) throw new require_errors.ItdConfigError("RealtimeComposer.route() принимает объект именованных веток");
-		const router = new RealtimeRouter(selector);
-		let registrations = 0;
-		for (const key of Reflect.ownKeys(routes)) {
-			const group = routes[key];
-			if (group === void 0) continue;
-			router.route(key, ...middlewareGroup(group));
-			registrations += 1;
-		}
-		if (fallback !== void 0) {
-			router.otherwise(...middlewareGroup(fallback));
-			registrations += 1;
-		}
-		if (registrations === 0) throw new require_errors.ItdConfigError("RealtimeComposer.route() требует хотя бы одну ветку или fallback");
-		return this.use(router);
-	}
-	/**
-	* Создаёт дочернюю ветку с локальной границей ошибок.
-	*
-	* Граница защищает только переданные и затем добавленные в возвращённый composer middleware.
-	* Ошибки внешней цепочки намеренно не перехватываются. Обработчик может вызвать `next()`,
-	* чтобы после ошибки продолжить внешнюю цепочку, либо повторно выбросить исключение. Внешняя
-	* цепочка начинается после полного завершения защищённой ветки, а не входит в её onion-вызов.
-	*/
-	errorBoundary(handler, ...middleware) {
-		if (typeof handler !== "function") throw new require_errors.ItdConfigError("RealtimeComposer.errorBoundary() принимает обработчик ошибки");
-		const child = new RealtimeComposer(...middleware);
-		this.#middleware.push(deferRealtimeMiddleware({ middleware: () => {
-			const nested = captureRealtimeMiddleware(child.middleware());
-			return async (context, next) => {
-				let continuation = boundaryContinuation();
-				try {
-					await runBoundaryStep(() => nested(context, continuation.next), continuation);
-				} catch (error) {
-					continuation = boundaryContinuation();
-					await runBoundaryStep(() => handler({
-						error,
-						context
-					}, continuation.next), continuation);
-				}
-				if (continuation.called()) await next();
-			};
-		} }));
-		return child;
-	}
-	/** Возвращает snapshot-aware middleware для `stream.use()` или вложенного composer. */
-	middleware() {
-		const middleware = (context, next) => this.#captureMiddleware()(context, next);
-		return withRealtimeMiddlewareSnapshot(middleware, () => this.#captureMiddleware());
-	}
-	#captureMiddleware() {
-		const snapshot = this.#middleware.map(captureRealtimeMiddleware);
-		return (context, next) => runRealtimeMiddleware(snapshot, context, next);
-	}
-};
-const CONNECTING = 0;
-const OPEN = 1;
-const NORMAL_CLOSURE = 1e3;
-const UNAUTHORIZED_CLOSE_CODES = /* @__PURE__ */ new Set([1008, 4401]);
-function validateDuration(value, name) {
-	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new require_errors.ItdConfigError(`WebSocketTransport.${name} должен быть числом не меньше 0, получено: ${value}`);
-}
-function isWebSocketConnection(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const socket = value;
-	return typeof socket.readyState === "number" && typeof socket.addEventListener === "function" && typeof socket.removeEventListener === "function" && typeof socket.send === "function" && typeof socket.close === "function";
-}
-function abortError(signal) {
-	if (signal.reason !== void 0) return signal.reason;
-	const error = /* @__PURE__ */ new Error("WebSocket-подключение отменено");
-	error.name = "AbortError";
-	return error;
-}
-function errorMessage(error) {
-	if (error instanceof Error && error.message) return error.message;
-	if (typeof error === "object" && error !== null && "message" in error) {
-		const message = error.message;
-		if (typeof message === "string" && message) return message;
+//#region src/operations/events.ts
+/** Контракты HTTP-запросов событийного канала. */
+const EVENT_OPERATIONS = Object.freeze({
+	"events.notifications.poll.updates": require_url.passthroughOperation("events.notifications.poll.updates"),
+	"events.notifications.poll.unread": require_url.passthroughOperation("events.notifications.poll.unread")
+});
+const CONNECTING = 0;
+const OPEN = 1;
+const NORMAL_CLOSURE = 1e3;
+const UNAUTHORIZED_CLOSE_CODES = /* @__PURE__ */ new Set([1008, 4401]);
+function validateDuration(value, name) {
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new require_errors.ItdConfigError(`WebSocketTransport.${name} должен быть числом не меньше 0, получено: ${value}`);
+}
+function isWebSocketConnection(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const socket = value;
+	return typeof socket.readyState === "number" && typeof socket.addEventListener === "function" && typeof socket.removeEventListener === "function" && typeof socket.send === "function" && typeof socket.close === "function";
+}
+function abortError(signal) {
+	if (signal.reason !== void 0) return signal.reason;
+	const error = /* @__PURE__ */ new Error("WebSocket-подключение отменено");
+	error.name = "AbortError";
+	return error;
+}
+function errorMessage(error) {
+	if (error instanceof Error && error.message) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) {
+		const message = error.message;
+		if (typeof message === "string" && message) return message;
 	}
 }
 function safeDetail(error, url, token) {
 	const message = errorMessage(error);
 	if (!message) return void 0;
-	const safe = message.replaceAll(url, require_url.redactUrl(url));
-	return token ? safe.replaceAll(token, require_url.maskSecret(token)) : safe;
+	const safe = message.replaceAll(url, require_redact.redactUrl(url));
+	return token ? safe.replaceAll(token, require_redact.maskSecret(token)) : safe;
 }
 function readCloseEvent(event) {
 	const close = typeof event === "object" && event !== null ? event : void 0;
@@ -1605,7 +1552,7 @@ function readMessage(event) {
 function eventName(data) {
 	return typeof data === "object" && data !== null && "type" in data ? String(data.type) : "message";
 }
-/** Транспорт исходных realtime-событий поверх стандартного WebSocket. */
+/** Транспорт исходных событий поверх стандартного WebSocket. */
 var WebSocketTransport = class {
 	name = "ws";
 	#path;
@@ -1645,7 +1592,7 @@ var WebSocketTransport = class {
 		const implementation = this.#webSocketImpl ?? this.#globalImplementation();
 		const auth = this.#auth === "auto" ? injected ? "header" : "query" : this.#auth;
 		const { requestUrl, socketUrl } = this.#urls(context.baseUrl);
-		const url = auth === "query" && token ? `${socketUrl}${require_cookies.buildQuery({ token })}` : socketUrl;
+		const url = auth === "query" && token ? `${socketUrl}${require_redact.buildQuery({ token })}` : socketUrl;
 		let headers;
 		if (injected) {
 			const resolved = await context.baseHeaders(requestUrl);
@@ -1661,7 +1608,7 @@ var WebSocketTransport = class {
 			}) : new implementation(url);
 		} catch (error) {
 			const detail = safeDetail(error, url, token);
-			throw new Error(`Не удалось создать WebSocket ${require_url.redactUrl(url)}${detail ? `: ${detail}` : ""}`);
+			throw new Error(`Не удалось создать WebSocket ${require_redact.redactUrl(url)}${detail ? `: ${detail}` : ""}`);
 		}
 		if (!isWebSocketConnection(value)) throw new require_errors.ItdConfigError("webSocketImpl вернул объект без WebSocket-методов addEventListener, send и close");
 		try {
@@ -1675,7 +1622,7 @@ var WebSocketTransport = class {
 		return implementation;
 	}
 	#urls(baseUrl) {
-		const request = new URL(require_cookies.joinUrl(baseUrl, this.#path));
+		const request = new URL(require_redact.joinUrl(baseUrl, this.#path));
 		const socket = new URL(request);
 		if (request.protocol === "https:") socket.protocol = "wss:";
 		else if (request.protocol === "http:") socket.protocol = "ws:";
@@ -1731,7 +1678,7 @@ var WebSocketTransport = class {
 				cancelIdle?.();
 				if (this.#idleTimeout <= 0) return;
 				cancelIdle = this.#clock.schedule(() => {
-					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)} молчит дольше допустимого`), 4e3, "idle timeout");
+					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_redact.redactUrl(url)} молчит дольше допустимого`), 4e3, "idle timeout");
 				}, this.#idleTimeout);
 			};
 			const scheduleKeepAlive = () => {
@@ -1742,7 +1689,7 @@ var WebSocketTransport = class {
 						socket.send("ping");
 					} catch (error) {
 						const detail = safeDetail(error, url, token);
-						closeWithError(/* @__PURE__ */ new Error(`Не удалось отправить WebSocket ping ${require_url.redactUrl(url)}` + (detail ? `: ${detail}` : "")));
+						closeWithError(/* @__PURE__ */ new Error(`Не удалось отправить WebSocket ping ${require_redact.redactUrl(url)}` + (detail ? `: ${detail}` : "")));
 						return;
 					}
 					scheduleKeepAlive();
@@ -1773,7 +1720,7 @@ var WebSocketTransport = class {
 				}
 				if (pending === void 0) return;
 				if (pendingFrames >= 256) {
-					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)}: очередь кадров переполнена`), 4e3, "queue overflow");
+					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_redact.redactUrl(url)}: очередь кадров переполнена`), 4e3, "queue overflow");
 					return;
 				}
 				pendingFrames += 1;
@@ -1813,11 +1760,11 @@ var WebSocketTransport = class {
 				if (context.authorize && UNAUTHORIZED_CLOSE_CODES.has(code)) outcome = new UnauthorizedStreamError();
 				else if (socketError !== void 0) {
 					const detail = safeDetail(socketError, url, token);
-					outcome = /* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)} завершился ошибкой${detail ? `: ${detail}` : ""}`);
+					outcome = /* @__PURE__ */ new Error(`WebSocket ${require_redact.redactUrl(url)} завершился ошибкой${detail ? `: ${detail}` : ""}`);
 				} else if (opened && code === NORMAL_CLOSURE && wasClean) outcome = void 0;
 				else {
-					const safeReason = token ? reason.replaceAll(token, require_url.maskSecret(token)) : reason;
-					outcome = /* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)} закрыт с кодом ${code}` + (safeReason ? `: ${safeReason}` : ""));
+					const safeReason = token ? reason.replaceAll(token, require_redact.maskSecret(token)) : reason;
+					outcome = /* @__PURE__ */ new Error(`WebSocket ${require_redact.redactUrl(url)} закрыт с кодом ${code}` + (safeReason ? `: ${safeReason}` : ""));
 				}
 				if (!opened && context.authorize && !(outcome instanceof UnauthorizedStreamError) && this.#classifyOpenFailure) try {
 					if (await this.#classifyOpenFailure(outcome, context.signal)) outcome = new UnauthorizedStreamError();
@@ -1862,53 +1809,404 @@ var WebSocketTransport = class {
 			socket.addEventListener("close", onClose);
 			context.signal.addEventListener("abort", onAbort, { once: true });
 			if (this.#handshakeTimeout > 0) cancelHandshake = this.#clock.schedule(() => {
-				closeWithError(/* @__PURE__ */ new Error(`Истёк таймаут установки WebSocket ${require_url.redactUrl(url)}`), 4e3, "handshake timeout");
+				closeWithError(/* @__PURE__ */ new Error(`Истёк таймаут установки WebSocket ${require_redact.redactUrl(url)}`), 4e3, "handshake timeout");
 			}, this.#handshakeTimeout);
 			if (context.signal.aborted) onAbort();
 		});
 	}
 };
 //#endregion
+//#region src/events/client.ts
+/**
+* Поток уведомлений с собственным конвейером запросов.
+*
+* Тот же {@link NotificationEvents}, что доступен как `itd.notifications.events`, но собранный без полного клиента:
+* ресурсы, билдеры и сессия сюда не входят. Нужен приложениям, которым от API нужны только
+* события, — виджетам, счётчикам непрочитанного, фоновым слушателям.
+*
+* @example
+* ```ts
+* import { createNotificationEventsClient } from 'itd-api/events';
+*
+* await using stream = createNotificationEventsClient({ auth: token });
+* stream.on('notification', ({ notification }) => console.log(notification.type));
+* await stream.connect();
+* ```
+*/
+var NotificationEventsClient = class NotificationEventsClient extends NotificationEvents {
+	#runtime;
+	/** Общий результат терминальной очистки для идемпотентных повторных вызовов. */
+	#disposePromise;
+	#disposed = false;
+	constructor(options = {}) {
+		const runtime = require_url.createClientRuntime(options, {
+			catalog: require_url.ITD_CATALOG,
+			auth: () => resolveAuthProvider(options.auth)
+		});
+		super(notificationEventsDeps(runtime), options);
+		this.#runtime = runtime;
+		setNotificationEventsConnectGuard(this, () => {
+			if (!this.#disposed) return;
+			throw new require_errors.ItdStateError("Поток уже окончательно освобождён через dispose(); нельзя подключить его снова. Создайте новый");
+		});
+	}
+	/**
+	* Окончательно освобождает поток и его конвейер: отключает соединение, дожидается
+	* обработчиков и останавливает очередь запросов.
+	*
+	* Повторные вызовы возвращают тот же результат очистки.
+	*/
+	dispose() {
+		if (this.#disposePromise) return this.#disposePromise;
+		this.#disposed = true;
+		this.#disposePromise = this.#dispose();
+		return this.#disposePromise;
+	}
+	async #dispose() {
+		const errors = [];
+		this.disconnect();
+		try {
+			await this.drain();
+		} catch (error) {
+			errors.push(error);
+		}
+		try {
+			this.#runtime.close();
+			await this.#runtime.dispose();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить поток");
+	}
+	/** Позволяет использовать поток с `await using`. */
+	[Symbol.asyncDispose]() {
+		return this.dispose();
+	}
+	static {
+		require_url.installAsyncDisposeFallback(NotificationEventsClient);
+	}
+};
+/** Приводит опцию `auth` к провайдеру конвейера. */
+function resolveAuthProvider(auth) {
+	if (auth === void 0) return require_url.anonymousAuth();
+	return typeof auth === "string" ? require_url.bearerToken(auth) : auth;
+}
+/**
+* Связывает поток с собранным конвейером.
+*
+* Начальный счётчик непрочитанных берётся той же операцией, что и при опросе
+* (`events.notifications.poll.unread`): ресурс уведомлений потоку для этого не нужен.
+*/
+function notificationEventsDeps(runtime) {
+	const request = ({ operationId, path, query, signal }) => runtime.http.execute(EVENT_OPERATIONS[operationId], {
+		path,
+		query,
+		signal
+	});
+	return {
+		connection: runtime.connection(),
+		clock: runtime.config.clock,
+		logger: runtime.config.logger,
+		request,
+		fetchUnreadCount: async (signal) => {
+			const payload = await request({
+				operationId: "events.notifications.poll.unread",
+				path: "/api/notifications/count",
+				signal
+			});
+			return require_url.pickNumber(payload, "count", 0);
+		}
+	};
+}
+/**
+* Создаёт поток уведомлений с собственным конвейером. Равнозначно конструктору
+* {@link NotificationEventsClient}.
+*/
+function createNotificationEventsClient(options = {}) {
+	return new NotificationEventsClient(options);
+}
+//#endregion
+//#region src/events/router.ts
+/**
+* Направляет обновления потока в именованные цепочки промежуточных обработчиков.
+*
+* @example
+* ```ts
+* import { EventRouter, NotificationUpdateType } from 'itd-api/events';
+*
+* const router = new EventRouter((context) => context.update.type);
+* router.route(NotificationUpdateType.Notification, async (context, next) => {
+*   if (context.update.type === NotificationUpdateType.Notification) {
+*     await handleNotification(context.update.data.notification);
+*   }
+*   await next();
+* });
+* stream.use(router);
+* ```
+*/
+var EventRouter = class {
+	#selector;
+	#routes = /* @__PURE__ */ new Map();
+	#fallback = [];
+	constructor(selector) {
+		if (typeof selector !== "function") throw new require_errors.ItdConfigError("EventRouter принимает функцию выбора маршрута");
+		this.#selector = selector;
+	}
+	/** Добавляет промежуточные обработчики к маршруту и возвращает функцию их удаления. */
+	route(key, ...middleware) {
+		if (!isPropertyKey(key)) throw new require_errors.ItdConfigError("Ключ маршрута событий должен быть PropertyKey");
+		const registration = this.#registration(middleware);
+		const registrations = this.#routes.get(key) ?? [];
+		registrations.push(registration);
+		this.#routes.set(key, registrations);
+		return () => {
+			const current = this.#routes.get(key);
+			if (!current) return;
+			const index = current.indexOf(registration);
+			if (index >= 0) current.splice(index, 1);
+			if (current.length === 0) this.#routes.delete(key);
+		};
+	}
+	/** Добавляет промежуточные обработчики для обновлений без зарегистрированного маршрута. */
+	otherwise(...middleware) {
+		const registration = this.#registration(middleware);
+		this.#fallback.push(registration);
+		return () => {
+			const index = this.#fallback.indexOf(registration);
+			if (index >= 0) this.#fallback.splice(index, 1);
+		};
+	}
+	/** Возвращает снимок маршрутов для `stream.use(router)` или ручной композиции. */
+	middleware() {
+		const middleware = (context, next) => this.#captureMiddleware()(context, next);
+		return withEventMiddlewareSnapshot(middleware, () => this.#captureMiddleware());
+	}
+	#captureMiddleware() {
+		const routes = /* @__PURE__ */ new Map();
+		for (const [key, registrations] of this.#routes) routes.set(key, registrations.flatMap(({ middleware }) => middleware).map(captureEventMiddleware));
+		const fallback = this.#fallback.flatMap(({ middleware }) => middleware).map(captureEventMiddleware);
+		return async (context, next) => {
+			const key = await this.#selector(context);
+			if (key != null && !isPropertyKey(key)) throw new require_errors.ItdConfigError("Функция выбора маршрута должна возвращать PropertyKey, null или undefined");
+			const route = key == null ? void 0 : routes.get(key);
+			const chain = route && route.length > 0 ? route : fallback;
+			if (chain.length === 0) {
+				await next();
+				return;
+			}
+			await runEventMiddleware(chain, context, next);
+		};
+	}
+	#registration(middleware) {
+		if (middleware.length === 0) throw new require_errors.ItdConfigError("Маршрут должен содержать хотя бы один обработчик");
+		for (const item of middleware) if (typeof item !== "function") throw new require_errors.ItdConfigError("Маршрут принимает только функции обработки");
+		return { middleware: [...middleware] };
+	}
+};
+function isPropertyKey(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+//#endregion
+//#region src/events/composer.ts
+function middlewareFunction(middleware) {
+	if (typeof middleware === "function") return middleware;
+	if (typeof middleware !== "object" || middleware === null || typeof middleware.middleware !== "function") throw new require_errors.ItdConfigError("EventComposer принимает функцию обработки или объект с middleware()");
+	return deferEventMiddleware(middleware);
+}
+function middlewareGroup(group) {
+	const middleware = Array.isArray(group) ? group : [group];
+	if (middleware.length === 0) throw new require_errors.ItdConfigError("Ветка EventComposer должна содержать хотя бы один middleware");
+	return middleware.map((item) => middlewareFunction(item));
+}
+function boundaryContinuation() {
+	let called = false;
+	let duplicate;
+	return {
+		next: () => {
+			if (!called) {
+				called = true;
+				return Promise.resolve();
+			}
+			const failure = Promise.reject(/* @__PURE__ */ new Error("next() в обработчике границы ошибок событий вызван повторно"));
+			duplicate = Promise.all(duplicate ? [duplicate, failure] : [failure]).then(() => void 0);
+			return failure;
+		},
+		called: () => called,
+		settled: async () => {
+			await duplicate;
+		}
+	};
+}
+async function runBoundaryStep(run, continuation) {
+	let failure;
+	try {
+		await run();
+	} catch (error) {
+		failure = { error };
+	}
+	try {
+		await continuation.settled();
+	} catch (error) {
+		failure ??= { error };
+	}
+	if (failure) throw failure.error;
+}
+/**
+* Собирает переиспользуемую цепочку обработчиков событий.
+*
+* Не открывает соединение. Готовый объект подключается через `stream.use(composer)`.
+* Для каждого обновления используется текущий снимок вложенных обработчиков.
+*
+* @example
+* ```ts
+* const feature = new EventComposer<AppEventContext>();
+* const safe = feature.errorBoundary(reportFeatureError);
+* safe.filter(isPostUpdate).use(handlePost);
+* stream.use(feature);
+* ```
+*/
+var EventComposer = class EventComposer {
+	#middleware = [];
+	constructor(...middleware) {
+		this.use(...middleware);
+	}
+	/** Добавляет промежуточные обработчики в конец цепочки. */
+	use(...middleware) {
+		const normalized = middleware.map(middlewareFunction);
+		this.#middleware.push(...normalized);
+		return this;
+	}
+	filter(predicate, ...middleware) {
+		if (typeof predicate !== "function") throw new require_errors.ItdConfigError("EventComposer.filter() принимает функцию условия");
+		const child = new EventComposer(...middleware);
+		this.#middleware.push(deferEventMiddleware({ middleware: () => {
+			const nested = captureEventMiddleware(child.middleware());
+			return async (context, next) => {
+				if (await predicate(context)) await nested(context, next);
+				else await next();
+			};
+		} }));
+		return child;
+	}
+	/**
+	* Направляет контекст в одну именованную ветку.
+	*
+	* Неизвестный ключ без запасной ветки передаёт обновление следующему обработчику. Для
+	* динамической регистрации и числовых ключей используйте {@link EventRouter} напрямую.
+	*/
+	route(selector, routes, fallback) {
+		if (typeof routes !== "object" || routes === null || Array.isArray(routes)) throw new require_errors.ItdConfigError("EventComposer.route() принимает объект именованных веток");
+		const router = new EventRouter(selector);
+		let registrations = 0;
+		for (const key of Reflect.ownKeys(routes)) {
+			const group = routes[key];
+			if (group === void 0) continue;
+			router.route(key, ...middlewareGroup(group));
+			registrations += 1;
+		}
+		if (fallback !== void 0) {
+			router.otherwise(...middlewareGroup(fallback));
+			registrations += 1;
+		}
+		if (registrations === 0) throw new require_errors.ItdConfigError("EventComposer.route() требует хотя бы одну ветку или fallback");
+		return this.use(router);
+	}
+	/**
+	* Создаёт дочернюю ветку с локальной границей ошибок.
+	*
+	* Перехватывает ошибки только из дочерней ветки. Вызов `next()` в обработчике ошибки
+	* продолжает внешнюю цепочку.
+	*/
+	errorBoundary(handler, ...middleware) {
+		if (typeof handler !== "function") throw new require_errors.ItdConfigError("EventComposer.errorBoundary() принимает обработчик ошибки");
+		const child = new EventComposer(...middleware);
+		this.#middleware.push(deferEventMiddleware({ middleware: () => {
+			const nested = captureEventMiddleware(child.middleware());
+			return async (context, next) => {
+				let continuation = boundaryContinuation();
+				try {
+					await runBoundaryStep(() => nested(context, continuation.next), continuation);
+				} catch (error) {
+					continuation = boundaryContinuation();
+					await runBoundaryStep(() => handler({
+						error,
+						context
+					}, continuation.next), continuation);
+				}
+				if (continuation.called()) await next();
+			};
+		} }));
+		return child;
+	}
+	/** Возвращает промежуточный обработчик для `stream.use()` или вложенной цепочки. */
+	middleware() {
+		const middleware = (context, next) => this.#captureMiddleware()(context, next);
+		return withEventMiddlewareSnapshot(middleware, () => this.#captureMiddleware());
+	}
+	#captureMiddleware() {
+		const snapshot = this.#middleware.map(captureEventMiddleware);
+		return (context, next) => runEventMiddleware(snapshot, context, next);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "EVENT_OPERATIONS", {
+	enumerable: true,
+	get: function() {
+		return EVENT_OPERATIONS;
+	}
+});
 Object.defineProperty(exports, "Emitter", {
 	enumerable: true,
 	get: function() {
 		return Emitter;
 	}
 });
-Object.defineProperty(exports, "ItdRealtime", {
+Object.defineProperty(exports, "EventChannel", {
+	enumerable: true,
+	get: function() {
+		return EventChannel;
+	}
+});
+Object.defineProperty(exports, "EventComposer", {
+	enumerable: true,
+	get: function() {
+		return EventComposer;
+	}
+});
+Object.defineProperty(exports, "EventRouter", {
 	enumerable: true,
 	get: function() {
-		return ItdRealtime;
+		return EventRouter;
 	}
 });
-Object.defineProperty(exports, "RealtimeComposer", {
+Object.defineProperty(exports, "NotificationEvents", {
 	enumerable: true,
 	get: function() {
-		return RealtimeComposer;
+		return NotificationEvents;
 	}
 });
-Object.defineProperty(exports, "RealtimeRouter", {
+Object.defineProperty(exports, "NotificationEventsClient", {
 	enumerable: true,
 	get: function() {
-		return RealtimeRouter;
+		return NotificationEventsClient;
 	}
 });
-Object.defineProperty(exports, "RealtimeTransportKind", {
+Object.defineProperty(exports, "NotificationEventsTransport", {
 	enumerable: true,
 	get: function() {
-		return RealtimeTransportKind;
+		return NotificationEventsTransport;
 	}
 });
-Object.defineProperty(exports, "RealtimeUpdateOrigin", {
+Object.defineProperty(exports, "NotificationUpdateOrigin", {
 	enumerable: true,
 	get: function() {
-		return RealtimeUpdateOrigin;
+		return NotificationUpdateOrigin;
 	}
 });
-Object.defineProperty(exports, "RealtimeUpdateType", {
+Object.defineProperty(exports, "NotificationUpdateType", {
 	enumerable: true,
 	get: function() {
-		return RealtimeUpdateType;
+		return NotificationUpdateType;
 	}
 });
 Object.defineProperty(exports, "UnauthorizedStreamError", {
@@ -1923,23 +2221,41 @@ Object.defineProperty(exports, "WebSocketTransport", {
 		return WebSocketTransport;
 	}
 });
+Object.defineProperty(exports, "createNotificationEventsClient", {
+	enumerable: true,
+	get: function() {
+		return createNotificationEventsClient;
+	}
+});
 Object.defineProperty(exports, "reportListenerError", {
 	enumerable: true,
 	get: function() {
 		return reportListenerError;
 	}
 });
-Object.defineProperty(exports, "runRealtimeMiddleware", {
+Object.defineProperty(exports, "resolveEventChannelOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveEventChannelOptions;
+	}
+});
+Object.defineProperty(exports, "resolveNotificationEventsOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveNotificationEventsOptions;
+	}
+});
+Object.defineProperty(exports, "runEventMiddleware", {
 	enumerable: true,
 	get: function() {
-		return runRealtimeMiddleware;
+		return runEventMiddleware;
 	}
 });
-Object.defineProperty(exports, "setRealtimeConnectGuard", {
+Object.defineProperty(exports, "setNotificationEventsConnectGuard", {
 	enumerable: true,
 	get: function() {
-		return setRealtimeConnectGuard;
+		return setNotificationEventsConnectGuard;
 	}
 });
 
-//# sourceMappingURL=websocket-C_eI4H2o.cjs.map
+//# sourceMappingURL=events-FZfnEez0.cjs.map