itd-api 0.7.0 → 0.7.1

package/dist/shared/websocket-sYlynrr0.cjs

@@ -0,0 +1,1945 @@
+const require_url = require("./url-yjl2c8Ie.cjs");
+const require_errors = require("./errors-DfU8M5eS.cjs");
+const require_cookies = require("./cookies-DZwFq6kr.cjs");
+//#region src/core/emitter.ts
+/**
+* Минимальный типизированный источник событий.
+*
+* Своя реализация вместо `EventTarget` и `EventEmitter`: первый есть не везде и требует
+* обёрток `CustomEvent`, второй существует только в Node. Нужны ровно подписка и рассылка.
+*
+* Исключение в обработчике не прерывает рассылку остальным и не роняет библиотеку.
+*
+* @typeParam Events карта «имя события → тип полезной нагрузки». Задаётся интерфейсом,
+* поэтому ограничение на индексную сигнатуру намеренно не накладывается.
+*/
+var Emitter = class {
+	#listeners = /* @__PURE__ */ new Map();
+	#onError;
+	constructor(onListenerError) {
+		this.#onError = onListenerError;
+	}
+	/**
+	* Подписывается на событие.
+	*
+	* @returns функция отписки
+	*
+	* @example
+	* ```ts
+	* const off = realtime.on('notification', (event) => console.log(event));
+	* off();
+	* ```
+	*/
+	on(event, listener) {
+		const set = this.#listeners.get(event) ?? /* @__PURE__ */ new Set();
+		set.add(listener);
+		this.#listeners.set(event, set);
+		return () => this.off(event, listener);
+	}
+	/** Подписывается на одно срабатывание. */
+	once(event, listener) {
+		const off = this.on(event, (payload) => {
+			off();
+			listener(payload);
+		});
+		return off;
+	}
+	/** Отписывается от события. */
+	off(event, listener) {
+		this.#listeners.get(event)?.delete(listener);
+	}
+	/** Рассылает событие подписчикам. */
+	emit(event, payload) {
+		const set = this.#listeners.get(event);
+		if (!set) return;
+		for (const listener of [...set]) try {
+			listener(payload);
+		} catch (error) {
+			this.#onError?.(error);
+		}
+	}
+	/** Сколько подписчиков у события. */
+	listenerCount(event) {
+		return this.#listeners.get(event)?.size ?? 0;
+	}
+	/** Снимает все подписки. */
+	removeAllListeners() {
+		this.#listeners.clear();
+	}
+};
+/**
+* Сообщает об исключении из пользовательского обработчика события: пишет в логгер,
+* при его отсутствии — в консоль.
+*
+* Ошибка чужого обработчика не должна ронять библиотеку, но и пропадать молча ей нельзя:
+* иначе подписка, падающая на каждом событии, выглядит как её отсутствие.
+*
+* @param scope о чьих событиях речь — попадает в текст сообщения
+*
+* @internal
+*/
+function reportListenerError(logger, scope, error) {
+	const message = `Ошибка в обработчике события ${scope}`;
+	if (logger) logger.error(message, error);
+	else console.error(`[itd-api] ${message}`, error);
+}
+//#endregion
+//#region src/realtime/middleware.ts
+const REALTIME_MIDDLEWARE_SNAPSHOT = Symbol("itd-api.realtime.middlewareSnapshot");
+/** @internal */
+function captureRealtimeMiddleware(middleware) {
+	const capture = middleware[REALTIME_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 });
+	return middleware;
+}
+/** Создаёт отложенный промежуточный обработчик для объекта. @internal */
+function deferRealtimeMiddleware(source) {
+	const capture = () => {
+		const middleware = source.middleware();
+		if (typeof middleware !== "function") throw new require_errors.ItdConfigError("realtime middleware() должен возвращать функцию обработки");
+		return captureRealtimeMiddleware(middleware);
+	};
+	const deferred = (context, next) => capture()(context, next);
+	return withRealtimeMiddlewareSnapshot(deferred, capture);
+}
+/** Выполняет промежуточные обработчики по порядку и запрещает повторный вызов `next()`. */
+async function runRealtimeMiddleware(middleware, context, terminal) {
+	let lastIndex = -1;
+	const dispatch = async (index) => {
+		if (index <= lastIndex) throw new Error("next() в промежуточном обработчике вызван повторно");
+		lastIndex = index;
+		const current = middleware[index];
+		if (!current) {
+			await terminal();
+			return;
+		}
+		let downstream;
+		let duplicateCalls;
+		let failure;
+		const next = () => {
+			if (!downstream) {
+				downstream = dispatch(index + 1);
+				return downstream;
+			}
+			const duplicate = Promise.reject(/* @__PURE__ */ new Error("next() в одном промежуточном обработчике вызван повторно"));
+			duplicateCalls = Promise.all(duplicateCalls ? [duplicateCalls, duplicate] : [duplicate]).then(() => void 0);
+			return duplicate;
+		};
+		try {
+			await current(context, next);
+		} catch (error) {
+			failure = { error };
+		}
+		try {
+			await downstream;
+			await duplicateCalls;
+		} catch (error) {
+			failure ??= { error };
+		}
+		if (failure) throw failure.error;
+	};
+	await dispatch(0);
+}
+/** Планирует нормализованные обновления и отслеживает незавершённые обработчики. */
+var RealtimeDispatcher = class {
+	#options;
+	#hooks;
+	#middleware = [];
+	#handlers = [];
+	#queue = [];
+	#activeKeys = /* @__PURE__ */ new Set();
+	#drainWaiters = /* @__PURE__ */ new Set();
+	#active = 0;
+	constructor(options, hooks) {
+		this.#options = options;
+		this.#hooks = hooks;
+	}
+	use(middleware) {
+		this.#middleware.push(middleware);
+		return () => {
+			const index = this.#middleware.indexOf(middleware);
+			if (index >= 0) this.#middleware.splice(index, 1);
+		};
+	}
+	on(predicate, handler) {
+		const registration = {
+			predicate,
+			handler
+		};
+		this.#handlers.push(registration);
+		return () => {
+			const index = this.#handlers.indexOf(registration);
+			if (index >= 0) this.#handlers.splice(index, 1);
+		};
+	}
+	/**
+	* Принимает обновление к обработке.
+	*
+	* @param coalesceKey ожидающая работа с тем же ключом заменяется новой
+	*/
+	dispatch(context, coalesceKey) {
+		let keys;
+		let middleware;
+		try {
+			keys = this.#keysFor(context);
+			middleware = this.#middleware.map(captureRealtimeMiddleware);
+		} catch (error) {
+			this.#hooks.middlewareError(error, context);
+			return;
+		}
+		const replaced = coalesceKey === void 0 ? -1 : this.#queue.findIndex((pending) => pending.coalesceKey === coalesceKey);
+		if (replaced < 0 && this.#queue.length >= 256) {
+			this.#hooks.overflow();
+			return;
+		}
+		const work = {
+			context,
+			middleware,
+			handlers: [...this.#handlers],
+			keys,
+			coalesceKey
+		};
+		if (replaced >= 0) this.#queue[replaced] = work;
+		else this.#queue.push(work);
+		this.#pump();
+	}
+	/** Отбрасывает обновления, обработка которых ещё не началась. */
+	clearPending() {
+		this.#queue.length = 0;
+		this.#resolveDrain();
+	}
+	/** Ждёт завершения активных и поставленных в очередь обновлений. */
+	drain() {
+		if (this.#active === 0 && this.#queue.length === 0) return Promise.resolve();
+		return new Promise((resolve) => this.#drainWaiters.add(resolve));
+	}
+	#keysFor(context) {
+		const value = this.#options.sequentialize?.(context);
+		if (value === void 0) return [];
+		const values = Array.isArray(value) ? value : [value];
+		for (const key of values) if (typeof key !== "string" && typeof key !== "number" && typeof key !== "symbol") throw new TypeError("sequentialize() должен возвращать PropertyKey или их список");
+		return [...new Set(values)];
+	}
+	#pump() {
+		while (this.#active < this.#options.concurrency) {
+			const blockedKeys = new Set(this.#activeKeys);
+			const index = this.#queue.findIndex(({ keys }) => {
+				const runnable = keys.every((key) => !blockedKeys.has(key));
+				if (!runnable) for (const key of keys) blockedKeys.add(key);
+				return runnable;
+			});
+			if (index < 0) break;
+			const [work] = this.#queue.splice(index, 1);
+			if (!work) break;
+			this.#active += 1;
+			for (const key of work.keys) this.#activeKeys.add(key);
+			this.#run(work);
+		}
+		this.#resolveDrain();
+	}
+	async #run(work) {
+		try {
+			await runRealtimeMiddleware(work.middleware, work.context, async () => {
+				for (const { predicate, handler } of work.handlers) try {
+					if (predicate(work.context)) await handler(work.context);
+				} catch (error) {
+					this.#hooks.handlerError(error, work.context);
+				}
+				this.#hooks.deliver(work.context);
+			});
+		} catch (error) {
+			this.#hooks.middlewareError(error, work.context);
+		} finally {
+			this.#active -= 1;
+			for (const key of work.keys) this.#activeKeys.delete(key);
+			this.#pump();
+		}
+	}
+	#resolveDrain() {
+		if (this.#active !== 0 || this.#queue.length !== 0) return;
+		for (const resolve of this.#drainWaiters) resolve();
+		this.#drainWaiters.clear();
+	}
+};
+//#endregion
+//#region src/realtime/reconnect.ts
+/**
+* Паузы перед попытками переподключения, мс.
+*
+* Значения совпадают с теми, что использует сайт итд.com, — поведение библиотеки
+* не отличается от привычного пользователю.
+*/
+const RECONNECT_BACKOFF = Object.freeze([
+	1e3,
+	2e3,
+	4e3,
+	8e3,
+	16e3,
+	3e4
+]);
+/**
+* Вычисляет паузу перед попыткой переподключения.
+*
+* Разброс нужен, чтобы клиенты, отключившиеся одновременно из-за перезапуска сервера,
+* не вернулись тоже одновременно.
+*
+* @param attempt номер попытки, начиная с нуля
+* @param random источник случайности; подменяется в тестах
+*/
+function reconnectDelay(attempt, options = {}, random = Math.random) {
+	const backoff = options.backoff ?? RECONNECT_BACKOFF;
+	const jitter = options.jitter ?? .3;
+	const base = backoff[Math.min(attempt, backoff.length - 1)] ?? 3e4;
+	const spread = base * jitter * (random() * 2 - 1);
+	return Math.max(0, Math.round(base + spread));
+}
+//#endregion
+//#region src/realtime/transports/transport.ts
+/** Ошибка, по которой видно, что сервер отверг авторизацию потока. */
+var UnauthorizedStreamError = class extends Error {
+	constructor() {
+		super("Поток событий отверг токен доступа");
+		this.name = "UnauthorizedStreamError";
+	}
+};
+//#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;
+}
+/** Сужает произвольный контекст потока до контекста уведомления. */
+function isNotificationContext(context) {
+	return context.update.type === RealtimeUpdateType.Notification;
+}
+//#endregion
+//#region src/realtime/engine.ts
+/** Проверяет настройки общей механики потока. */
+function validateRealtimeEngineOptions(options) {
+	const positiveInteger = (value, name) => {
+		if (value === void 0) return;
+		if (!Number.isInteger(value) || value < 0) throw new require_errors.ItdConfigError(`realtime.${name} должен быть целым неотрицательным числом, получено: ${value}`);
+	};
+	const duration = (value, name) => {
+		if (!Number.isFinite(value) || value < 0) throw new require_errors.ItdConfigError(`realtime.${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.backoff !== void 0) {
+		if (!Array.isArray(options.backoff) || options.backoff.length === 0) throw new require_errors.ItdConfigError("realtime.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 должен быть функцией");
+}
+/**
+* Общая механика потока событий: соединение, переподключение с backoff, обновление
+* токена, реакция на среду, статусы и очередь обработчиков.
+*
+* Ничего не знает о домене: что считать обновлением, как собрать контекст и кому его
+* доставить, решают {@link RealtimeEngineDeps}. Поэтому один и тот же движок несёт
+* и поток уведомлений, и любой другой.
+*
+* @internal
+*/
+var RealtimeEngine = class {
+	#deps;
+	#options;
+	#dispatcher;
+	#emitter;
+	#clock;
+	#maxAttempts;
+	#controller;
+	/**
+	* Хочет ли вызывающий код, чтобы соединение было живо.
+	*
+	* Отдельно от `#controller`, потому что тот появляется только после `await` внутри
+	* {@link connect}. Без этого флага два вызова подряд проскочили бы проверку оба
+	* и подняли два соединения, а `disconnect()` во время синхронизации не был бы замечен
+	* и соединение поднялось бы уже после отмены.
+	*/
+	#wanted = false;
+	#status = require_url.RealtimeStatus.Disconnected;
+	#attempt = 0;
+	#generation = 0;
+	#starting;
+	#cancelTimer;
+	#detachEnvironment;
+	constructor(deps, options = {}) {
+		validateRealtimeEngineOptions(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({
+			concurrency: options.concurrency ?? 1,
+			...options.sequentialize ? { sequentialize: options.sequentialize } : {}
+		}, {
+			deliver: (context) => this.#deps.deliver(context.update),
+			middlewareError: (error, context) => this.#reportDispatchError("middlewareError", error, context),
+			handlerError: (error, context) => this.#reportDispatchError("handlerError", error, context),
+			overflow: () => this.#handleOverflow()
+		});
+	}
+	/** Текущее состояние соединения. */
+	get status() {
+		return this.#status;
+	}
+	/** Имя используемого транспорта. */
+	get transport() {
+		return this.#deps.transport.name;
+	}
+	/** Подписывается на событие потока. @returns функция отписки */
+	on(event, listener) {
+		return this.#emitter.on(event, listener);
+	}
+	/** Подписывается на одно срабатывание события потока. */
+	once(event, listener) {
+		return this.#emitter.once(event, listener);
+	}
+	/** Рассылает доменное событие через общий эмиттер потока. */
+	emit(event, payload) {
+		this.#emitter.emit(event, payload);
+	}
+	/** Снимает подписки на события. Обработчики обновлений и middleware остаются. */
+	removeAllListeners() {
+		this.#emitter.removeAllListeners();
+	}
+	/** Добавляет промежуточный обработчик. @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));
+	}
+	/** Подписывает обработчик обновлений, подходящих под условие. */
+	onUpdate(predicate, handler) {
+		return this.#dispatcher.on(predicate, handler);
+	}
+	/**
+	* Поднимает соединение.
+	*
+	* Повторный вызов при уже живом соединении ничего не делает. Возвращает управление
+	* сразу после запуска: соединение живёт в фоне.
+	*/
+	async connect() {
+		if (this.#wanted) return;
+		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);
+	}
+	/** Закрывает соединение и отменяет запланированные попытки. */
+	disconnect() {
+		this.#wanted = false;
+		this.#generation += 1;
+		this.#starting = void 0;
+		if (this.#cancelTimer) {
+			this.#cancelTimer();
+			this.#cancelTimer = void 0;
+		}
+		this.#detachEnvironment?.();
+		this.#detachEnvironment = void 0;
+		this.#controller?.abort();
+		this.#controller = void 0;
+		this.#attempt = 0;
+		this.#dispatcher.clearPending();
+		this.#setStatus(require_url.RealtimeStatus.Disconnected);
+		this.#deps.onClose?.();
+	}
+	/** Ждёт завершения всех принятых обновлений. */
+	drain() {
+		return this.#dispatcher.drain();
+	}
+	/** Пропускает актуальное обновление через цепочку обработчиков. */
+	#dispatch(update, raw, origin) {
+		if (!this.#wanted) return;
+		this.#dispatcher.dispatch(this.#deps.createContext(update, raw, origin), this.#deps.coalesceKey?.(update));
+	}
+	/**
+	* Очередь обновлений достигла предела: закрывает соединение и переподключается,
+	* когда обработчики разберут очередь.
+	*/
+	#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 error = /* @__PURE__ */ new Error("Обработчики не успевают за потоком: очередь обновлений переполнена");
+		this.#dispatcher.drain().then(() => {
+			if (this.#isCurrentGeneration(generation) && !this.#controller) this.#scheduleReconnect(error);
+		});
+	}
+	/** Выполняет доменную синхронизацию, не роняя подключение из-за её ошибки. */
+	async #sync(reason, generation, starting) {
+		if (!this.#deps.sync) return;
+		try {
+			await this.#deps.sync(reason, (update) => {
+				if (this.#starting !== starting || !this.#isCurrentGeneration(generation)) return;
+				this.#dispatch(update, void 0, RealtimeUpdateOrigin.Sync);
+			});
+		} catch (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,
+			onOpen: () => {
+				if (!this.#isCurrentConnection(controller, generation)) return;
+				this.#attempt = 0;
+				this.#setStatus(require_url.RealtimeStatus.Connected);
+			},
+			onEvent: (event) => {
+				if (this.#isCurrentConnection(controller, generation)) this.#handleEvent(event);
+			},
+			onParseError: (error, raw) => {
+				if (this.#isCurrentConnection(controller, generation)) this.#emitEngine("parseError", {
+					error,
+					raw
+				});
+			}
+		}).then(() => {
+			if (this.#isCurrentConnection(controller, generation)) this.#handleFailure(/* @__PURE__ */ new Error("Соединение с потоком событий закрыто"));
+		}, (error) => {
+			if (this.#isCurrentConnection(controller, generation)) this.#handleFailure(error);
+		});
+	}
+	#handleEvent(event) {
+		if (!this.#wanted) return;
+		this.#emitEngine("message", event);
+		if (this.#deps.handleFrame?.(event)) return;
+		const update = this.#deps.readUpdate(event);
+		if (update !== void 0) this.#dispatch(update, event, RealtimeUpdateOrigin.Stream);
+	}
+	#reportDispatchError(event, error, context) {
+		if (this.#emitter.listenerCount(event) > 0) {
+			this.#emitEngine(event, {
+				error,
+				context
+			});
+			return;
+		}
+		const message = event === "middlewareError" ? "Ошибка в промежуточном обработчике потока" : "Ошибка в обработчике обновления потока";
+		if (this.#deps.logger) this.#deps.logger.error(message, error);
+		else console.error(`[itd-api] ${message}`, error);
+	}
+	#handleFailure(error) {
+		this.#controller = void 0;
+		if (error instanceof UnauthorizedStreamError) {
+			this.#refreshAndReconnect(error);
+			return;
+		}
+		this.#setStatus(require_url.RealtimeStatus.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;
+		if (!refreshed) {
+			this.#giveUp(error);
+			return;
+		}
+		this.#scheduleReconnect(error);
+	}
+	#scheduleReconnect(error) {
+		if (!this.#wanted) return;
+		if (this.#attempt >= this.#maxAttempts) {
+			this.#giveUp(error);
+			return;
+		}
+		const delay = reconnectDelay(this.#attempt, this.#options);
+		this.#attempt += 1;
+		this.#emitEngine("error", {
+			error,
+			willReconnect: true
+		});
+		this.#emitEngine("reconnect", {
+			attempt: this.#attempt,
+			delay
+		});
+		this.#cancelTimer = this.#clock.schedule(() => {
+			this.#cancelTimer = void 0;
+			this.#reconnect();
+		}, delay);
+	}
+	/** Догон через REST идёт до сокета: он же обновляет протухший токен. */
+	async #reconnect() {
+		if (!this.#wanted || this.#starting) return;
+		const generation = this.#generation;
+		const starting = {};
+		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);
+	}
+	/**
+	* Завершает автоматические попытки переподключения.
+	*
+	* Владелец узнаёт об этом так же, как при {@link disconnect}. `onClose` вызывается
+	* до событий: обработчик `giveup` может тут же вызвать `connect()`.
+	*/
+	#giveUp(error) {
+		this.#wanted = false;
+		this.#generation += 1;
+		this.#starting = void 0;
+		this.#attempt = 0;
+		this.#detachEnvironment?.();
+		this.#detachEnvironment = void 0;
+		this.#deps.onClose?.();
+		this.#emitEngine("error", {
+			error,
+			willReconnect: false
+		});
+		this.#emitEngine("giveup", void 0);
+	}
+	/**
+	* Подписывается на события среды.
+	*
+	* Возврат вкладки из фона и восстановление сети — самые частые причины «мёртвого»
+	* соединения. У сайта итд.com такой обработки нет.
+	*/
+	#attachEnvironmentListeners() {
+		if (this.#detachEnvironment) return;
+		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;
+			this.#attempt = 0;
+			this.#reconnect();
+		};
+		const onVisibility = () => {
+			if (target.document?.visibilityState === "visible") wake();
+		};
+		const listeners = [];
+		if (this.#options.reconnectOnVisible !== false && target.document) listeners.push(["visibilitychange", onVisibility]);
+		if (this.#options.reconnectOnOnline !== false) listeners.push(["online", wake]);
+		for (const [type, listener] of listeners) target.addEventListener(type, listener);
+		this.#detachEnvironment = () => {
+			for (const [type, listener] of listeners) target.removeEventListener?.(type, listener);
+		};
+	}
+	#setStatus(status) {
+		if (this.#status === status) return;
+		this.#status = status;
+		this.#emitEngine("status", status);
+	}
+	#isCurrentGeneration(generation) {
+		return this.#wanted && this.#generation === generation;
+	}
+	#isCurrentConnection(controller, generation) {
+		return this.#isCurrentGeneration(generation) && this.#controller === controller && !controller.signal.aborted;
+	}
+	/** Рассылает событие из общей части карты, не теряя доменные события типа `E`. */
+	#emitEngine(event, payload) {
+		this.#emitter.emit(event, payload);
+	}
+};
+//#endregion
+//#region src/realtime/transports/poll.ts
+/**
+* Запасной транспорт: обычный опрос REST вместо потока.
+*
+* Нужен там, где `fetch` не умеет отдавать тело по частям, — например в части сборок
+* React Native. Наружу выдаёт те же события, что и {@link SseTransport}, поэтому
+* вызывающий код разницы не замечает.
+*
+* Новыми считаются уведомления, которых не было в предыдущем ответе; чтобы список
+* известных не рос бесконечно, он ограничен последними двумя страницами.
+*/
+var PollTransport = class {
+	name = "poll";
+	#interval;
+	#limit;
+	#clock;
+	constructor(options = {}) {
+		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);
+			context.onOpen();
+			const items = require_url.pickArray(payload, "notifications");
+			for (const item of [...items].reverse()) {
+				const id = typeof item.id === "string" ? item.id : void 0;
+				if (!id || seen.has(id)) continue;
+				seen.add(id);
+				if (!firstRun) context.onEvent({
+					name: "notification",
+					data: { payload: item }
+				});
+			}
+			if (seen.size > this.#limit * 2) {
+				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);
+			if (count !== void 0 && count !== lastUnreadCount) {
+				lastUnreadCount = count;
+				context.onEvent({
+					name: "unread_count",
+					data: { payload: { count } }
+				});
+			}
+			firstRun = false;
+			await this.#wait(context.signal);
+		}
+	}
+	async #readUpdates(request, signal) {
+		try {
+			return await request({
+				operationId: "realtime.poll.updates",
+				path: "/api/notifications/",
+				query: {
+					limit: this.#limit,
+					offset: 0
+				},
+				signal
+			});
+		} catch (error) {
+			if (require_errors.isItdAuthError(error)) throw new UnauthorizedStreamError();
+			throw error;
+		}
+	}
+	async #readCount(request, signal) {
+		try {
+			const payload = await request({
+				operationId: "realtime.poll.unread",
+				path: "/api/notifications/count",
+				signal
+			});
+			return require_url.pickNumber(payload, "count", 0);
+		} catch {
+			return;
+		}
+	}
+	/** Ждёт следующего опроса, прерываясь при отмене. */
+	#wait(signal) {
+		if (signal.aborted) return Promise.resolve();
+		return new Promise((resolve) => {
+			const cancel = this.#clock.schedule(finish, this.#interval);
+			function finish() {
+				cancel();
+				signal.removeEventListener("abort", finish);
+				resolve();
+			}
+			signal.addEventListener("abort", finish, { once: true });
+		});
+	}
+};
+//#endregion
+//#region node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+	constructor(message, options) {
+		super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+	}
+};
+const LF = 10;
+const CR = 13;
+const SPACE = 32;
+function noop(_arg) {}
+function createParser(config) {
+	if (typeof config == "function") throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+	const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+	let pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+	function feed(chunk) {
+		if (terminated) throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+		if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+			const trailing2 = processLines(chunk);
+			trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+			return;
+		}
+		if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+			pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+			return;
+		}
+		pendingFragments.push(chunk);
+		const input = pendingFragments.join("");
+		pendingFragments.length = 0, pendingFragmentsLength = 0;
+		const trailing = processLines(input);
+		trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+	}
+	function checkBufferSize() {
+		maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, { type: "max-buffer-size-exceeded" }))));
+	}
+	function processLines(chunk) {
+		let searchIndex = 0;
+		if (chunk.indexOf("\r") === -1) {
+			let lfIndex = chunk.indexOf(`
+`, searchIndex);
+			for (; lfIndex !== -1;) {
+				if (searchIndex === lfIndex) {
+					dataLines > 0 && onEvent({
+						id,
+						event: eventType,
+						data
+					}), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+					continue;
+				}
+				const firstCharCode = chunk.charCodeAt(searchIndex);
+				if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+					const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+					if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+						onEvent({
+							id,
+							event: eventType,
+							data: value
+						}), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+						continue;
+					}
+					data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				} else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+				searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+			}
+			return chunk.slice(searchIndex);
+		}
+		for (; searchIndex < chunk.length;) {
+			const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+			let lineEnd = -1;
+			if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) break;
+			parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+		}
+		return chunk.slice(searchIndex);
+	}
+	function parseLine(chunk, start, end) {
+		if (start === end) {
+			dispatchEvent();
+			return;
+		}
+		const firstCharCode = chunk.charCodeAt(start);
+		if (isDataPrefix(chunk, start, firstCharCode)) {
+			const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+			data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+			return;
+		}
+		if (isEventPrefix(chunk, start, firstCharCode)) {
+			eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+			return;
+		}
+		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;
+			return;
+		}
+		if (firstCharCode === 58) {
+			if (onComment) {
+				const line2 = chunk.slice(start, end);
+				onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+			}
+			return;
+		}
+		const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+		if (fieldSeparatorIndex === -1) {
+			processField(line, "", line);
+			return;
+		}
+		const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+		processField(field, line.slice(fieldSeparatorIndex + offset), line);
+	}
+	function processField(field, value, line) {
+		switch (field) {
+			case "event":
+				eventType = value || void 0;
+				break;
+			case "data":
+				data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				break;
+			case "id":
+				id = value.includes("\0") ? void 0 : value;
+				break;
+			case "retry":
+				/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+					type: "invalid-retry",
+					value,
+					line
+				}));
+				break;
+			default: onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, {
+				type: "unknown-field",
+				field,
+				value,
+				line
+			}));
+		}
+	}
+	function dispatchEvent() {
+		dataLines > 0 && onEvent({
+			id,
+			event: eventType,
+			data
+		}), id = void 0, data = "", dataLines = 0, eventType = void 0;
+	}
+	function reset(options = {}) {
+		if (options.consume && pendingFragments.length > 0) {
+			const incompleteLine = pendingFragments.join("");
+			parseLine(incompleteLine, 0, incompleteLine.length);
+		}
+		isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
+	}
+	return {
+		feed,
+		reset
+	};
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+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
+/** Путь потока уведомлений. */
+const STREAM_PATH = "/api/notifications/stream";
+/**
+* Транспорт поверх Server-Sent Events.
+*
+* Нативный `EventSource` не подходит: он не умеет отправлять заголовок `Authorization`,
+* а поток требует Bearer-токен. Поэтому используется `fetch` с чтением тела по частям.
+*
+* Разбор кадров делегирован `eventsource-parser`, который корректно обрабатывает
+* многострочный `data:`, перевод строки `\r\n`, `data:` без пробела и кадр, разорванный
+* между сетевыми чанками. В разборе на сайте итд.com каждый из этих случаев обрабатывается
+* неверно.
+*/
+var SseTransport = class {
+	name = "sse";
+	#idleTimeout;
+	#handshakeTimeout;
+	#clock;
+	/** Идентификатор последнего события — отправляется при переподключении. */
+	#lastEventId;
+	constructor(options = {}) {
+		this.#clock = options.clock ?? require_url.systemClock;
+		this.#idleTimeout = options.idleTimeout ?? 9e4;
+		this.#handshakeTimeout = options.handshakeTimeout ?? 2e4;
+	}
+	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 headers = await context.baseHeaders(url);
+		headers.set("Accept", "text/event-stream");
+		if (token) headers.set("Authorization", `Bearer ${token}`);
+		headers.set("Cache-Control", "no-cache");
+		if (this.#lastEventId) headers.set("Last-Event-ID", this.#lastEventId);
+		const controller = new AbortController();
+		const relayAbort = () => controller.abort(context.signal.reason);
+		if (context.signal.aborted) controller.abort(context.signal.reason);
+		else context.signal.addEventListener("abort", relayAbort, { once: true });
+		try {
+			const response = await this.#handshake(url, headers, context, controller);
+			if (context.authorize && response.status === 401) throw new UnauthorizedStreamError();
+			if (!response.ok) throw new Error(`Поток уведомлений вернул статус ${response.status}`);
+			if (!response.body) throw new Error("Ответ потока уведомлений пуст");
+			context.onOpen();
+			await this.#read(response.body, context);
+		} finally {
+			context.signal.removeEventListener("abort", relayAbort);
+		}
+	}
+	/** Выполняет запрос потока, обрывая его, если ответ не пришёл за отведённое время. */
+	async #handshake(url, headers, context, controller) {
+		let expired = false;
+		const cancelTimer = this.#handshakeTimeout > 0 ? this.#clock.schedule(() => {
+			expired = true;
+			controller.abort(/* @__PURE__ */ new Error("Истёк таймаут рукопожатия SSE"));
+		}, this.#handshakeTimeout) : void 0;
+		try {
+			return await context.fetch(url, {
+				method: "GET",
+				headers,
+				signal: controller.signal
+			});
+		} catch (error) {
+			if (expired) throw new Error("Поток уведомлений не ответил: истёк таймаут рукопожатия");
+			throw error;
+		} finally {
+			cancelTimer?.();
+		}
+	}
+	async #read(body, context) {
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		const parser = createParser({ onEvent: (message) => {
+			if (message.id) this.#lastEventId = message.id;
+			let data;
+			try {
+				data = JSON.parse(message.data);
+			} catch (error) {
+				context.onParseError(error, message.data);
+				return;
+			}
+			const name = message.event ?? (typeof data === "object" && data !== null && "type" in data ? String(data.type) : "message");
+			context.onEvent({
+				name,
+				data
+			});
+		} });
+		let cancelIdleTimer;
+		const armIdleTimer = () => {
+			if (this.#idleTimeout <= 0) return;
+			cancelIdleTimer?.();
+			cancelIdleTimer = this.#clock.schedule(() => {
+				reader.cancel(/* @__PURE__ */ new Error("Поток молчит дольше допустимого")).catch(() => {});
+			}, this.#idleTimeout);
+		};
+		armIdleTimer();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				armIdleTimer();
+				parser.feed(decoder.decode(value, { stream: true }));
+			}
+		} finally {
+			cancelIdleTimer?.();
+			reader.releaseLock?.();
+		}
+	}
+};
+//#endregion
+//#region src/realtime/stream.ts
+/** Способ получения событий. */
+const RealtimeTransportKind = Object.freeze({
+	/** Поток событий, если среда умеет читать тело по частям, иначе опрос. */
+	Auto: "auto",
+	/** Поток `text/event-stream`. */
+	Sse: "sse",
+	/** Периодический опрос REST. */
+	Poll: "poll"
+});
+/** Проверяет настройки потока. @throws {ItdConfigError} при некорректных значениях */
+function validateRealtimeOptions(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}`);
+	};
+	duration(options.pollInterval, "pollInterval", 1);
+	duration(options.idleTimeout, "idleTimeout", 0);
+	duration(options.handshakeTimeout, "handshakeTimeout", 0);
+}
+const REALTIME_CONNECT_GUARDS = /* @__PURE__ */ new WeakMap();
+/** Связывает поток с lifecycle создавшего его клиента. @internal */
+function setRealtimeConnectGuard(stream, guard) {
+	REALTIME_CONNECT_GUARDS.set(stream, guard);
+}
+/**
+* Поток уведомлений в реальном времени.
+*
+* Получается вызовом `itd.realtime()`. Соединение поднимается методом {@link connect}
+* и держится само: обрывы, обновление токена и повторные попытки библиотека берёт на себя.
+*
+* Параметр типа задаёт форму контекста: плагин может расширить её своими полями
+* (`ItdRealtime<RealtimeContext & SessionFlavor<S>>`) и типизировать обработчики.
+*
+* @example
+* ```ts
+* import { NotificationType } from 'itd-api';
+*
+* const stream = itd.realtime();
+*
+* stream.onNotification(NotificationType.PostComment, async ({ update }) => {
+*   await saveCommentNotification(update.data.notification);
+* });
+* stream.on('status', (status) => console.log('соединение:', status));
+*
+* await stream.connect();
+* // …позже
+* stream.disconnect();
+* await stream.drain();
+* ```
+*/
+var ItdRealtime = class {
+	#deps;
+	#engine;
+	constructor(deps, options = {}) {
+		validateRealtimeOptions(options);
+		this.#deps = deps;
+		this.#engine = new RealtimeEngine({
+			baseUrl: deps.baseUrl,
+			authorize: deps.authorize ?? true,
+			fetch: deps.fetch,
+			request: deps.request,
+			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),
+			handleFrame: (event) => this.#handleFrame(event),
+			readUpdate: readRealtimeUpdate,
+			coalesceKey: (update) => update.type === RealtimeUpdateType.UnreadCount ? update.type : void 0,
+			createContext: (update, raw, origin) => ({
+				update,
+				stream: this,
+				raw,
+				origin
+			}),
+			deliver: (update) => this.#deliver(update),
+			...options.syncCount === false ? {} : { sync: (reason, dispatch) => this.#syncUnreadCount(reason, dispatch) }
+		}, options);
+	}
+	/** Текущее состояние соединения. */
+	get status() {
+		return this.#engine.status;
+	}
+	/** Имя используемого транспорта. */
+	get transport() {
+		return this.#engine.transport;
+	}
+	/** Базовый URL клиента, создавшего поток. @internal */
+	get baseUrl() {
+		return this.#deps.baseUrl;
+	}
+	/** Идентификаторы аккаунта и сессии клиента, создавшего поток. @internal */
+	getAuthIdentity() {
+		return this.#deps.getAuthIdentity?.();
+	}
+	/** Непрозрачная область авторизации создавшего поток клиента. @internal */
+	getAuthScope() {
+		return this.#deps.getAuthScope?.();
+	}
+	/** Подписывается на событие потока. @returns функция отписки */
+	on(event, listener) {
+		return this.#engine.on(event, listener);
+	}
+	/** Подписывается на одно срабатывание. */
+	once(event, listener) {
+		return this.#engine.once(event, listener);
+	}
+	/**
+	* Добавляет промежуточный обработчик или объект, предоставляющий его через `middleware()`.
+	*
+	* Обработчики выполняются в порядке регистрации. Если `next()` не вызван, обновление не
+	* передаётся дальше по цепочке, асинхронным обработчикам и слушателям событий.
+	*
+	* @returns функция удаления обработчика
+	*/
+	use(middleware) {
+		return this.#engine.use(middleware);
+	}
+	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)}`);
+		let predicate;
+		if (selectAll) predicate = () => true;
+		else {
+			const selector = selectorOrHandler;
+			predicate = typeof selector === "function" ? selector : (context) => context.update.type === selector;
+		}
+		return this.#engine.onUpdate(predicate, handler);
+	}
+	onNotification(selector, handler) {
+		if (typeof handler !== "function") throw new require_errors.ItdConfigError("realtime.onNotification() принимает функцию обработчика");
+		if (typeof selector !== "function") validateNotificationSelector(selector);
+		const predicate = (context) => {
+			if (!isNotificationContext(context)) return false;
+			return typeof selector === "function" ? selector(context) : matchesNotification(context, selector);
+		};
+		return this.#engine.onUpdate(predicate, handler);
+	}
+	/**
+	* Поднимает соединение.
+	*
+	* Повторный вызов при уже живом соединении ничего не делает — это защита от двойного
+	* подключения при перерисовке интерфейса.
+	*
+	* Возвращает управление сразу после запуска: соединение живёт в фоне.
+	*
+	* @throws если создавший поток клиент уже освобождён
+	*/
+	async connect() {
+		REALTIME_CONNECT_GUARDS.get(this)?.();
+		return this.#engine.connect();
+	}
+	/** Закрывает соединение и отменяет запланированные попытки. */
+	disconnect() {
+		this.#engine.disconnect();
+	}
+	/** Ждёт завершения всех принятых обновлений. */
+	drain() {
+		return this.#engine.drain();
+	}
+	/** Снимает подписки `on()` и `once()`. Остальные обработчики остаются. */
+	removeAllListeners() {
+		this.#engine.removeAllListeners();
+	}
+	/** Кадр `connected` — не обновление, а подтверждение подключения. */
+	#handleFrame(event) {
+		if (event.name !== "connected") return false;
+		this.#engine.emit("ready", { userId: require_url.pickString(event.data, "userId") });
+		return true;
+	}
+	/**
+	* Загружает начальное число непрочитанных.
+	*
+	* Только при первом подключении: поток присылает счётчик сам, а лишний запрос
+	* на каждой попытке переподключения нагружал бы сервер во время недоступности сети.
+	*/
+	async #syncUnreadCount(reason, dispatch) {
+		if (reason !== "initial") return;
+		const count = await this.#deps.fetchUnreadCount();
+		dispatch({
+			type: RealtimeUpdateType.UnreadCount,
+			data: count
+		});
+	}
+	#deliver(update) {
+		if (update.type === RealtimeUpdateType.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) {
+			this.#engine.emit("unreadCount", update.data);
+			return;
+		}
+		if (update.type === RealtimeUpdateType.Unknown) return;
+		assertNeverUpdate(update);
+	}
+};
+/** Выбирает транспорт по настройкам и возможностям среды. */
+function createTransport(deps, options) {
+	const kind = options.transport ?? RealtimeTransportKind.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 } : {}
+	});
+	return new SseTransport({
+		...deps.clock ? { clock: deps.clock } : {},
+		...options.idleTimeout !== void 0 ? { idleTimeout: options.idleTimeout } : {},
+		...options.handshakeTimeout !== void 0 ? { handshakeTimeout: options.handshakeTimeout } : {}
+	});
+}
+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;
+	}
+}
+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;
+}
+function readCloseEvent(event) {
+	const close = typeof event === "object" && event !== null ? event : void 0;
+	return {
+		code: typeof close?.code === "number" ? close.code : 1006,
+		reason: typeof close?.reason === "string" ? close.reason : "",
+		wasClean: close?.wasClean === true
+	};
+}
+function readMessage(event) {
+	const data = typeof event === "object" && event !== null && "data" in event ? event.data : void 0;
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+	if (typeof Blob !== "undefined" && data instanceof Blob) return data.text();
+}
+function eventName(data) {
+	return typeof data === "object" && data !== null && "type" in data ? String(data.type) : "message";
+}
+/** Транспорт исходных realtime-событий поверх стандартного WebSocket. */
+var WebSocketTransport = class {
+	name = "ws";
+	#path;
+	#webSocketImpl;
+	#auth;
+	#idleTimeout;
+	#keepAlive;
+	#handshakeTimeout;
+	#classifyOpenFailure;
+	#clock;
+	constructor(options = {}) {
+		const path = options.path ?? "/api/ws";
+		if (typeof path !== "string" || path.trim() === "" || path.includes("?") || path.includes("#") || /^[a-z][a-z\d+.-]*:/i.test(path)) throw new require_errors.ItdConfigError("WebSocketTransport.path должен быть путём без query и fragment");
+		if (options.webSocketImpl !== void 0 && typeof options.webSocketImpl !== "function") throw new require_errors.ItdConfigError("WebSocketTransport.webSocketImpl должен быть конструктором");
+		if (options.classifyOpenFailure !== void 0 && typeof options.classifyOpenFailure !== "function") throw new require_errors.ItdConfigError("WebSocketTransport.classifyOpenFailure должен быть функцией");
+		const auth = options.auth ?? "auto";
+		if (auth !== "auto" && auth !== "query" && auth !== "header") throw new require_errors.ItdConfigError(`Неизвестный способ авторизации WebSocket: ${String(auth)}`);
+		if (auth === "header" && !options.webSocketImpl) throw new require_errors.ItdConfigError("WebSocketTransport.auth=\"header\" требует webSocketImpl с поддержкой заголовков");
+		validateDuration(options.idleTimeout, "idleTimeout");
+		validateDuration(options.keepAlive, "keepAlive");
+		validateDuration(options.handshakeTimeout, "handshakeTimeout");
+		this.#path = path;
+		this.#webSocketImpl = options.webSocketImpl;
+		this.#auth = auth;
+		this.#idleTimeout = options.idleTimeout ?? 9e4;
+		this.#keepAlive = options.keepAlive ?? 3e4;
+		this.#handshakeTimeout = options.handshakeTimeout ?? 2e4;
+		this.#classifyOpenFailure = options.classifyOpenFailure;
+		this.#clock = options.clock ?? require_url.systemClock;
+	}
+	async connect(context) {
+		if (context.signal.aborted) throw abortError(context.signal);
+		const token = context.authorize ? await context.getToken() : null;
+		if (context.signal.aborted) throw abortError(context.signal);
+		if (context.authorize && !token) throw new UnauthorizedStreamError();
+		const injected = this.#webSocketImpl !== void 0;
+		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;
+		let headers;
+		if (injected) {
+			const resolved = await context.baseHeaders(requestUrl);
+			if (context.signal.aborted) throw abortError(context.signal);
+			if (auth === "header" && token) resolved.set("Authorization", `Bearer ${token}`);
+			headers = Object.fromEntries(resolved.entries());
+		}
+		let value;
+		try {
+			value = injected ? new implementation(url, [], {
+				...headers ? { headers } : {},
+				...this.#handshakeTimeout > 0 ? { handshakeTimeout: this.#handshakeTimeout } : {}
+			}) : new implementation(url);
+		} catch (error) {
+			const detail = safeDetail(error, url, token);
+			throw new Error(`Не удалось создать WebSocket ${require_url.redactUrl(url)}${detail ? `: ${detail}` : ""}`);
+		}
+		if (!isWebSocketConnection(value)) throw new require_errors.ItdConfigError("webSocketImpl вернул объект без WebSocket-методов addEventListener, send и close");
+		try {
+			value.binaryType = "arraybuffer";
+		} catch {}
+		return this.#listen(value, url, token, context);
+	}
+	#globalImplementation() {
+		const implementation = Reflect.get(globalThis, "WebSocket");
+		if (typeof implementation !== "function") throw new require_errors.ItdConfigError("В этой среде нет WebSocket: передайте реализацию через webSocketImpl");
+		return implementation;
+	}
+	#urls(baseUrl) {
+		const request = new URL(require_cookies.joinUrl(baseUrl, this.#path));
+		const socket = new URL(request);
+		if (request.protocol === "https:") socket.protocol = "wss:";
+		else if (request.protocol === "http:") socket.protocol = "ws:";
+		else throw new require_errors.ItdConfigError(`WebSocketTransport требует baseUrl с http или https, получено: ${request.protocol}`);
+		return {
+			requestUrl: request.toString(),
+			socketUrl: socket.toString()
+		};
+	}
+	#listen(socket, url, token, context) {
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let finishing = false;
+			let opened = false;
+			let discardMessages = false;
+			let socketError;
+			let messageQueue = Promise.resolve();
+			let pendingFrames = 0;
+			let cancelHandshake;
+			let cancelIdle;
+			let cancelKeepAlive;
+			const stopSocketListeners = () => {
+				cancelHandshake?.();
+				cancelIdle?.();
+				cancelKeepAlive?.();
+				cancelHandshake = void 0;
+				cancelIdle = void 0;
+				cancelKeepAlive = void 0;
+				socket.removeEventListener("open", onOpen);
+				socket.removeEventListener("message", onMessage);
+				socket.removeEventListener("error", onError);
+				socket.removeEventListener("close", onClose);
+			};
+			const finish = (error) => {
+				if (settled) return;
+				settled = true;
+				stopSocketListeners();
+				context.signal.removeEventListener("abort", onAbort);
+				if (error !== void 0) reject(error);
+				else resolve();
+			};
+			const closeWithError = (error, code = 4e3, reason = "transport error") => {
+				if (settled || finishing) return;
+				socketError = error;
+				finishing = true;
+				stopSocketListeners();
+				try {
+					if (socket.readyState === CONNECTING || socket.readyState === OPEN) socket.close(code, reason);
+				} catch {}
+				messageQueue.then(() => finish(error), (queueError) => finish(queueError));
+			};
+			const armIdleTimer = () => {
+				cancelIdle?.();
+				if (this.#idleTimeout <= 0) return;
+				cancelIdle = this.#clock.schedule(() => {
+					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)} молчит дольше допустимого`), 4e3, "idle timeout");
+				}, this.#idleTimeout);
+			};
+			const scheduleKeepAlive = () => {
+				if (this.#keepAlive <= 0 || settled || finishing) return;
+				cancelKeepAlive = this.#clock.schedule(() => {
+					if (settled || finishing || socket.readyState !== OPEN) return;
+					try {
+						socket.send("ping");
+					} catch (error) {
+						const detail = safeDetail(error, url, token);
+						closeWithError(/* @__PURE__ */ new Error(`Не удалось отправить WebSocket ping ${require_url.redactUrl(url)}` + (detail ? `: ${detail}` : "")));
+						return;
+					}
+					scheduleKeepAlive();
+				}, this.#keepAlive);
+			};
+			const onOpen = () => {
+				if (settled || finishing || opened) return;
+				opened = true;
+				cancelHandshake?.();
+				cancelHandshake = void 0;
+				armIdleTimer();
+				scheduleKeepAlive();
+				try {
+					context.onOpen();
+				} catch (error) {
+					closeWithError(error);
+				}
+			};
+			const onMessage = (event) => {
+				if (settled || finishing) return;
+				armIdleTimer();
+				let pending;
+				try {
+					const raw = readMessage(event);
+					if (raw !== void 0) pending = Promise.resolve(raw).then((value) => ({ raw: value }), (error) => ({ error }));
+				} catch (error) {
+					pending = Promise.resolve({ error });
+				}
+				if (pending === void 0) return;
+				if (pendingFrames >= 256) {
+					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${require_url.redactUrl(url)}: очередь кадров переполнена`), 4e3, "queue overflow");
+					return;
+				}
+				pendingFrames += 1;
+				messageQueue = messageQueue.then(async () => {
+					pendingFrames -= 1;
+					if (settled || discardMessages) return;
+					const decoded = await pending;
+					if ("error" in decoded) {
+						context.onParseError(decoded.error, "[binary WebSocket frame]");
+						return;
+					}
+					const { raw } = decoded;
+					if (settled || discardMessages || raw === "pong") return;
+					let data;
+					try {
+						data = JSON.parse(raw);
+					} catch (error) {
+						context.onParseError(error, raw);
+						return;
+					}
+					context.onEvent({
+						name: eventName(data),
+						data
+					});
+				}).catch((error) => {
+					if (finishing) throw error;
+					closeWithError(error);
+				});
+			};
+			const onError = (event) => {
+				if (settled || finishing) return;
+				socketError = typeof event === "object" && event !== null && "error" in event ? event.error : event;
+			};
+			const finishClose = async (event) => {
+				const { code, reason, wasClean } = readCloseEvent(event);
+				let outcome;
+				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}` : ""}`);
+				} 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}` : ""));
+				}
+				if (!opened && context.authorize && !(outcome instanceof UnauthorizedStreamError) && this.#classifyOpenFailure) try {
+					if (await this.#classifyOpenFailure(outcome, context.signal)) outcome = new UnauthorizedStreamError();
+				} catch {}
+				if (context.signal.aborted) {
+					discardMessages = true;
+					finish(abortError(context.signal));
+					return;
+				}
+				try {
+					await messageQueue;
+					finish(outcome);
+				} catch (error) {
+					finish(error);
+				}
+			};
+			const onClose = (event) => {
+				if (settled || finishing) return;
+				if (context.signal.aborted) {
+					discardMessages = true;
+					finish(abortError(context.signal));
+					return;
+				}
+				finishing = true;
+				stopSocketListeners();
+				finishClose(event);
+			};
+			const onAbort = () => {
+				if (settled) return;
+				const error = abortError(context.signal);
+				discardMessages = true;
+				finishing = true;
+				stopSocketListeners();
+				try {
+					if (socket.readyState === CONNECTING || socket.readyState === OPEN) socket.close(NORMAL_CLOSURE, "aborted");
+				} catch {}
+				finish(error);
+			};
+			socket.addEventListener("open", onOpen);
+			socket.addEventListener("message", onMessage);
+			socket.addEventListener("error", onError);
+			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");
+			}, this.#handshakeTimeout);
+			if (context.signal.aborted) onAbort();
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Emitter", {
+	enumerable: true,
+	get: function() {
+		return Emitter;
+	}
+});
+Object.defineProperty(exports, "ItdRealtime", {
+	enumerable: true,
+	get: function() {
+		return ItdRealtime;
+	}
+});
+Object.defineProperty(exports, "RealtimeComposer", {
+	enumerable: true,
+	get: function() {
+		return RealtimeComposer;
+	}
+});
+Object.defineProperty(exports, "RealtimeRouter", {
+	enumerable: true,
+	get: function() {
+		return RealtimeRouter;
+	}
+});
+Object.defineProperty(exports, "RealtimeTransportKind", {
+	enumerable: true,
+	get: function() {
+		return RealtimeTransportKind;
+	}
+});
+Object.defineProperty(exports, "RealtimeUpdateOrigin", {
+	enumerable: true,
+	get: function() {
+		return RealtimeUpdateOrigin;
+	}
+});
+Object.defineProperty(exports, "RealtimeUpdateType", {
+	enumerable: true,
+	get: function() {
+		return RealtimeUpdateType;
+	}
+});
+Object.defineProperty(exports, "UnauthorizedStreamError", {
+	enumerable: true,
+	get: function() {
+		return UnauthorizedStreamError;
+	}
+});
+Object.defineProperty(exports, "WebSocketTransport", {
+	enumerable: true,
+	get: function() {
+		return WebSocketTransport;
+	}
+});
+Object.defineProperty(exports, "reportListenerError", {
+	enumerable: true,
+	get: function() {
+		return reportListenerError;
+	}
+});
+Object.defineProperty(exports, "runRealtimeMiddleware", {
+	enumerable: true,
+	get: function() {
+		return runRealtimeMiddleware;
+	}
+});
+Object.defineProperty(exports, "setRealtimeConnectGuard", {
+	enumerable: true,
+	get: function() {
+		return setRealtimeConnectGuard;
+	}
+});
+
+//# sourceMappingURL=websocket-sYlynrr0.cjs.map