itd-api 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_multi_storage = require("./multi-storage-D1keK2Op.cjs");
+const require_multi_storage = require("./multi-storage-C8R5Crwo.cjs");
 const require_storage = require("./storage-ycBqLBRB.cjs");
 const require_runtime = require("./runtime-CFEsf-jD.cjs");
 //#region src/core/emitter.ts
@@ -419,7 +419,7 @@ var AuthManager = class {
 		await this.#saveSession({
 			...this.#session ?? {},
 			accessToken,
-			obtainedAt: Date.now()
+			obtainedAt: this.#config.clock.now()
 		});
 		this.#emitter.emit("tokens", { accessToken });
 	}
@@ -504,12 +504,12 @@ var AuthManager = class {
 		if (!auth) return null;
 		if (typeof auth === "string") return {
 			accessToken: auth,
-			obtainedAt: Date.now()
+			obtainedAt: this.#config.clock.now()
 		};
 		if ("accessToken" in auth) return {
 			accessToken: auth.accessToken,
 			refreshToken: auth.refreshToken,
-			obtainedAt: Date.now()
+			obtainedAt: this.#config.clock.now()
 		};
 		return null;
 	}
@@ -557,7 +557,7 @@ var AuthManager = class {
 				...this.#session ?? {},
 				accessToken,
 				...rotated ? { refreshToken: rotated } : {},
-				obtainedAt: Date.now()
+				obtainedAt: this.#config.clock.now()
 			});
 			this.#emitter.emit("tokens", { accessToken });
 			return accessToken;
@@ -632,7 +632,7 @@ var AuthManager = class {
 		this.#transitionAuth(accessToken);
 		await this.#saveSession({
 			accessToken,
-			obtainedAt: Date.now()
+			obtainedAt: this.#config.clock.now()
 		});
 		this.#emitter.emit("tokens", { accessToken });
 		this.#emitter.emit("signIn", { accessToken });
@@ -640,6 +640,16 @@ var AuthManager = class {
 	}
 };
 //#endregion
+//#region src/core/clock.ts
+/** Системные часы, используемые клиентом по умолчанию. */
+const systemClock = Object.freeze({
+	now: () => Date.now(),
+	schedule(callback, delay) {
+		const timer = setTimeout(callback, delay);
+		return () => clearTimeout(timer);
+	}
+});
+//#endregion
 //#region src/core/url.ts
 /**
 * Собирает строку запроса.
@@ -717,7 +727,7 @@ function normalizeBaseUrl(baseUrl) {
 //#endregion
 //#region src/core/version.ts
 /** Версия библиотеки. Попадает в `User-Agent`. */
-const LIBRARY_VERSION = "0.2.0";
+const LIBRARY_VERSION = "0.4.0";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -945,6 +955,7 @@ function resolveConfig(options = {}) {
 	const mode = options.mode ?? require_runtime.RuntimeMode.Auto;
 	if (!Object.values(require_runtime.RuntimeMode).includes(mode)) throw new require_storage.ItdConfigError(`mode должен быть одним из ${Object.values(require_runtime.RuntimeMode).join(", ")}, получено: ${mode}`);
 	const timeout = requirePositive(options.timeout ?? 3e4, "timeout");
+	if (options.clock !== void 0 && (typeof options.clock !== "object" || options.clock === null || typeof options.clock.now !== "function" || typeof options.clock.schedule !== "function")) throw new require_storage.ItdConfigError("clock должен предоставлять методы now() и schedule()");
 	requireOptionalBoolean(options.autoRefresh, "autoRefresh");
 	requireOptionalBoolean(options.reloginOnRefreshFailure, "reloginOnRefreshFailure");
 	if (options.userAgent !== void 0 && options.userAgent !== false && typeof options.userAgent !== "string") throw new require_storage.ItdConfigError("userAgent должен быть строкой или false");
@@ -957,6 +968,7 @@ function resolveConfig(options = {}) {
 		autoRefresh: options.autoRefresh ?? true,
 		reloginOnRefreshFailure: options.reloginOnRefreshFailure ?? true,
 		fetch: require_runtime.resolveFetch(options.fetch),
+		clock: options.clock ?? systemClock,
 		timeout,
 		retry: resolveRetry(options.retry),
 		rateLimit: resolveRateLimit(options.rateLimit),
@@ -1040,15 +1052,271 @@ function withLayerHeaders(request, headers) {
 	};
 }
 //#endregion
-//#region src/core/plugins.ts
-/** Пустой набор — отдаётся, пока плагинов нет, чтобы не заводить объект на каждый запрос. */
-const NO_KEYS = /* @__PURE__ */ new Set();
+//#region src/core/plugins/hooks.ts
+const REQUEST_HOOK_DISPATCHERS = /* @__PURE__ */ new WeakMap();
+const PLUGIN_HOOK_SCOPE = Symbol("itd-api.plugin-hooks");
+/** Создаёт динамический набор hooks, связанный с диспетчером registry. @internal */
+function createRequestHooks(dispatcher) {
+	const hooks = {};
+	REQUEST_HOOK_DISPATCHERS.set(hooks, dispatcher);
+	return hooks;
+}
+/** Привязывает к запросу неизменяемый снимок plugin hooks. @internal */
+function withRequestHookScope(request, hooks) {
+	const scoped = request;
+	return scoped[PLUGIN_HOOK_SCOPE] === hooks ? scoped : {
+		...request,
+		[PLUGIN_HOOK_SCOPE]: hooks
+	};
+}
+/** Читает снимок plugin hooks, привязанный к логическому запросу. @internal */
+function requestHookScope(request) {
+	return request[PLUGIN_HOOK_SCOPE] ?? [];
+}
+/**
+* Вызывает публичный хук, сохраняя привязанный к логическому запросу снимок плагинов.
+*
+* Обычные наборы хуков по-прежнему получают только публичный контекст. Дополнительный
+* аргумент используется исключительно внутренним составным набором PluginRegistry.
+*
+* @internal
+*/
+async function dispatchRequestHook(hooks, field, context, request) {
+	const dispatcher = REQUEST_HOOK_DISPATCHERS.get(hooks);
+	if (dispatcher) {
+		await dispatcher(field, context, request);
+		return;
+	}
+	const hook = hooks[field];
+	await hook?.(context);
+}
+//#endregion
+//#region src/core/retry.ts
+/**
+* Методы, повтор которых безопасен по определению.
+*
+* `DELETE` формально тоже идемпотентен, но его повтор после успеха вернёт `404`
+* и собьёт с толку — в список он не входит.
+*/
+const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+/**
+* Стоит ли повторять запрос после этой ошибки.
+*
+* Отдельно разобран `429`: он повторяется даже для запросов на запись, потому что
+* гарантирует, что запрос **не был обработан**. Обрыв сети и `5xx` такой гарантии не дают —
+* сервер мог успеть создать пост, — поэтому запись по умолчанию не повторяется.
+*/
+function isRetryable(error, method, retryWrites, retryNetworkWrite) {
+	if (error instanceof require_storage.ItdAbortError) return false;
+	const safeToRepeat = retryWrites || IDEMPOTENT_METHODS.has(method);
+	if (error instanceof require_storage.ItdApiError) {
+		if (error.status === 429) return true;
+		if (error.status >= 500) return safeToRepeat;
+		return false;
+	}
+	if (error instanceof require_storage.ItdNetworkError || error instanceof require_storage.ItdTimeoutError) return safeToRepeat || retryNetworkWrite;
+	if (error instanceof require_storage.ItdFileError) return error.retryable && (safeToRepeat || retryNetworkWrite);
+	return false;
+}
+/** Экспоненциальная пауза со случайным разбросом. */
+function backoffDelay(attempt, options, random) {
+	const exponential = options.baseDelay * 2 ** (attempt - 1);
+	const capped = Math.min(exponential, options.maxDelay);
+	const spread = capped * options.jitter * (random() * 2 - 1);
+	return Math.max(0, Math.round(capped + spread));
+}
+/**
+* Собирает планировщик повторов для транспорта.
+*
+* Поведение при `Retry-After`: пауза, названная сервером, соблюдается точно — она
+* авторитетнее нашего расчёта. Но если сервер просит ждать дольше, чем `maxDelay`,
+* повтор **не выполняется вовсе**: молча спать десять минут внутри вызова библиотека
+* не должна, лучше отдать {@link ItdRateLimitError} и дать решить вызывающему коду.
+*
+* @param options настройки повторов после подстановки значений по умолчанию
+* @param random источник случайности; подменяется в тестах ради предсказуемости
+*
+* @example
+* ```ts
+* const scheduler = createRetryScheduler(config.retry);
+* const delay = scheduler(error, 1, 'GET'); // 500 мс ± 30%
+* ```
+*/
+function createRetryScheduler(options, random = Math.random) {
+	return (error, attempt, method, retryNetworkWrite = false) => {
+		if (attempt >= options.attempts) return void 0;
+		if (options.shouldRetry) return options.shouldRetry(error, attempt) ? backoffDelay(attempt, options, random) : void 0;
+		if (!isRetryable(error, method, options.retryWrites, retryNetworkWrite)) return void 0;
+		if (error instanceof require_storage.ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
+		return backoffDelay(attempt, options, random);
+	};
+}
+//#endregion
+//#region src/core/middleware.ts
+/** Ожидание повтора, которое уважает отмену запроса. */
+function sleep(clock, ms, signal) {
+	if (!signal) return new Promise((resolve) => clock.schedule(resolve, ms));
+	if (signal.aborted) return Promise.reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
+	return new Promise((resolve, reject) => {
+		const cancel = clock.schedule(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			cancel();
+			reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Слой очереди: ограничение конкурентности и частоты.
+*
+* `skipQueue` пропускает запрос мимо очереди — так поступают служебные запросы, которые
+* порождены изнутри другого запроса и не могут ждать освободившегося слота.
+*
+* Очередь выбирается по запросу: у каждого сервиса платформы свой хост и свой лимит.
+*/
+function createQueueMiddleware(schedule) {
+	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
+}
+/**
+* Слой плагинов.
+*
+* Стоит снаружи повторов и внутри очереди: плагин должен увидеть запрос и ответ по одному
+* разу, независимо от числа попыток, — иначе, например, текст поста зашифруется дважды.
+*/
+function createPluginsMiddleware(plugins) {
+	return (request, next) => plugins.run(request, next);
+}
+/**
+* Слой сервисов.
+*
+* Запросу с полем `service` подставляет хост сервиса, его заголовки и `skipAuth`, если
+* сервис объявлен публичным. Заданный у запроса `baseUrl` не трогает.
+*
+* Стоит снаружи повторов и авторизации, чтобы выставленный здесь `skipAuth` был ей виден.
+*/
+function createServicesMiddleware(registry) {
+	return async (request, next) => {
+		const service = request.service === void 0 ? void 0 : registry.require(request.service);
+		let prepared = request;
+		if (request.baseUrl !== void 0) {
+			const baseUrl = normalizeBaseUrl(request.baseUrl);
+			if (baseUrl !== request.baseUrl) prepared = {
+				...prepared,
+				baseUrl
+			};
+			if (!(service?.baseUrl === baseUrl ? service.auth !== false : registry.isPrimarySite(baseUrl)) && prepared.skipAuth === void 0) prepared = {
+				...prepared,
+				skipAuth: true
+			};
+		}
+		if (!service) return next(prepared);
+		if (prepared.baseUrl === void 0) prepared = {
+			...prepared,
+			baseUrl: service.baseUrl
+		};
+		if (service.headers) prepared = withLayerHeaders(prepared, service.headers);
+		if (service.auth === false && prepared.skipAuth === void 0) prepared = {
+			...prepared,
+			skipAuth: true
+		};
+		return next(prepared);
+	};
+}
+async function applyAuth(request, deps) {
+	if (request.skipAuth) return request;
+	const headers = await deps.getAuthHeaders();
+	return Object.keys(headers).length > 0 ? withLayerHeaders(request, headers) : request;
+}
+/**
+* Слой авторизации.
+*
+* Подставляет заголовок `Authorization` и обрабатывает `401`: обновляет токен и повторяет
+* запрос ровно один раз. Стоит внутри повторов, поэтому обычным попыткам он не виден —
+* они уже работают со свежим токеном.
+*/
+function createAuthMiddleware(deps) {
+	return async (request, next) => {
+		const authorized = await applyAuth(request, deps);
+		try {
+			return await next(authorized);
+		} catch (error) {
+			if (request.skipAuthRefresh || !deps.autoRefresh || !require_storage.isItdApiError(error) || error.status !== 401) throw error;
+			if (!await deps.onUnauthorized()) throw error;
+			return next(await applyAuth({
+				...request,
+				skipAuthRefresh: true
+			}, deps));
+		}
+	};
+}
+/**
+* Выбирает планировщик отката для конкретного запроса.
+*
+* `retry` у запроса переопределяет глобальную настройку: `false` выключает повторы,
+* объект задаёт свои. Обработка `429` от этого не зависит — она общая.
+*/
+function resolveBackoff(retry, global) {
+	if (retry === void 0) return global;
+	if (retry === false) return void 0;
+	const resolved = resolveRetry(retry);
+	return resolved ? createRetryScheduler(resolved) : void 0;
+}
 /**
-* Имена, которые плагин заявить не может.
+* Слой повторов.
 *
-* Заявленные опции ресурсы переносят в описание запроса поверх собранных полей, поэтому
-* имя из {@link RawRequestOptions} подменило бы путь, тело или заголовки любого вызова.
+* Ответ `429` обрабатывается отдельно от прочих ошибок лестницей пауз и с придержанием
+* всей очереди; сетевые сбои и `5xx` — экспоненциальным откатом. Настройка `retry`
+* у отдельного запроса имеет приоритет над глобальной.
 */
+function createRetryMiddleware(deps) {
+	const globalScheduler = deps.retry ? createRetryScheduler(deps.retry) : void 0;
+	const nextDelay = (error, attempt, request, method, backoff) => {
+		if (require_storage.isItdRateLimitError(error)) {
+			const wait = error.retryAfter ?? deps.rateLimitDelays[attempt - 1];
+			if (wait === void 0) return void 0;
+			deps.pauseQueue?.(wait, request);
+			deps.logger?.debug(`лимит частоты, попытка ${attempt + 1} через ${wait} мс`);
+			return wait;
+		}
+		return backoff?.(error, attempt, method, request.retryNetworkWrite ?? false);
+	};
+	return async (request, next) => {
+		const method = request.method.toUpperCase();
+		const backoff = resolveBackoff(request.retry, globalScheduler);
+		for (let attempt = 1;; attempt++) try {
+			return await next({
+				...request,
+				attempt
+			});
+		} catch (error) {
+			const delay = nextDelay(error, attempt, request, method, backoff);
+			if (delay === void 0) throw error;
+			await dispatchRequestHook(deps.hooks, "onRetry", {
+				method,
+				path: request.path,
+				url: deps.buildUrl(request),
+				headers: new Headers({
+					...request.layerHeaders,
+					...request.headers
+				}),
+				attempt,
+				error,
+				delay
+			}, request);
+			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${attempt + 1} через ${delay} мс`);
+			await sleep(deps.clock ?? systemClock, delay, request.signal);
+		}
+	};
+}
+//#endregion
+//#region src/core/plugins/order.ts
 const RESERVED_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"signal",
 	"timeout",
@@ -1089,7 +1357,8 @@ function validateNameList(plugin, field) {
 		seen.add(value);
 	}
 }
-function validateHooks(plugin, hooks) {
+/** Проверяет набор hooks, переданный плагином. @internal */
+function validatePluginHooks(plugin, hooks) {
 	if (typeof hooks !== "object" || hooks === null) throw new require_storage.ItdConfigError(`плагин «${plugin}» передал в useHooks() не объект`);
 	for (const field of HOOK_FIELDS) if (hooks[field] !== void 0 && typeof hooks[field] !== "function") throw new require_storage.ItdConfigError(`плагин «${plugin}»: useHooks().${field} должен быть функцией`);
 }
@@ -1176,32 +1445,16 @@ function orderPluginDefinitions(plugins) {
 	if (ordered.length !== entries.length) throw new require_storage.ItdConfigError(`циклический порядок плагинов: ${entries.filter(({ plugin }) => (indegree.get(plugin.name) ?? 0) > 0).map(({ plugin }) => plugin.name).join(" → ")}`);
 	return ordered;
 }
-/** Проверяет, можно ли удалить плагин, не нарушив обязательные зависимости. @internal */
+/** Проверяет, можно ли удалить плагин без нарушения обязательных зависимостей. @internal */
 function assertPluginRemovable(plugins, name) {
 	const dependent = plugins.find((plugin) => plugin.requires?.includes(name));
 	if (dependent) throw new require_storage.ItdConfigError(`нельзя отключить плагин «${name}»: от него зависит «${dependent.name}»`);
 }
-const REQUEST_HOOK_DISPATCHERS = /* @__PURE__ */ new WeakMap();
-const PLUGIN_HOOK_SCOPE = Symbol("itd-api.plugin-hooks");
+//#endregion
+//#region src/core/plugins/registry.ts
+const NO_KEYS = /* @__PURE__ */ new Set();
 /**
-* Вызывает публичный хук, сохраняя привязанный к логическому запросу снимок плагинов.
-*
-* Обычные наборы хуков по-прежнему получают только публичный контекст. Дополнительный
-* аргумент используется исключительно внутренним составным набором PluginRegistry.
-*
-* @internal
-*/
-async function dispatchRequestHook(hooks, field, context, request) {
-	const dispatcher = REQUEST_HOOK_DISPATCHERS.get(hooks);
-	if (dispatcher) {
-		await dispatcher(field, context, request);
-		return;
-	}
-	const hook = hooks[field];
-	await hook?.(context);
-}
-/**
-* Список подключённых плагинов и собранная из них цепочка обёрток.
+* Список подключённых плагинов и собранная из них цепочка обёрток.
 *
 * Живёт в клиенте, а работает в транспорте: {@link HttpClient} прогоняет через `run`
 * каждый запрос, если плагины есть.
@@ -1257,7 +1510,7 @@ var PluginRegistry = class {
 				transformers.push(transformer);
 			},
 			useHooks: (value) => {
-				validateHooks(plugin.name, value);
+				validatePluginHooks(plugin.name, value);
 				hooks.push({ ...value });
 			}
 		});
@@ -1339,9 +1592,7 @@ var PluginRegistry = class {
 	* со следующего логического запроса без пересоздания транспорта.
 	*/
 	hooks(base) {
-		const hooks = {};
-		REQUEST_HOOK_DISPATCHERS.set(hooks, ((field, context, request) => this.#runHook(field, context, request, base)));
-		return hooks;
+		return createRequestHooks((field, context, request) => this.#runHook(field, context, request, base));
 	}
 	/**
 	* Прогоняет запрос через цепочку обёрток.
@@ -1355,10 +1606,7 @@ var PluginRegistry = class {
 		const entries = [...this.#ordered];
 		for (const entry of entries) entry.activeRequests += 1;
 		const hookScope = entries.flatMap((entry) => entry.hooks);
-		const scoped = (current) => current[PLUGIN_HOOK_SCOPE] === hookScope ? current : {
-			...current,
-			[PLUGIN_HOOK_SCOPE]: hookScope
-		};
+		const scoped = (current) => withRequestHookScope(current, hookScope);
 		const chain = entries.flatMap((entry) => entry.transformers).reduceRight((next, transformer) => (current) => transformer(scoped(current), (prepared) => next(scoped(prepared))), (current) => execute(scoped(current)));
 		try {
 			return await chain(scoped(request));
@@ -1392,239 +1640,13 @@ var PluginRegistry = class {
 	async #runHook(field, context, request, base) {
 		const baseHook = base[field];
 		await baseHook?.(context);
-		const scope = request[PLUGIN_HOOK_SCOPE] ?? [];
-		for (const hooks of scope) {
+		for (const hooks of requestHookScope(request)) {
 			const hook = hooks[field];
 			await hook?.(context);
 		}
 	}
 };
 //#endregion
-//#region src/core/retry.ts
-/**
-* Методы, повтор которых безопасен по определению.
-*
-* `DELETE` формально тоже идемпотентен, но его повтор после успеха вернёт `404`
-* и собьёт с толку — в список он не входит.
-*/
-const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-/**
-* Стоит ли повторять запрос после этой ошибки.
-*
-* Отдельно разобран `429`: он повторяется даже для запросов на запись, потому что
-* гарантирует, что запрос **не был обработан**. Обрыв сети и `5xx` такой гарантии не дают —
-* сервер мог успеть создать пост, — поэтому запись по умолчанию не повторяется.
-*/
-function isRetryable(error, method, retryWrites, retryNetworkWrite) {
-	if (error instanceof require_storage.ItdAbortError) return false;
-	const safeToRepeat = retryWrites || IDEMPOTENT_METHODS.has(method);
-	if (error instanceof require_storage.ItdApiError) {
-		if (error.status === 429) return true;
-		if (error.status >= 500) return safeToRepeat;
-		return false;
-	}
-	if (error instanceof require_storage.ItdNetworkError || error instanceof require_storage.ItdTimeoutError) return safeToRepeat || retryNetworkWrite;
-	if (error instanceof require_storage.ItdFileError) return error.retryable && (safeToRepeat || retryNetworkWrite);
-	return false;
-}
-/** Экспоненциальная пауза со случайным разбросом. */
-function backoffDelay(attempt, options, random) {
-	const exponential = options.baseDelay * 2 ** (attempt - 1);
-	const capped = Math.min(exponential, options.maxDelay);
-	const spread = capped * options.jitter * (random() * 2 - 1);
-	return Math.max(0, Math.round(capped + spread));
-}
-/**
-* Собирает планировщик повторов для транспорта.
-*
-* Поведение при `Retry-After`: пауза, названная сервером, соблюдается точно — она
-* авторитетнее нашего расчёта. Но если сервер просит ждать дольше, чем `maxDelay`,
-* повтор **не выполняется вовсе**: молча спать десять минут внутри вызова библиотека
-* не должна, лучше отдать {@link ItdRateLimitError} и дать решить вызывающему коду.
-*
-* @param options настройки повторов после подстановки значений по умолчанию
-* @param random источник случайности; подменяется в тестах ради предсказуемости
-*
-* @example
-* ```ts
-* const scheduler = createRetryScheduler(config.retry);
-* const delay = scheduler(error, 1, 'GET'); // 500 мс ± 30%
-* ```
-*/
-function createRetryScheduler(options, random = Math.random) {
-	return (error, attempt, method, retryNetworkWrite = false) => {
-		if (attempt >= options.attempts) return void 0;
-		if (options.shouldRetry) return options.shouldRetry(error, attempt) ? backoffDelay(attempt, options, random) : void 0;
-		if (!isRetryable(error, method, options.retryWrites, retryNetworkWrite)) return void 0;
-		if (error instanceof require_storage.ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
-		return backoffDelay(attempt, options, random);
-	};
-}
-//#endregion
-//#region src/core/middleware.ts
-/** Ожидание повтора, которое уважает отмену запроса. */
-function sleep(ms, signal) {
-	if (!signal) return new Promise((resolve) => setTimeout(resolve, ms));
-	if (signal.aborted) return Promise.reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
-/**
-* Слой очереди: ограничение конкурентности и частоты.
-*
-* `skipQueue` пропускает запрос мимо очереди — так поступают служебные запросы, которые
-* порождены изнутри другого запроса и не могут ждать освободившегося слота.
-*
-* Очередь выбирается по запросу: у каждого сервиса платформы свой хост и свой лимит.
-*/
-function createQueueMiddleware(schedule) {
-	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
-}
-/**
-* Слой плагинов.
-*
-* Стоит снаружи повторов и внутри очереди: плагин должен увидеть запрос и ответ по одному
-* разу, независимо от числа попыток, — иначе, например, текст поста зашифруется дважды.
-*/
-function createPluginsMiddleware(plugins) {
-	return (request, next) => plugins.run(request, next);
-}
-/**
-* Слой сервисов.
-*
-* Запросу с полем `service` подставляет хост сервиса, его заголовки и `skipAuth`, если
-* сервис объявлен публичным. Заданный у запроса `baseUrl` не трогает.
-*
-* Стоит снаружи повторов и авторизации, чтобы выставленный здесь `skipAuth` был ей виден.
-*/
-function createServicesMiddleware(registry) {
-	return async (request, next) => {
-		const service = request.service === void 0 ? void 0 : registry.require(request.service);
-		let prepared = request;
-		if (request.baseUrl !== void 0) {
-			const baseUrl = normalizeBaseUrl(request.baseUrl);
-			if (baseUrl !== request.baseUrl) prepared = {
-				...prepared,
-				baseUrl
-			};
-			if (!(service?.baseUrl === baseUrl ? service.auth !== false : registry.isPrimarySite(baseUrl)) && prepared.skipAuth === void 0) prepared = {
-				...prepared,
-				skipAuth: true
-			};
-		}
-		if (!service) return next(prepared);
-		if (prepared.baseUrl === void 0) prepared = {
-			...prepared,
-			baseUrl: service.baseUrl
-		};
-		if (service.headers) prepared = withLayerHeaders(prepared, service.headers);
-		if (service.auth === false && prepared.skipAuth === void 0) prepared = {
-			...prepared,
-			skipAuth: true
-		};
-		return next(prepared);
-	};
-}
-async function applyAuth(request, deps) {
-	if (request.skipAuth) return request;
-	const headers = await deps.getAuthHeaders();
-	return Object.keys(headers).length > 0 ? withLayerHeaders(request, headers) : request;
-}
-/**
-* Слой авторизации.
-*
-* Подставляет заголовок `Authorization` и обрабатывает `401`: обновляет токен и повторяет
-* запрос ровно один раз. Стоит внутри повторов, поэтому обычным попыткам он не виден —
-* они уже работают со свежим токеном.
-*/
-function createAuthMiddleware(deps) {
-	return async (request, next) => {
-		const authorized = await applyAuth(request, deps);
-		try {
-			return await next(authorized);
-		} catch (error) {
-			if (request.skipAuthRefresh || !deps.autoRefresh || !require_storage.isItdApiError(error) || error.status !== 401) throw error;
-			if (!await deps.onUnauthorized()) throw error;
-			return next(await applyAuth({
-				...request,
-				skipAuthRefresh: true
-			}, deps));
-		}
-	};
-}
-/**
-* Выбирает планировщик отката для конкретного запроса.
-*
-* `retry` у запроса переопределяет глобальную настройку: `false` выключает повторы,
-* объект задаёт свои. Обработка `429` от этого не зависит — она общая.
-*/
-function resolveBackoff(retry, global) {
-	if (retry === void 0) return global;
-	if (retry === false) return void 0;
-	const resolved = resolveRetry(retry);
-	return resolved ? createRetryScheduler(resolved) : void 0;
-}
-/**
-* Слой повторов.
-*
-* Ответ `429` обрабатывается отдельно от прочих ошибок лестницей пауз и с придержанием
-* всей очереди; сетевые сбои и `5xx` — экспоненциальным откатом. Настройка `retry`
-* у отдельного запроса имеет приоритет над глобальной.
-*/
-function createRetryMiddleware(deps) {
-	const globalScheduler = deps.retry ? createRetryScheduler(deps.retry) : void 0;
-	const nextDelay = (error, attempt, request, method, backoff) => {
-		if (require_storage.isItdRateLimitError(error)) {
-			const wait = error.retryAfter ?? deps.rateLimitDelays[attempt - 1];
-			if (wait === void 0) return void 0;
-			deps.pauseQueue?.(wait, request);
-			deps.logger?.debug(`лимит частоты, попытка ${attempt + 1} через ${wait} мс`);
-			return wait;
-		}
-		return backoff?.(error, attempt, method, request.retryNetworkWrite ?? false);
-	};
-	return async (request, next) => {
-		const method = request.method.toUpperCase();
-		const backoff = resolveBackoff(request.retry, globalScheduler);
-		for (let attempt = 1;; attempt++) try {
-			return await next({
-				...request,
-				attempt
-			});
-		} catch (error) {
-			const delay = nextDelay(error, attempt, request, method, backoff);
-			if (delay === void 0) throw error;
-			await dispatchRequestHook(deps.hooks, "onRetry", {
-				method,
-				path: request.path,
-				url: deps.buildUrl(request),
-				headers: new Headers({
-					...request.layerHeaders,
-					...request.headers
-				}),
-				attempt,
-				error,
-				delay
-			}, request);
-			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${attempt + 1} через ${delay} мс`);
-			await sleep(delay, request.signal);
-		}
-	};
-}
-//#endregion
 //#region src/core/rate-limit.ts
 /** Ошибка отмены запроса, который ещё не дошёл до транспорта. */
 function queueAbortError() {
@@ -1649,10 +1671,12 @@ var RequestQueue = class {
 	#active = 0;
 	/** Момент, раньше которого следующий запрос стартовать не должен. */
 	#nextSlot = 0;
-	#timer;
-	constructor(options) {
+	#clock;
+	#cancelTimer;
+	constructor(options, clock = systemClock) {
 		this.#concurrency = options.concurrency;
 		this.#minGap = options.rps ? 1e3 / options.rps : 0;
+		this.#clock = clock;
 	}
 	/** Сколько задач выполняется прямо сейчас. */
 	get active() {
@@ -1704,9 +1728,9 @@ var RequestQueue = class {
 	* ошибкой `ItdAbortError`. Уже выполняющиеся задачи доводятся до конца.
 	*/
 	stop() {
-		if (this.#timer !== void 0) {
-			clearTimeout(this.#timer);
-			this.#timer = void 0;
+		if (this.#cancelTimer) {
+			this.#cancelTimer();
+			this.#cancelTimer = void 0;
 		}
 		this.#nextSlot = 0;
 		const pending = this.#waiting.splice(0, this.#waiting.length);
@@ -1720,23 +1744,23 @@ var RequestQueue = class {
 	*/
 	pause(ms) {
 		if (ms <= 0) return;
-		this.#nextSlot = Math.max(this.#nextSlot, Date.now() + ms);
+		this.#nextSlot = Math.max(this.#nextSlot, this.#clock.now() + ms);
 	}
 	/** Запускает столько ожидающих задач, сколько позволяют ограничения. */
 	#drain() {
 		if (this.#waiting.length === 0) {
-			if (this.#timer !== void 0) {
-				clearTimeout(this.#timer);
-				this.#timer = void 0;
+			if (this.#cancelTimer) {
+				this.#cancelTimer();
+				this.#cancelTimer = void 0;
 			}
 			return;
 		}
 		if (this.#active >= this.#concurrency) return;
-		if (this.#timer !== void 0) return;
-		const now = Date.now();
+		if (this.#cancelTimer) return;
+		const now = this.#clock.now();
 		if (this.#nextSlot > now) {
-			this.#timer = setTimeout(() => {
-				this.#timer = void 0;
+			this.#cancelTimer = this.#clock.schedule(() => {
+				this.#cancelTimer = void 0;
 				this.#drain();
 			}, this.#nextSlot - now);
 			return;
@@ -1755,19 +1779,21 @@ var RequestQueue = class {
 */
 var RequestQueuePool = class {
 	#options;
+	#clock;
 	#main;
 	/** Очереди сервисов заводятся при первом запросе — обычно не нужна ни одна. */
 	#byService = /* @__PURE__ */ new Map();
-	constructor(options) {
+	constructor(options, clock = systemClock) {
 		this.#options = options;
-		this.#main = new RequestQueue(options);
+		this.#clock = clock;
+		this.#main = new RequestQueue(options, clock);
 	}
 	/** Очередь хоста. */
 	for(service) {
 		if (service === void 0) return this.#main;
 		let queue = this.#byService.get(service);
 		if (!queue) {
-			queue = new RequestQueue(this.#options);
+			queue = new RequestQueue(this.#options, this.#clock);
 			this.#byService.set(service, queue);
 		}
 		return queue;
@@ -2215,7 +2241,7 @@ function createApiError(context) {
 		path: context.path,
 		raw: safeRawBody(context.body),
 		response: context.response,
-		retryAfter: parseRetryAfter(context.headers?.get("retry-after"))
+		retryAfter: parseRetryAfter(context.headers?.get("retry-after"), context.now)
 	};
 	if (parsed.code === "PHONE_VERIFICATION_REQUIRED") return new require_storage.ItdPhoneVerificationError({
 		...init,
@@ -2291,13 +2317,13 @@ function abortable(promise, signal) {
 * Реализовано вручную, а не через `AbortSignal.any`: последний появился только в Node 20,
 * а библиотека поддерживает Node 18.
 */
-function createAbortBundle(userSignal, timeout) {
+function createAbortBundle(userSignal, timeout, clock) {
 	const controller = new AbortController();
 	let timedOut = false;
 	const onUserAbort = () => controller.abort(userSignal?.reason);
 	if (userSignal) if (userSignal.aborted) controller.abort(userSignal.reason);
 	else userSignal.addEventListener("abort", onUserAbort, { once: true });
-	const timer = timeout > 0 ? setTimeout(() => {
+	const cancelTimer = timeout > 0 ? clock.schedule(() => {
 		timedOut = true;
 		controller.abort();
 	}, timeout) : void 0;
@@ -2305,7 +2331,7 @@ function createAbortBundle(userSignal, timeout) {
 		signal: controller.signal,
 		timedOut: () => timedOut,
 		cleanup: () => {
-			if (timer !== void 0) clearTimeout(timer);
+			cancelTimer?.();
 			userSignal?.removeEventListener("abort", onUserAbort);
 		}
 	};
@@ -2342,8 +2368,8 @@ var Transport = class {
 		const headers = await this.#buildHeaders(request, url);
 		const attempt = request.attempt ?? 1;
 		const timeout = request.timeout ?? this.#config.timeout;
-		const abort = createAbortBundle(request.signal, timeout);
-		const startedAt = Date.now();
+		const abort = createAbortBundle(request.signal, timeout, this.#config.clock);
+		const startedAt = this.#config.clock.now();
 		let cleanupBody;
 		try {
 			let body;
@@ -2362,7 +2388,7 @@ var Transport = class {
 				};
 				await dispatchRequestHook(this.#config.hooks, "onError", {
 					...context,
-					duration: Date.now() - startedAt,
+					duration: this.#config.clock.now() - startedAt,
 					error: failure
 				}, request);
 				throw failure;
@@ -2391,7 +2417,7 @@ var Transport = class {
 				if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) init.duplex = "half";
 				response = await this.#config.fetch(url, init);
 			} catch (error) {
-				const duration = Date.now() - startedAt;
+				const duration = this.#config.clock.now() - startedAt;
 				const failure = this.#toTransportError(error, abort, request, method, timeout);
 				await dispatchRequestHook(this.#config.hooks, "onError", {
 					...context,
@@ -2409,16 +2435,17 @@ var Transport = class {
 			if (response.ok) await dispatchRequestHook(this.#config.hooks, "onResponse", {
 				...context,
 				status: response.status,
-				duration: Date.now() - startedAt,
+				duration: this.#config.clock.now() - startedAt,
 				response
 			}, request);
 			const payload = await this.#readBodyOrFail(response, context, request, method, abort, timeout);
-			const duration = Date.now() - startedAt;
+			const duration = this.#config.clock.now() - startedAt;
 			if (!response.ok) {
 				const error = createApiError({
 					method,
 					path: request.path,
 					status: response.status,
+					now: this.#config.clock.now(),
 					statusText: response.statusText,
 					headers: response.headers,
 					response,
@@ -2487,7 +2514,7 @@ var Transport = class {
 	}
 	/** Читает тело и преобразует ошибку чтения в транспортную ошибку библиотеки. */
 	async #readBodyOrFail(response, context, request, method, abort, timeout) {
-		const startedAt = Date.now();
+		const startedAt = this.#config.clock.now();
 		try {
 			return await abortable(readBody(response), abort.signal);
 		} catch (error) {
@@ -2495,7 +2522,7 @@ var Transport = class {
 			const failure = this.#toTransportError(error, abort, request, method, timeout);
 			await dispatchRequestHook(this.#config.hooks, "onError", {
 				...context,
-				duration: Date.now() - startedAt,
+				duration: this.#config.clock.now() - startedAt,
 				error: failure
 			}, request);
 			this.#config.logger?.warn(`× ${method} ${request.path}: не удалось прочитать тело ответа — ${failure.message}`);
@@ -2816,144 +2843,167 @@ const ItdErrorCode = Object.freeze({
 	WRITE_ACCESS_RESTRICTED: "WRITE_ACCESS_RESTRICTED"
 });
 //#endregion
-//#region src/notifications/type-map.ts
-/**
-* Соответствие коротких имён типов уведомлений развёрнутым.
-*
-* Сервер — и в списке, и в потоке событий — присылает короткие имена: `like`, `comment`,
-* `reply`, `repost`, `comment_like`. Развёрнутые (`post_reaction`, `post_comment`)
-* встречаются в оформлении интерфейса, поэтому библиотека приводит типы к ним:
-* они однозначно называют и объект, и действие.
-*
-* Пришедшее значение всегда остаётся в поле `rawType`.
-*/
-const NOTIFICATION_TYPE_ALIASES = Object.freeze({
-	like: NotificationType.PostReaction,
-	comment: NotificationType.PostComment,
-	comment_like: NotificationType.CommentReaction,
-	reply: NotificationType.CommentReply,
-	repost: NotificationType.PostRepost,
-	mention: NotificationType.PostMention
-});
-const KNOWN_TYPES = new Set(Object.values(NotificationType));
-/**
-* Приводит имя типа к каноническому.
-*
-* Неизвестное значение возвращается без изменений, чтобы не менять смысл нового типа
-* уведомления на другой.
-*
-* @example
-* ```ts
-* canonicalNotificationType('like');           // 'post_reaction'
-* canonicalNotificationType('post_reaction');  // 'post_reaction'
-* canonicalNotificationType('новое_событие');  // 'новое_событие'
-* ```
-*/
-function canonicalNotificationType(rawType) {
-	return NOTIFICATION_TYPE_ALIASES[rawType] ?? rawType;
-}
-/**
-* Известен ли библиотеке этот тип уведомления.
-*
-* Полезно, чтобы решить, показывать ли уведомление, для которого нет своего оформления.
-*/
-function isKnownNotificationType(type) {
-	return KNOWN_TYPES.has(canonicalNotificationType(type));
-}
-//#endregion
-//#region src/notifications/normalize.ts
-function asActor(value) {
-	if (!isRecord(value)) return void 0;
-	const id = asString(value.id);
-	if (!id) return void 0;
-	return {
-		id,
-		username: asString(value.username) ?? "",
-		displayName: asString(value.displayName) ?? "",
-		avatar: asString(value.avatar) ?? "",
-		...typeof value.isFollowing === "boolean" ? { isFollowing: value.isFollowing } : {},
-		...typeof value.isFollowedBy === "boolean" ? { isFollowedBy: value.isFollowedBy } : {}
-	};
-}
-/** Собирает участников: сервер присылает либо одного `actor`, либо массив `actors`. */
-function readActors(source) {
-	if (Array.isArray(source.actors)) return source.actors.map(asActor).filter((actor) => actor !== void 0);
-	const single = asActor(source.actor);
-	return single ? [single] : [];
-}
-/**
-* Приводит уведомление к единой форме.
-*
-* Нужна потому, что REST-список и поток событий описывают одно и то же событие по-разному:
-* различаются имена типов (`like` против `post_reaction`), имена полей
-* (`targetId`/`entityId`, `read`/`isRead`, `preview`/`entityPreview`) и число участников
-* (`actor` против массива `actors`). После приведения объекты из обоих источников
-* можно складывать в один список.
-*
-* Исходные данные не теряются: имя типа с сервера остаётся в `rawType`,
-* весь объект целиком — в `raw`.
-*
-* @param input уведомление из REST-ответа либо полезная нагрузка события потока
-*
-* @example
-* ```ts
-* const fromRest = normalizeNotification(restItem);
-* const fromStream = normalizeNotification(event.payload);
-* // одинаковая форма — можно объединять
-* ```
-*/
-function normalizeNotification(input) {
-	const source = isRecord(input) ? input : {};
-	const payload = isRecord(source.payload) ? source.payload : source;
-	const rawType = asString(payload.type) ?? asString(source.type) ?? "";
-	const createdAt = asString(payload.createdAt) ?? asString(source.createdAt) ?? "";
-	const readAt = asString(payload.readAt) ?? asString(source.readAt);
-	const isRead = typeof payload.isRead === "boolean" ? payload.isRead : typeof payload.read === "boolean" ? payload.read : Boolean(readAt);
-	const subjectId = asString(payload.subjectId);
-	const targetId = asString(payload.targetId);
-	const subjectIsComment = payload.subjectType === "comment";
-	const clickUrl = asString(payload.clickUrl);
-	return {
-		id: asString(payload.id) ?? asString(source.id) ?? "",
-		type: canonicalNotificationType(rawType),
-		rawType,
-		entityId: asString(payload.entityId) ?? (subjectIsComment ? subjectId ?? targetId : targetId) ?? null,
-		parentEntityId: asString(payload.parentEntityId) ?? (subjectIsComment ? targetId ?? null : null),
-		isRead,
-		actors: readActors(payload),
-		count: typeof payload.count === "number" && payload.count > 0 ? payload.count : 1,
-		preview: asString(payload.entityPreview) ?? asString(payload.preview) ?? null,
-		...clickUrl ? { clickUrl } : {},
-		createdAt,
-		updatedAt: asString(payload.updatedAt) ?? readAt ?? createdAt,
-		raw: input
-	};
-}
-/**
-* Разбирает событие `notification` из потока.
-*
-* Кроме самого уведомления событие несёт служебные поля уровня конверта: актуальный
-* счётчик непрочитанных и признак звука.
-*/
-function readNotificationEvent(data) {
-	const source = isRecord(data) ? data : {};
-	return {
-		notification: normalizeNotification(data),
-		unreadCount: typeof source.unreadCount === "number" ? source.unreadCount : void 0,
-		sound: source.sound === true
+//#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;
+}
+/** Выполняет промежуточные обработчики по порядку и запрещает повторный вызов `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);
 }
-/**
-* Разбирает событие `unread_count` из потока.
-*
-* Возвращает `undefined`, если сервер прислал событие без вложенного `payload`.
-*/
-function readUnreadCountEvent(data) {
-	if (!isRecord(data)) return void 0;
-	const payload = isRecord(data.payload) ? data.payload : void 0;
-	if (!payload) return void 0;
-	return typeof payload.count === "number" ? payload.count : void 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);
+		};
+	}
+	dispatch(context) {
+		let keys;
+		let middleware;
+		try {
+			keys = this.#keysFor(context);
+			middleware = this.#middleware.map(captureRealtimeMiddleware);
+		} catch (error) {
+			this.#hooks.middlewareError(error, context);
+			return;
+		}
+		this.#queue.push({
+			context,
+			middleware,
+			handlers: [...this.#handlers],
+			keys
+		});
+		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/transport.ts
 /** Ошибка, по которой видно, что сервер отверг авторизацию потока. */
@@ -2979,7 +3029,9 @@ var PollTransport = class {
 	name = "poll";
 	#interval;
 	#limit;
+	#clock;
 	constructor(options = {}) {
+		this.#clock = options.clock ?? systemClock;
 		this.#interval = options.interval ?? 15e3;
 		this.#limit = options.limit ?? 20;
 	}
@@ -3047,9 +3099,9 @@ var PollTransport = class {
 	#wait(signal) {
 		if (signal.aborted) return Promise.resolve();
 		return new Promise((resolve) => {
-			const timer = setTimeout(finish, this.#interval);
+			const cancel = this.#clock.schedule(finish, this.#interval);
 			function finish() {
-				clearTimeout(timer);
+				cancel();
 				signal.removeEventListener("abort", finish);
 				resolve();
 			}
@@ -3286,9 +3338,11 @@ var SseTransport = class {
 	name = "sse";
 	#idleTimeout;
 	#handshakeTimeout;
+	#clock;
 	/** Идентификатор последнего события — отправляется при переподключении. */
 	#lastEventId;
 	constructor(options = {}) {
+		this.#clock = options.clock ?? systemClock;
 		this.#idleTimeout = options.idleTimeout ?? 9e4;
 		this.#handshakeTimeout = options.handshakeTimeout ?? 2e4;
 	}
@@ -3316,66 +3370,274 @@ var SseTransport = class {
 			context.signal.removeEventListener("abort", relayAbort);
 		}
 	}
-	/** Выполняет запрос потока, обрывая его, если ответ не пришёл за отведённое время. */
-	async #handshake(url, headers, context, controller) {
-		let expired = false;
-		const timer = this.#handshakeTimeout > 0 ? setTimeout(() => {
-			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 {
-			if (timer !== void 0) clearTimeout(timer);
-		}
+	/** Выполняет запрос потока, обрывая его, если ответ не пришёл за отведённое время. */
+	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/notifications/type-map.ts
+/**
+* Соответствие коротких имён типов уведомлений развёрнутым.
+*
+* Сервер — и в списке, и в потоке событий — присылает короткие имена: `like`, `comment`,
+* `reply`, `repost`, `comment_like`. Развёрнутые (`post_reaction`, `post_comment`)
+* встречаются в оформлении интерфейса, поэтому библиотека приводит типы к ним:
+* они однозначно называют и объект, и действие.
+*
+* Пришедшее значение всегда остаётся в поле `rawType`.
+*/
+const NOTIFICATION_TYPE_ALIASES = Object.freeze({
+	like: NotificationType.PostReaction,
+	comment: NotificationType.PostComment,
+	comment_like: NotificationType.CommentReaction,
+	reply: NotificationType.CommentReply,
+	repost: NotificationType.PostRepost,
+	mention: NotificationType.PostMention
+});
+const KNOWN_TYPES = new Set(Object.values(NotificationType));
+/**
+* Приводит имя типа к каноническому.
+*
+* Неизвестное значение возвращается без изменений, чтобы не менять смысл нового типа
+* уведомления на другой.
+*
+* @example
+* ```ts
+* canonicalNotificationType('like');           // 'post_reaction'
+* canonicalNotificationType('post_reaction');  // 'post_reaction'
+* canonicalNotificationType('новое_событие');  // 'новое_событие'
+* ```
+*/
+function canonicalNotificationType(rawType) {
+	return NOTIFICATION_TYPE_ALIASES[rawType] ?? rawType;
+}
+/**
+* Известен ли библиотеке этот тип уведомления.
+*
+* Полезно, чтобы решить, показывать ли уведомление, для которого нет своего оформления.
+*/
+function isKnownNotificationType(type) {
+	return KNOWN_TYPES.has(canonicalNotificationType(type));
+}
+//#endregion
+//#region src/notifications/normalize.ts
+function asActor(value) {
+	if (!isRecord(value)) return void 0;
+	const id = asString(value.id);
+	if (!id) return void 0;
+	return {
+		id,
+		username: asString(value.username) ?? "",
+		displayName: asString(value.displayName) ?? "",
+		avatar: asString(value.avatar) ?? "",
+		...typeof value.isFollowing === "boolean" ? { isFollowing: value.isFollowing } : {},
+		...typeof value.isFollowedBy === "boolean" ? { isFollowedBy: value.isFollowedBy } : {}
+	};
+}
+/** Собирает участников: сервер присылает либо одного `actor`, либо массив `actors`. */
+function readActors(source) {
+	if (Array.isArray(source.actors)) return source.actors.map(asActor).filter((actor) => actor !== void 0);
+	const single = asActor(source.actor);
+	return single ? [single] : [];
+}
+/**
+* Приводит уведомление к единой форме.
+*
+* Нужна потому, что REST-список и поток событий описывают одно и то же событие по-разному:
+* различаются имена типов (`like` против `post_reaction`), имена полей
+* (`targetId`/`entityId`, `read`/`isRead`, `preview`/`entityPreview`) и число участников
+* (`actor` против массива `actors`). После приведения объекты из обоих источников
+* можно складывать в один список.
+*
+* Исходные данные не теряются: имя типа с сервера остаётся в `rawType`,
+* весь объект целиком — в `raw`.
+*
+* @param input уведомление из REST-ответа либо полезная нагрузка события потока
+*
+* @example
+* ```ts
+* const fromRest = normalizeNotification(restItem);
+* const fromStream = normalizeNotification(event.payload);
+* // одинаковая форма — можно объединять
+* ```
+*/
+function normalizeNotification(input) {
+	const source = isRecord(input) ? input : {};
+	const payload = isRecord(source.payload) ? source.payload : source;
+	const rawType = asString(payload.type) ?? asString(source.type) ?? "";
+	const createdAt = asString(payload.createdAt) ?? asString(source.createdAt) ?? "";
+	const readAt = asString(payload.readAt) ?? asString(source.readAt);
+	const isRead = typeof payload.isRead === "boolean" ? payload.isRead : typeof payload.read === "boolean" ? payload.read : Boolean(readAt);
+	const subjectId = asString(payload.subjectId);
+	const targetId = asString(payload.targetId);
+	const subjectIsComment = payload.subjectType === "comment";
+	const clickUrl = asString(payload.clickUrl);
+	return {
+		id: asString(payload.id) ?? asString(source.id) ?? "",
+		type: canonicalNotificationType(rawType),
+		rawType,
+		entityId: asString(payload.entityId) ?? (subjectIsComment ? subjectId ?? targetId : targetId) ?? null,
+		parentEntityId: asString(payload.parentEntityId) ?? (subjectIsComment ? targetId ?? null : null),
+		isRead,
+		actors: readActors(payload),
+		count: typeof payload.count === "number" && payload.count > 0 ? payload.count : 1,
+		preview: asString(payload.entityPreview) ?? asString(payload.preview) ?? null,
+		...clickUrl ? { clickUrl } : {},
+		createdAt,
+		updatedAt: asString(payload.updatedAt) ?? readAt ?? createdAt,
+		raw: input
+	};
+}
+/**
+* Разбирает событие `notification` из потока.
+*
+* Кроме самого уведомления событие несёт служебные поля уровня конверта: актуальный
+* счётчик непрочитанных и признак звука.
+*/
+function readNotificationEvent(data) {
+	const source = isRecord(data) ? data : {};
+	return {
+		notification: normalizeNotification(data),
+		unreadCount: typeof source.unreadCount === "number" ? source.unreadCount : void 0,
+		sound: source.sound === true
+	};
+}
+/**
+* Разбирает событие `unread_count` из потока.
+*
+* Возвращает `undefined`, если сервер прислал событие без вложенного `payload`.
+*/
+function readUnreadCountEvent(data) {
+	if (!isRecord(data)) return void 0;
+	const payload = isRecord(data.payload) ? data.payload : void 0;
+	if (!payload) return void 0;
+	return typeof payload.count === "number" ? payload.count : void 0;
+}
+//#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_storage.ItdConfigError("Тип уведомления не должен быть пустым");
+		return;
+	}
+	if (Array.isArray(selector)) {
+		if (selector.length === 0 || selector.some((type) => typeof type !== "string" || !type)) throw new require_storage.ItdConfigError("Список типов уведомлений должен содержать непустые строки");
+		return;
 	}
-	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 idleTimer;
-		const armIdleTimer = () => {
-			if (this.#idleTimeout <= 0) return;
-			if (idleTimer !== void 0) clearTimeout(idleTimer);
-			idleTimer = setTimeout(() => {
-				reader.cancel(/* @__PURE__ */ new Error("Поток молчит дольше допустимого")).catch(() => {});
-			}, this.#idleTimeout);
+	if (typeof selector !== "object" || selector === null) throw new require_storage.ItdConfigError("Фильтр уведомлений должен быть строкой, списком или объектом");
+	const filter = selector;
+	if (filter.type !== void 0) validateNotificationSelector(filter.type);
+	if (filter.actorId !== void 0 && typeof filter.actorId !== "string") throw new require_storage.ItdConfigError("Фильтр уведомлений: actorId должен быть строкой");
+	for (const field of ["entityId", "parentEntityId"]) {
+		const value = filter[field];
+		if (value !== void 0 && value !== null && typeof value !== "string") throw new require_storage.ItdConfigError(`Фильтр уведомлений: ${field} должен быть строкой или null`);
+	}
+	if (filter.predicate !== void 0 && typeof filter.predicate !== "function") throw new require_storage.ItdConfigError("Фильтр уведомлений: predicate должен быть функцией");
+}
+/** Преобразует транспортный кадр в одно логическое обновление. */
+function readRealtimeUpdate(event) {
+	if (event.name === "notification") return {
+		type: RealtimeUpdateType.Notification,
+		data: readNotificationEvent(event.data)
+	};
+	if (event.name === "unread_count") {
+		const count = readUnreadCountEvent(event.data);
+		return count === void 0 ? void 0 : {
+			type: RealtimeUpdateType.UnreadCount,
+			data: count
 		};
-		armIdleTimer();
-		try {
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				armIdleTimer();
-				parser.feed(decoder.decode(value, { stream: true }));
-			}
-		} finally {
-			if (idleTimer !== void 0) clearTimeout(idleTimer);
-			reader.releaseLock?.();
-		}
 	}
-};
+	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/stream.ts
 /** Способ получения событий. */
@@ -3398,6 +3660,8 @@ function validateRealtimeOptions(options) {
 		if (!Number.isFinite(value) || value < min) throw new require_storage.ItdConfigError(`realtime.${name} должен быть числом не меньше ${min}, получено: ${value}`);
 	};
 	positiveInteger(options.maxAttempts, "maxAttempts");
+	positiveInteger(options.concurrency, "concurrency");
+	if (options.concurrency === 0) throw new require_storage.ItdConfigError("realtime.concurrency должен быть больше нуля");
 	duration(options.pollInterval, "pollInterval", 1);
 	duration(options.idleTimeout, "idleTimeout", 0);
 	duration(options.handshakeTimeout, "handshakeTimeout", 0);
@@ -3406,6 +3670,7 @@ function validateRealtimeOptions(options) {
 		if (!Array.isArray(options.backoff) || options.backoff.length === 0) throw new require_storage.ItdConfigError("realtime.backoff должен быть непустым списком пауз");
 		for (const delay of options.backoff) duration(delay, "backoff", 0);
 	}
+	if (options.sequentialize !== void 0 && typeof options.sequentialize !== "function") throw new require_storage.ItdConfigError("realtime.sequentialize должен быть функцией");
 }
 /**
 * Поток уведомлений в реальном времени.
@@ -3415,22 +3680,26 @@ function validateRealtimeOptions(options) {
 *
 * @example
 * ```ts
+* import { NotificationType } from 'itd-api';
+*
 * const stream = itd.realtime();
 *
-* stream.on('notification', ({ notification, unreadCount }) => {
-*   console.log(formatNotificationText(notification), unreadCount);
+* 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;
 	#options;
 	#emitter;
+	#dispatcher;
 	#transport;
 	#maxAttempts;
 	#controller;
@@ -3445,7 +3714,7 @@ var ItdRealtime = class {
 	#wanted = false;
 	#status = RealtimeStatus.Disconnected;
 	#attempt = 0;
-	#timer;
+	#cancelTimer;
 	#detachEnvironment;
 	constructor(deps, options = {}) {
 		validateRealtimeOptions(options);
@@ -3458,6 +3727,14 @@ var ItdRealtime = class {
 			if (deps.logger) deps.logger.error(message, error);
 			else console.error(`[itd-api] ${message}`, error);
 		});
+		this.#dispatcher = new RealtimeDispatcher({
+			concurrency: options.concurrency ?? 1,
+			...options.sequentialize ? { sequentialize: options.sequentialize } : {}
+		}, {
+			deliver: (context) => this.#deliver(context.update),
+			middlewareError: (error, context) => this.#reportDispatchError("middlewareError", error, context),
+			handlerError: (error, context) => this.#reportDispatchError("handlerError", error, context)
+		});
 	}
 	/** Текущее состояние соединения. */
 	get status() {
@@ -3488,6 +3765,40 @@ var ItdRealtime = class {
 		return this.#emitter.once(event, listener);
 	}
 	/**
+	* Добавляет промежуточный обработчик нормализованных обновлений.
+	*
+	* Обработчики выполняются в порядке регистрации. Если `next()` не вызван, обновление не
+	* передаётся дальше по цепочке, асинхронным обработчикам и слушателям событий.
+	*
+	* @returns функция удаления обработчика
+	*/
+	use(middleware) {
+		if (typeof middleware !== "function") throw new require_storage.ItdConfigError("realtime.use() принимает функцию обработки");
+		return this.#dispatcher.use(middleware);
+	}
+	onUpdate(selectorOrHandler, selectedHandler) {
+		const selectAll = selectedHandler === void 0;
+		const handler = selectAll ? selectorOrHandler : selectedHandler;
+		if (typeof handler !== "function") throw new require_storage.ItdConfigError("realtime.onUpdate() принимает функцию обработчика");
+		if (!selectAll && typeof selectorOrHandler !== "function" && !Object.values(RealtimeUpdateType).includes(selectorOrHandler)) throw new require_storage.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.#dispatcher.on(predicate, handler);
+	}
+	onNotification(selector, handler) {
+		if (typeof handler !== "function") throw new require_storage.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.#dispatcher.on(predicate, handler);
+	}
+	/**
 	* Поднимает соединение.
 	*
 	* Повторный вызов при уже живом соединении ничего не делает — это защита от двойного
@@ -3498,9 +3809,14 @@ var ItdRealtime = class {
 	async connect() {
 		if (this.#wanted) return;
 		this.#wanted = true;
+		this.#deps.onConnect?.();
 		this.#attachEnvironmentListeners();
 		if (this.#options.syncCount !== false) try {
-			this.#emitter.emit("unreadCount", await this.#deps.fetchUnreadCount());
+			const count = await this.#deps.fetchUnreadCount();
+			if (this.#wanted) this.#dispatch({
+				type: RealtimeUpdateType.UnreadCount,
+				data: count
+			}, void 0, RealtimeUpdateOrigin.Sync);
 		} catch (error) {
 			this.#deps.logger?.debug("не удалось получить число непрочитанных", error);
 		}
@@ -3509,27 +3825,36 @@ var ItdRealtime = class {
 	/** Закрывает соединение и отменяет запланированные попытки. */
 	disconnect() {
 		this.#wanted = false;
-		if (this.#timer !== void 0) {
-			clearTimeout(this.#timer);
-			this.#timer = 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(RealtimeStatus.Disconnected);
 		this.#deps.onClose?.();
 	}
-	/** Снимает все подписки. Соединение при этом не закрывается. */
+	/** Ждёт завершения всех принятых обновлений. */
+	drain() {
+		return this.#dispatcher.drain();
+	}
+	/** Снимает подписки `on()` и `once()`. Остальные обработчики остаются. */
 	removeAllListeners() {
 		this.#emitter.removeAllListeners();
 	}
 	#createTransport() {
 		const kind = this.#options.transport ?? RealtimeTransportKind.Auto;
 		if (typeof kind === "object") return kind;
-		if (kind === RealtimeTransportKind.Poll || kind === RealtimeTransportKind.Auto && !require_runtime.supportsStreamingBody()) return new PollTransport({ ...this.#options.pollInterval !== void 0 ? { interval: this.#options.pollInterval } : {} });
+		if (kind === RealtimeTransportKind.Poll || kind === RealtimeTransportKind.Auto && !require_runtime.supportsStreamingBody()) return new PollTransport({
+			clock: this.#deps.clock ?? systemClock,
+			...this.#options.pollInterval !== void 0 ? { interval: this.#options.pollInterval } : {}
+		});
 		return new SseTransport({
+			clock: this.#deps.clock ?? systemClock,
 			...this.#options.idleTimeout !== void 0 ? { idleTimeout: this.#options.idleTimeout } : {},
 			...this.#options.handshakeTimeout !== void 0 ? { handshakeTimeout: this.#options.handshakeTimeout } : {}
 		});
@@ -3551,7 +3876,7 @@ var ItdRealtime = class {
 				this.#attempt = 0;
 				this.#setStatus(RealtimeStatus.Connected);
 			},
-			onEvent: (event) => this.#handleEvent(event.name, event.data),
+			onEvent: (event) => this.#handleEvent(event),
 			onParseError: (error, raw) => this.#emitter.emit("parseError", {
 				error,
 				raw
@@ -3563,25 +3888,48 @@ var ItdRealtime = class {
 			this.#handleFailure(error);
 		});
 	}
-	#handleEvent(name, data) {
-		this.#emitter.emit("message", {
-			name,
-			data
+	#handleEvent(event) {
+		if (!this.#wanted) return;
+		this.#emitter.emit("message", event);
+		if (event.name === "connected") {
+			this.#emitter.emit("ready", { userId: pickString(event.data, "userId") });
+			return;
+		}
+		const update = readRealtimeUpdate(event);
+		if (update) this.#dispatch(update, event, RealtimeUpdateOrigin.Stream);
+	}
+	#dispatch(update, raw, origin) {
+		this.#dispatcher.dispatch({
+			update,
+			stream: this,
+			raw,
+			origin
 		});
-		if (name === "connected") {
-			this.#emitter.emit("ready", { userId: pickString(data, "userId") });
+	}
+	#deliver(update) {
+		if (update.type === RealtimeUpdateType.Notification) {
+			this.#emitter.emit("notification", update.data);
+			if (update.data.unreadCount !== void 0) this.#emitter.emit("unreadCount", update.data.unreadCount);
 			return;
 		}
-		if (name === "notification") {
-			const event = readNotificationEvent(data);
-			this.#emitter.emit("notification", event);
-			if (event.unreadCount !== void 0) this.#emitter.emit("unreadCount", event.unreadCount);
+		if (update.type === RealtimeUpdateType.UnreadCount) {
+			this.#emitter.emit("unreadCount", update.data);
 			return;
 		}
-		if (name === "unread_count") {
-			const count = readUnreadCountEvent(data);
-			if (count !== void 0) this.#emitter.emit("unreadCount", count);
+		if (update.type === RealtimeUpdateType.Unknown) return;
+		assertNeverUpdate(update);
+	}
+	#reportDispatchError(event, error, context) {
+		if (this.#emitter.listenerCount(event) > 0) {
+			this.#emitter.emit(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;
@@ -3619,8 +3967,8 @@ var ItdRealtime = class {
 			attempt: this.#attempt,
 			delay
 		});
-		this.#timer = setTimeout(() => {
-			this.#timer = void 0;
+		this.#cancelTimer = (this.#deps.clock ?? systemClock).schedule(() => {
+			this.#cancelTimer = void 0;
 			this.#run();
 		}, delay);
 	}
@@ -3647,7 +3995,7 @@ var ItdRealtime = class {
 		const target = globalThis;
 		if (typeof target.addEventListener !== "function") return;
 		const wake = () => {
-			if (this.#controller || this.#timer !== void 0) return;
+			if (this.#controller || this.#cancelTimer) return;
 			if (this.#status === RealtimeStatus.Disconnected) return;
 			this.#attempt = 0;
 			this.#run();
@@ -3669,6 +4017,9 @@ var ItdRealtime = class {
 		this.#emitter.emit("status", status);
 	}
 };
+function assertNeverUpdate(update) {
+	throw new TypeError(`Необработанное обновление потока: ${String(update)}`);
+}
 //#endregion
 //#region src/core/pagination.ts
 /** Схема пагинации эндпоинта. */
@@ -4584,6 +4935,140 @@ var CommentsResource = class extends BaseResource {
 	}
 };
 //#endregion
+//#region src/core/attachments/url-source.ts
+/** Убирает параметры MIME и приводит его к форме для сравнения. */
+function normalizeMimeType(contentType) {
+	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
+}
+/** Достаёт имя файла из пути URL. */
+function filenameFromUrl(url) {
+	const last = url.pathname.split("/").pop();
+	if (!last) return void 0;
+	try {
+		return decodeURIComponent(last) || void 0;
+	} catch {
+		return last;
+	}
+}
+/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
+function declaredSize(response, maxBytes, url) {
+	const header = response.headers.get("content-length");
+	if (header === null) return void 0;
+	const size = Number(header);
+	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
+	if (maxBytes !== void 0 && size > maxBytes) throw require_multi_storage.fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new require_storage.ItdConfigError(`«${target}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_storage.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
+	let response;
+	try {
+		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
+	} catch (error) {
+		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
+		throw new require_storage.ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
+			reason: require_storage.ItdFileErrorReason.Network,
+			url: requested.href,
+			retryable: true,
+			cause: error
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		throw new require_storage.ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
+			reason: require_storage.ItdFileErrorReason.Http,
+			url: finalUrl.href,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	let size;
+	try {
+		size = declaredSize(response, maxBytes, finalUrl.href);
+	} catch (error) {
+		await response.body?.cancel().catch(() => {});
+		throw error;
+	}
+	return {
+		response,
+		url: finalUrl,
+		size
+	};
+}
+/** Читает ответ с контролем размера до создания итогового `Blob`. */
+async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
+	if (!response.body) {
+		const blob = await response.blob();
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_multi_storage.fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = require_multi_storage.boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url } = await fetchFile(target, options, context);
+	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	const filename = options.filename ?? filenameFromUrl(url);
+	return {
+		file: new Blob([blob], { type: contentType ?? "" }),
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+/** Открывает HTTP-ответ как ограниченный поток. @internal */
+async function openUrlFile(target, options, context) {
+	const resolved = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) throw new require_storage.ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
+		reason: require_storage.ItdFileErrorReason.StreamUnavailable,
+		url: url.href
+	});
+	const stream = require_multi_storage.boundedFileStream(response.body, {
+		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+		streamBufferBytes: resolved.streamBufferBytes,
+		...context.signal ? { signal: context.signal } : {},
+		url: url.href,
+		retryableRead: true
+	});
+	const filename = options.filename ?? filenameFromUrl(url);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	return {
+		stream,
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {},
+		...size !== void 0 ? { size } : {},
+		close: () => stream.cancel().catch(() => {})
+	};
+}
+//#endregion
 //#region src/core/mime.ts
 /** Изображения, которые принимает `POST /api/files/upload`. */
 const IMAGE_MIME_TYPES = Object.freeze([
@@ -4832,7 +5317,7 @@ var FilesResource = class extends BaseResource {
 	async #prepareBuffer(input, options, context) {
 		const content = await this.#resolveBuffer(input, context);
 		const filename = options.filename ?? content.filename ?? this.#nameFromMime(options.contentType ?? content.contentType);
-		const contentType = require_multi_storage.normalizeMimeType(options.contentType ?? content.contentType) ?? require_multi_storage.normalizeMimeType(require_runtime.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(require_runtime.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
 		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
 		const blob = require_runtime.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
 		const limits = require_multi_storage.resolveFileStreamOptions(options);
@@ -4853,7 +5338,7 @@ var FilesResource = class extends BaseResource {
 		if (typeof input === "object" && input !== null && "open" in input) opened = await input.open(context);
 		else if (typeof input === "object" && input !== null && "url" in input) {
 			const { url, ...urlOptions } = input;
-			opened = await require_multi_storage.openUrlFile(url, urlOptions, context);
+			opened = await openUrlFile(url, urlOptions, context);
 		} else throw new require_storage.ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
 		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
 			await opened?.close?.();
@@ -4861,7 +5346,7 @@ var FilesResource = class extends BaseResource {
 		}
 		try {
 			const filename = options.filename ?? opened.filename ?? this.#nameFromMime(options.contentType ?? opened.contentType);
-			const contentType = require_multi_storage.normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
+			const contentType = normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
 			if (options.validateMime !== false) assertAllowedMime(contentType, filename);
 			const limits = require_multi_storage.resolveFileStreamOptions({
 				mode: require_multi_storage.FileTransferMode.Stream,
@@ -4899,7 +5384,7 @@ var FilesResource = class extends BaseResource {
 		if ("load" in input) return input.load(context);
 		if ("url" in input) {
 			const { url, ...urlOptions } = input;
-			return require_multi_storage.downloadFile(url, urlOptions, context);
+			return downloadFile(url, urlOptions, context);
 		}
 		if ("file" in input) return input;
 		if ("open" in input) throw new require_storage.ItdConfigError("потоковый источник нельзя использовать как буферный");
@@ -4907,7 +5392,7 @@ var FilesResource = class extends BaseResource {
 	}
 	/** Подбирает непустое имя, обязательное для multipart. */
 	#nameFromMime(contentType) {
-		const extension = require_multi_storage.normalizeMimeType(contentType)?.split("/")[1];
+		const extension = normalizeMimeType(contentType)?.split("/")[1];
 		return extension ? `file.${extension}` : "file";
 	}
 };
@@ -5129,7 +5614,6 @@ var NotificationsResource = class extends BaseResource {
 };
 //#endregion
 //#region src/core/time.ts
-/** Отметка времени без часового пояса: `2026-07-23 23:14:25`, возможно с долями секунды. */
 const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
 /**
 * Приводит отметку времени без часового пояса к ISO-8601, считая её временем UTC.
@@ -5148,6 +5632,21 @@ function utcStampToIso(value) {
 	const iso = `${match[1]}T${match[2]}Z`;
 	return Number.isFinite(Date.parse(iso)) ? iso : value;
 }
+/**
+* Разбирает дату API в объект `Date`.
+*
+* @returns `null`, если строки нет или она не разбирается
+*
+* @example
+* ```ts
+* const created = toDate(post.createdAt);
+* ```
+*/
+function toDate(value) {
+	if (!value) return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date : null;
+}
 //#endregion
 //#region src/resources/platform.ts
 /** Приводит `last_checked` каждого сервиса к ISO. Остальное остаётся как прислал сервер. */
@@ -6078,7 +6577,7 @@ function resolvePoll(input) {
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const BUILD_UPDATE = Symbol.for("itd.postBuilder.update");
 /**
-* Проверяет данные поста.
+* Проверяет и нормализует данные поста.
 *
 * Отдельного внимания заслуживает `wallRecipientId`: API принимает там **только UUID**,
 * а имя пользователя молча приводит к ошибке на сервере. Проверка здесь превращает
@@ -6098,10 +6597,11 @@ function validatePost(input) {
 	if (wallRecipientId !== void 0 && wallRecipientId !== null) {
 		if (!UUID_PATTERN.test(wallRecipientId)) throw new require_storage.ItdConfigError(`wallRecipientId должен быть UUID, а не именем пользователя (получено: «${wallRecipientId}»). Идентификатор можно взять из профиля: (await itd.users.get(username)).id`);
 	}
+	const { poll: inputPoll, ...data } = input;
 	return {
-		...input,
+		...data,
 		...input.spans !== void 0 ? { spans: validateSpans(content, input.spans) } : {},
-		...input.poll !== void 0 ? { poll: resolvePoll(input.poll) } : {}
+		...inputPoll !== void 0 ? { poll: resolvePoll(inputPoll) } : {}
 	};
 }
 /**
@@ -6298,7 +6798,8 @@ function post(content) {
 }
 /** Приводит любую форму входа к готовым данным поста. */
 function resolvePost(input) {
-	return resolveInput(input, () => post(), validatePost);
+	const resolved = typeof input === "function" ? input(post()) : input;
+	return isBuilder(resolved) ? validatePost(resolved.build()) : validatePost(resolved);
 }
 function validatePostUpdate(input) {
 	if (!input || typeof input !== "object") throw new require_storage.ItdConfigError("Для обновления поста нужен объект с явно заданным content");
@@ -7573,7 +8074,7 @@ var ItdClient = class ItdClient {
 		for (const service of BUILT_IN_SERVICES) this.#services.define(service);
 		for (const service of config.services) this.#services.define(service);
 		const shared = config.rateLimit ? internals.queues : void 0;
-		const queues = shared ?? (config.rateLimit ? new RequestQueuePool(config.rateLimit) : void 0);
+		const queues = shared ?? (config.rateLimit ? new RequestQueuePool(config.rateLimit, config.clock) : void 0);
 		this.#queues = queues;
 		this.#ownsQueues = shared === void 0;
 		let authManager;
@@ -7589,6 +8090,7 @@ var ItdClient = class ItdClient {
 		this.#transport = transport;
 		const pluginsLayer = createPluginsMiddleware(this.#plugins);
 		const retriesLayer = createRetryMiddleware({
+			clock: config.clock,
 			retry: config.retry,
 			rateLimitDelays: config.rateLimit?.retryDelays ?? [],
 			pauseQueue: queues ? (ms, request) => queues.for(request.service).pause(ms) : void 0,
@@ -7768,10 +8270,12 @@ var ItdClient = class ItdClient {
 	*
 	* @example
 	* ```ts
+	* import { NotificationType } from 'itd-api';
+	*
 	* const stream = itd.realtime();
 	*
-	* stream.on('notification', ({ notification }) => {
-	*   console.log(formatNotificationText(notification));
+	* stream.onNotification(NotificationType.PostComment, async ({ update }) => {
+	*   await handleComment(update.data.notification);
 	* });
 	* stream.on('unreadCount', (count) => setBadge(count));
 	*
@@ -7789,8 +8293,10 @@ var ItdClient = class ItdClient {
 			getToken: () => this.#authManager.getAccessToken(),
 			refresh: () => this.#authManager.onUnauthorized(),
 			fetchUnreadCount: () => this.notifications.count(),
+			onConnect: () => this.#streams.add(stream),
 			onClose: () => this.#streams.delete(stream),
-			logger: this.#config.logger
+			logger: this.#config.logger,
+			clock: this.#config.clock
 		}, options);
 		this.#streams.add(stream);
 		return stream;
@@ -7799,8 +8305,8 @@ var ItdClient = class ItdClient {
 	* Освобождает ресурсы клиента: закрывает все потоки уведомлений, отправляет открытые
 	* накопители {@link telemetry}, затем останавливает очередь запросов.
 	*
-	* После вызова клиентом можно пользоваться снова — новые запросы поднимут всё заново,
-	* но уже созданные потоки и успешно закрытые накопители останутся закрытыми.
+	* Метод дожидается активных обработчиков потока. После вызова клиентом можно пользоваться
+	* снова; ранее созданный поток можно запустить повторным `connect()`.
 	*
 	* Общая очередь, полученная от {@link ItdAccounts}, не останавливается: её гасит сам
 	* контейнер, когда закрывает все аккаунты разом.
@@ -7813,8 +8319,9 @@ var ItdClient = class ItdClient {
 	* ```
 	*/
 	async close() {
-		this.#disconnectStreams();
+		const streams = this.#disconnectStreams();
 		try {
+			await Promise.all(streams.map((stream) => stream.drain()));
 			await this.telemetry.close();
 		} finally {
 			if (this.#ownsQueues) this.#queues?.stop();
@@ -7833,8 +8340,10 @@ var ItdClient = class ItdClient {
 	}
 	/** Завершает потоки до того, как запросы начнут использовать другой аккаунт. */
 	#disconnectStreams() {
-		for (const stream of [...this.#streams]) stream.disconnect();
+		const streams = [...this.#streams];
+		for (const stream of streams) stream.disconnect();
 		this.#streams.clear();
+		return streams;
 	}
 	/** Позволяет использовать клиент с `await using`. */
 	[Symbol.asyncDispose]() {
@@ -7973,7 +8482,7 @@ var ItdAccounts = class ItdAccounts {
 		this.#plugins = orderPluginDefinitions(plugins ?? []);
 		this.#rateLimitScope = rateLimitScope ?? "account";
 		const rateLimit = this.#rateLimitScope === "shared" ? resolveRateLimit(base.rateLimit) : void 0;
-		this.#queues = rateLimit ? new RequestQueuePool(rateLimit) : void 0;
+		this.#queues = rateLimit ? new RequestQueuePool(rateLimit, base.clock ?? systemClock) : void 0;
 		const logger = typeof base.logger === "object" ? base.logger : void 0;
 		this.#logger = logger;
 		this.#emitter = new Emitter((error) => reportListenerError(logger, "аккаунтов", error));
@@ -8302,6 +8811,92 @@ function createAccounts(options = {}) {
 	return new ItdAccounts(options);
 }
 //#endregion
+//#region src/core/attachments/factories.ts
+function fromUrl(url, options = {}) {
+	if (require_multi_storage.resolveFileStreamOptions(options, 104857600).mode === require_multi_storage.FileTransferMode.Stream) return { open: (context) => openUrlFile(url, options, context) };
+	return { load: (context) => downloadFile(url, options, context) };
+}
+/**
+* Создаёт повторяемый пользовательский поток.
+*
+* Фабрика вызывается заново для каждой попытки; возвращать один и тот же поток нельзя.
+*/
+function fromStream(factory, options = {}) {
+	const resolved = require_multi_storage.resolveFileStreamOptions({
+		...options,
+		mode: require_multi_storage.FileTransferMode.Stream
+	}, void 0);
+	require_multi_storage.optionalBytes(options.size, "size");
+	return { open: async (context) => {
+		let opened;
+		try {
+			opened = await factory(context);
+		} catch (error) {
+			if (error instanceof require_storage.ItdFileError || error instanceof require_storage.ItdConfigError || context.signal?.aborted) throw error;
+			throw new require_storage.ItdFileError("не удалось открыть поток вложения", {
+				reason: require_storage.ItdFileErrorReason.Read,
+				retryable: true,
+				cause: error
+			});
+		}
+		const content = require_multi_storage.isReadableByteStream(opened) ? { stream: opened } : opened;
+		if (!content || !require_multi_storage.isReadableByteStream(content.stream)) throw new require_storage.ItdConfigError("fromStream должен вернуть ReadableStream или { stream }");
+		const size = options.size ?? content.size;
+		require_multi_storage.optionalBytes(size, "size");
+		if (resolved.maxBytes !== void 0 && size !== void 0 && size > resolved.maxBytes) {
+			await content.close?.();
+			throw require_multi_storage.fileTooLarge(void 0, resolved.maxBytes, size);
+		}
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType);
+		return {
+			stream: require_multi_storage.boundedFileStream(content.stream, {
+				...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+				streamBufferBytes: resolved.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {},
+				retryableRead: true
+			}),
+			...options.filename ?? content.filename ? { filename: options.filename ?? content.filename } : {},
+			...contentType ? { contentType } : {},
+			...size !== void 0 ? { size } : {},
+			...content.close ? { close: content.close } : {}
+		};
+	} };
+}
+//#endregion
+//#region src/models/guards.ts
+/**
+* Свой ли это профиль.
+*
+* @example
+* ```ts
+* if (isMyProfile(profile)) console.log(profile.subscription.isActive);
+* ```
+*/
+function isMyProfile(profile) {
+	return "subscription" in profile;
+}
+//#endregion
+//#region src/models/status-helpers.ts
+const STATUS_WINDOW_DAYS = 90;
+/**
+* Разворачивает историю сервиса в массив на 90 суток.
+* Сутки без данных становятся `null`.
+*
+* @returns массив, где индекс — сколько суток назад: `[0]` — сегодня
+*
+* @example
+* ```ts
+* const status = await itd.platform.status();
+* const days = statusDays(status.services[0]);
+*
+* days[0]?.uptime;                              // доступность за сегодня
+* days.filter((day) => day === null).length;    // за сколько суток данных нет
+* ```
+*/
+function statusDays(service) {
+	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
+}
+//#endregion
 //#region src/notifications/text.ts
 /** Имя, которое подставляется, если участник неизвестен. */
 const UNKNOWN_ACTOR = "Пользователь";
@@ -8433,6 +9028,87 @@ function resolveNotificationUrl(notification) {
 	return clickUrl || "/notifications";
 }
 //#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.middleware());
+* ```
+*/
+var RealtimeRouter = class {
+	#selector;
+	#routes = /* @__PURE__ */ new Map();
+	#fallback = [];
+	constructor(selector) {
+		if (typeof selector !== "function") throw new require_storage.ItdConfigError("RealtimeRouter принимает функцию выбора маршрута");
+		this.#selector = selector;
+	}
+	/** Добавляет промежуточные обработчики к маршруту и возвращает функцию их удаления. */
+	route(key, ...middleware) {
+		if (!isPropertyKey(key)) throw new require_storage.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()`. */
+	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_storage.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_storage.ItdConfigError("Маршрут должен содержать хотя бы один обработчик");
+		for (const item of middleware) if (typeof item !== "function") throw new require_storage.ItdConfigError("Маршрут принимает только функции обработки");
+		return { middleware: [...middleware] };
+	}
+};
+function isPropertyKey(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "symbol";
+}
+//#endregion
 //#region src/spans/render.ts
 /** Формат результата {@link renderSpans}. */
 const SpanRenderFormat = Object.freeze({
@@ -8637,54 +9313,6 @@ function renderSpans(content, spans = [], options = {}) {
 	return result;
 }
 //#endregion
-//#region src/types/models.ts
-/**
-* Свой ли это профиль.
-*
-* @example
-* ```ts
-* if (isMyProfile(profile)) console.log(profile.subscription.isActive);
-* ```
-*/
-function isMyProfile(profile) {
-	return "subscription" in profile;
-}
-/** Глубина истории статуса в сутках. Столько элементов отдаёт {@link statusDays}. */
-const STATUS_WINDOW_DAYS = 90;
-/**
-* Разбирает дату API в объект `Date`.
-*
-* @returns `null`, если строки нет или она не разбирается
-*
-* @example
-* ```ts
-* const created = toDate(post.createdAt);
-* ```
-*/
-function toDate(value) {
-	if (!value) return null;
-	const date = new Date(value);
-	return Number.isFinite(date.getTime()) ? date : null;
-}
-/**
-* Разворачивает историю сервиса в массив на 90 суток.
-* Сутки без данных становятся `null`.
-*
-* @returns массив, где индекс — сколько суток назад: `[0]` — сегодня
-*
-* @example
-* ```ts
-* const status = await itd.platform.status();
-* const days = statusDays(status.services[0]);
-*
-* days[0]?.uptime;                              // доступность за сегодня
-* days.filter((day) => day === null).length;    // за сколько суток данных нет
-* ```
-*/
-function statusDays(service) {
-	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
-}
-//#endregion
 exports.ALLOWED_MIME_TYPES = ALLOWED_MIME_TYPES;
 exports.AUDIO_MIME_TYPES = AUDIO_MIME_TYPES;
 exports.AUTH_FLAG_COOKIE = require_multi_storage.AUTH_FLAG_COOKIE;
@@ -8743,8 +9371,11 @@ exports.RECONNECT_JITTER = RECONNECT_JITTER;
 exports.REFRESH_COOKIE = require_multi_storage.REFRESH_COOKIE;
 exports.REFRESH_COOKIE_PATH = require_multi_storage.REFRESH_COOKIE_PATH;
 exports.REQUEST_OPTION_KEYS = REQUEST_OPTION_KEYS;
+exports.RealtimeRouter = RealtimeRouter;
 exports.RealtimeStatus = RealtimeStatus;
 exports.RealtimeTransportKind = RealtimeTransportKind;
+exports.RealtimeUpdateOrigin = RealtimeUpdateOrigin;
+exports.RealtimeUpdateType = RealtimeUpdateType;
 exports.ReportReason = ReportReason;
 exports.ReportTargetType = ReportTargetType;
 exports.RuntimeMode = require_runtime.RuntimeMode;
@@ -8770,8 +9401,8 @@ exports.createMultiTokenStorage = require_multi_storage.createMultiTokenStorage;
 exports.createRecordMultiStorage = require_multi_storage.createRecordMultiStorage;
 exports.createTokenStorage = require_storage.createTokenStorage;
 exports.formatNotificationText = formatNotificationText;
-exports.fromStream = require_multi_storage.fromStream;
-exports.fromUrl = require_multi_storage.fromUrl;
+exports.fromStream = fromStream;
+exports.fromUrl = fromUrl;
 exports.isBuilder = isBuilder;
 exports.isItdApiError = require_storage.isItdApiError;
 exports.isItdAuthError = require_storage.isItdAuthError;
@@ -8800,6 +9431,7 @@ exports.report = report;
 exports.resolveNotificationUrl = resolveNotificationUrl;
 exports.scopedTokenStorage = require_multi_storage.scopedTokenStorage;
 exports.statusDays = statusDays;
+exports.systemClock = systemClock;
 exports.toDate = toDate;
 exports.utcStampToIso = utcStampToIso;