itd-api 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_multi_storage = require("./multi-storage-mBuCOVZY.cjs");
-const require_storage = require("./storage-dF8Tio5y.cjs");
+const require_multi_storage = require("./multi-storage-Bf84xiO8.cjs");
+const require_storage = require("./storage-DnzZPS_9.cjs");
 //#region src/core/emitter.ts
 /**
 * Минимальный типизированный источник событий.
@@ -130,6 +130,56 @@ function readTokenSubject(token) {
 	return readTokenIdentity(token).subject;
 }
 //#endregion
+//#region src/core/buckets.ts
+/**
+* Ёмкость серверных счётчиков частоты, запросов в минуту.
+*
+* Таблица действует до первого ответа бакета; дальше ёмкость берётся из заголовка
+* `x-ratelimit-limit` и заменяет табличную. `default` — счётчик любого пути без
+* собственного правила на сервере.
+*/
+const BUCKET_LIMITS = Object.freeze({
+	"posts.stats": 180,
+	default: 150,
+	feed: 90,
+	"posts.like": 85,
+	"posts.comments": 80,
+	hashtags: 50,
+	users: 40,
+	notifications: 40,
+	"files.get": 40,
+	auth: 35,
+	"auth.refresh": 25,
+	search: 25,
+	"comments.like": 22,
+	"files.upload": 15,
+	"files.remove": 15,
+	"posts.comment": 14,
+	"hashtags.trending": 13,
+	"posts.repost": 7,
+	"users.follow": 7,
+	"verification.status": 6,
+	"posts.create": 5,
+	"users.updateMe": 3,
+	"reports.create": 3,
+	"verification.submit": 3
+});
+/** Счётчик, из которого списывается путь без собственного правила на сервере. */
+const DEFAULT_RATE_LIMIT_BUCKET = "default";
+/** Известно ли библиотеке имя бакета. */
+function isKnownBucket(name) {
+	return Object.hasOwn(BUCKET_LIMITS, name);
+}
+/** Реакция на остаток лимита из заголовков ответа. */
+const RateLimitPacing = Object.freeze({
+	/** Задержек нет, пока в бакете есть остаток; исчерпанный бакет ждёт `60000 / limit`. */
+	React: "react",
+	/** Ровный темп в пределах минутного лимита: задержки идут с первого запроса. */
+	Smooth: "smooth",
+	/** Остаток на темп не влияет; остаётся пауза после `429`. */
+	Off: "off"
+});
+//#endregion
 //#region src/core/operations.ts
 /** Семантическая безопасность автоматического повтора операции. */
 const RetrySafety = Object.freeze({
@@ -157,59 +207,73 @@ const OPERATIONS = freezeOperations({
 	},
 	"auth.signUp": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.signIn": {
 		method: "POST",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "auth"
 	},
 	"auth.verifyOtp": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.resendOtp": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.refresh": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth.refresh"
 	},
 	"auth.logout": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.forgotPassword": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.resetPassword": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.changePassword": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.sessions": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "auth"
 	},
 	"auth.revokeSession": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"auth.revokeOtherSessions": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
 	},
 	"users.me": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.updateMe": {
 		method: "PUT",
-		retrySafety: RetrySafety.Idempotent
+		retrySafety: RetrySafety.Idempotent,
+		bucket: "users.updateMe"
 	},
 	"users.deactivate": {
 		method: "DELETE",
@@ -225,39 +289,48 @@ const OPERATIONS = freezeOperations({
 	},
 	"users.get": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.checkUsername": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.search": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.whoToFollow": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.topClans": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.follow": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "users.follow"
 	},
 	"users.unfollow": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "users.follow"
 	},
 	"users.followers": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.following": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.followStatus": {
 		method: "POST",
@@ -273,11 +346,13 @@ const OPERATIONS = freezeOperations({
 	},
 	"users.blocked": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.getPrivacy": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.updatePrivacy": {
 		method: "PUT",
@@ -285,7 +360,8 @@ const OPERATIONS = freezeOperations({
 	},
 	"users.pins": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
 	},
 	"users.setPin": {
 		method: "PUT",
@@ -297,11 +373,13 @@ const OPERATIONS = freezeOperations({
 	},
 	"posts.list": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "feed"
 	},
 	"posts.create": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.create"
 	},
 	"posts.get": {
 		method: "GET",
@@ -321,19 +399,23 @@ const OPERATIONS = freezeOperations({
 	},
 	"posts.like": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.like"
 	},
 	"posts.unlike": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.like"
 	},
 	"posts.repost": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.repost"
 	},
 	"posts.unrepost": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.repost"
 	},
 	"posts.pin": {
 		method: "POST",
@@ -349,7 +431,8 @@ const OPERATIONS = freezeOperations({
 	},
 	"posts.stats": {
 		method: "POST",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "posts.stats"
 	},
 	"posts.byUser": {
 		method: "GET",
@@ -361,11 +444,13 @@ const OPERATIONS = freezeOperations({
 	},
 	"posts.comments": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "posts.comments"
 	},
 	"posts.comment": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.comment"
 	},
 	"comments.replies": {
 		method: "GET",
@@ -389,31 +474,38 @@ const OPERATIONS = freezeOperations({
 	},
 	"comments.like": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "comments.like"
 	},
 	"comments.unlike": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "comments.like"
 	},
 	"files.upload": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "files.upload"
 	},
 	"files.get": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "files.get"
 	},
 	"files.remove": {
 		method: "DELETE",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "files.remove"
 	},
 	"notifications.list": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
 	},
 	"notifications.count": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
 	},
 	"notifications.markRead": {
 		method: "POST",
@@ -429,31 +521,47 @@ const OPERATIONS = freezeOperations({
 	},
 	"notifications.getSettings": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
 	},
 	"notifications.updateSettings": {
 		method: "PUT",
 		retrySafety: RetrySafety.Idempotent
 	},
+	"realtime.poll.updates": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
+	},
+	"realtime.poll.unread": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
+	},
 	"hashtags.search": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "hashtags"
 	},
 	"hashtags.trending": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "hashtags.trending"
 	},
 	"hashtags.posts": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "hashtags"
 	},
 	"search.all": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "search"
 	},
 	"reports.create": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "reports.create"
 	},
 	"subscription.status": {
 		method: "GET",
@@ -485,11 +593,13 @@ const OPERATIONS = freezeOperations({
 	},
 	"verification.status": {
 		method: "GET",
-		retrySafety: RetrySafety.Safe
+		retrySafety: RetrySafety.Safe,
+		bucket: "verification.status"
 	},
 	"verification.submit": {
 		method: "POST",
-		retrySafety: RetrySafety.Unsafe
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "verification.submit"
 	},
 	"platform.version": {
 		method: "GET",
@@ -533,6 +643,16 @@ function operationMethod(id) {
 function operationRetrySafety(id) {
 	return OPERATIONS[id].retrySafety;
 }
+/**
+* Бакет операции.
+*
+* `raw` и `custom:*` попадают в `default`; назвать бакет явно позволяет
+* `rateLimitBucket` у запроса.
+*/
+function operationBucket(id) {
+	if (!isBuiltInOperationId(id)) return DEFAULT_RATE_LIMIT_BUCKET;
+	return OPERATIONS[id].bucket ?? "default";
+}
 //#endregion
 //#region src/core/runtime.ts
 /**
@@ -668,6 +788,11 @@ const AUTH_PATHS = {
 * Нужен, чтобы отрисовать виджет капчи и получить токен для `signIn`, `signUp`
 * и `forgotPassword`.
 *
+* Ключ привязан к домену: на чужом origin Cloudflare отказывает виджету с кодом `110200`.
+* Поэтому отрисовать его может только код, выполняемый на самом итд.com. Остальным
+* подходит `@itd-api/turnstile`, готовый токен из другого источника или вовсе вход
+* без капчи — по сохранённой сессии либо по токенам, взятым в браузере.
+*
 * @example
 * ```ts
 * turnstile.render('#captcha', {
@@ -677,8 +802,6 @@ const AUTH_PATHS = {
 * ```
 */
 const TURNSTILE_SITE_KEY = "0x4AAAAAACHhxczw6fJGwPBg";
-/** Заголовок с идентификатором устройства. Сервер связывает с ним запись в списке сессий. */
-const DEVICE_ID_HEADER = "X-Device-Id";
 function readAccessToken(payload) {
 	if (typeof payload !== "object" || payload === null) return void 0;
 	const token = payload.accessToken;
@@ -1183,10 +1306,33 @@ const systemClock = Object.freeze({
 		return () => clearTimeout(timer);
 	}
 });
+/**
+* Заводит срок, общий на все ожидания: от ожидания к ожиданию он не продлевается.
+*
+* @param timeout срок в миллисекундах; `0` — ждать без ограничения
+* @internal
+*/
+function createDeadline(timeout, clock = systemClock) {
+	if (timeout <= 0) return {
+		wait: async (promise) => {
+			await promise;
+			return true;
+		},
+		cancel: () => {}
+	};
+	let expire;
+	const expired = new Promise((resolve) => {
+		expire = resolve;
+	});
+	return {
+		wait: (promise) => Promise.race([promise.then(() => true), expired.then(() => false)]),
+		cancel: clock.schedule(() => expire(), timeout)
+	};
+}
 //#endregion
 //#region src/core/version.ts
 /** Версия библиотеки. Попадает в `User-Agent`. */
-const LIBRARY_VERSION = "0.5.0";
+const LIBRARY_VERSION = "0.7.0";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -1201,8 +1347,6 @@ const BUILT_IN_SERVICES = Object.freeze([Object.freeze({
 	baseUrl: DEFAULT_STATUS_BASE_URL,
 	auth: false
 })]);
-/** Таймаут запроса по умолчанию — 30 секунд. */
-const DEFAULT_TIMEOUT = 3e4;
 /**
 * `User-Agent` по умолчанию.
 *
@@ -1217,9 +1361,8 @@ const DEFAULT_USER_AGENT = `Mozilla/5.0 (compatible; itd-api/${LIBRARY_VERSION};
 /**
 * Паузы перед повторами при ответе `429`.
 *
-* Сервер итд.com не присылает `Retry-After` и не сообщает время сброса окна, поэтому
-* паузу приходится подбирать лестницей: от секунды, если окно почти истекло,
-* до полутора минут, если лимит исчерпан всерьёз.
+* Сервер итд.com не присылает `Retry-After` и не сообщает время сброса окна, поэтому паузу
+* приходится подбирать лестницей: от секунды, если окно почти истекло, до полутора минут.
 */
 const DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([
 	1e3,
@@ -1228,6 +1371,13 @@ const DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([
 	6e4,
 	9e4
 ]);
+/**
+* Встроенные поправки бакетов.
+*
+* Таймаут загрузки файла — пять минут против обычных тридцати секунд, поэтому её
+* одновременность ограничена одним запросом.
+*/
+const DEFAULT_BUCKET_OVERRIDES = Object.freeze({ "files.upload": Object.freeze({ concurrency: 1 }) });
 function requirePositive(value, name) {
 	if (!Number.isFinite(value) || value < 0) throw new require_storage.ItdConfigError(`${name} должен быть неотрицательным числом, получено: ${value}`);
 	return value;
@@ -1316,6 +1466,54 @@ function resolveRetry(retry) {
 	};
 }
 /**
+* Сверяет имя бакета со встроенной картой.
+*
+* Своё правило выбора заводит собственное пространство имён, и встроенные имена в нём
+* необязательны — тогда проверка снимается.
+*
+* @param option путь опции для текста ошибки
+* @throws {ItdConfigError} если имени нет во встроенной карте
+*
+* @internal
+*/
+function assertKnownBucket(name, option, bucket) {
+	if (bucket !== void 0 || isKnownBucket(name)) return;
+	throw new require_storage.ItdConfigError(`${option}: бакета «${name}» нет. Известны: ${Object.keys(BUCKET_LIMITS).join(", ")}`);
+}
+function requireConcurrency(value, name) {
+	if (!Number.isInteger(value) || value < 1) throw new require_storage.ItdConfigError(`${name} должен быть целым числом от 1, получено: ${value}`);
+	return value;
+}
+function resolvePacing(pacing) {
+	const known = Object.values(RateLimitPacing);
+	if (pacing !== void 0 && !known.includes(pacing)) throw new require_storage.ItdConfigError(`rateLimit.pacing должен быть одним из ${known.join(", ")}, получено: ${pacing}`);
+	return pacing ?? RateLimitPacing.React;
+}
+/**
+* Проверяет поправки бакетов и накладывает их на встроенные.
+*
+* Имена сверяются со встроенной картой, пока не задано своё правило выбора бакета.
+* Поля сливаются по отдельности: своя ёмкость `files.upload` не снимает встроенный
+* предел одновременности.
+*/
+function resolveBucketOverrides(overrides, bucket) {
+	if (overrides === void 0) return DEFAULT_BUCKET_OVERRIDES;
+	if (!isRecord$1(overrides)) throw new require_storage.ItdConfigError("rateLimit.bucketOverrides должен быть объектом");
+	const resolved = { ...DEFAULT_BUCKET_OVERRIDES };
+	for (const [name, override] of Object.entries(overrides)) {
+		if (!isRecord$1(override)) throw new require_storage.ItdConfigError(`rateLimit.bucketOverrides.${name} должен быть объектом`);
+		assertKnownBucket(name, "rateLimit.bucketOverrides", bucket);
+		if (override.concurrency !== void 0) requireConcurrency(override.concurrency, `rateLimit.bucketOverrides.${name}.concurrency`);
+		if (override.limit !== void 0 && (!Number.isFinite(override.limit) || override.limit <= 0)) throw new require_storage.ItdConfigError(`rateLimit.bucketOverrides.${name}.limit должен быть положительным числом, получено: ${override.limit}`);
+		const built = DEFAULT_BUCKET_OVERRIDES[name];
+		resolved[name] = Object.freeze({
+			concurrency: override.concurrency ?? built?.concurrency,
+			limit: override.limit ?? built?.limit
+		});
+	}
+	return Object.freeze(resolved);
+}
+/**
 * Приводит настройки очереди к полному виду. `undefined` — очередь не нужна.
 *
 * Кроме создания клиента вызывается ещё из {@link ItdAccounts}: общая на всех аккаунтов
@@ -1332,21 +1530,29 @@ function resolveRateLimit(rateLimit) {
 		concurrency: 6,
 		rps: void 0,
 		retryDelays: DEFAULT_RATE_LIMIT_DELAYS,
-		respectHeaders: true
+		buckets: true,
+		pacing: RateLimitPacing.React,
+		bucketConcurrency: 6,
+		bucketOverrides: DEFAULT_BUCKET_OVERRIDES,
+		bucket: void 0
 	};
 	if (!rateLimit) return defaults;
-	const concurrency = rateLimit.concurrency ?? 6;
-	if (!Number.isInteger(concurrency) || concurrency < 1) throw new require_storage.ItdConfigError(`rateLimit.concurrency должен быть целым числом от 1, получено: ${concurrency}`);
+	const concurrency = requireConcurrency(rateLimit.concurrency ?? 6, "rateLimit.concurrency");
 	if (rateLimit.rps !== void 0 && (!Number.isFinite(rateLimit.rps) || rateLimit.rps <= 0)) throw new require_storage.ItdConfigError(`rateLimit.rps должен быть положительным числом, получено: ${rateLimit.rps}`);
 	const retryDelays = rateLimit.retryDelays ?? defaults.retryDelays;
 	if (!Array.isArray(retryDelays)) throw new require_storage.ItdConfigError("rateLimit.retryDelays должен быть массивом чисел");
 	for (const delay of retryDelays) requirePositive(delay, "rateLimit.retryDelays");
-	requireOptionalBoolean(rateLimit.respectHeaders, "rateLimit.respectHeaders");
+	requireOptionalBoolean(rateLimit.buckets, "rateLimit.buckets");
+	if (rateLimit.bucket !== void 0 && typeof rateLimit.bucket !== "function") throw new require_storage.ItdConfigError("rateLimit.bucket должен быть функцией");
 	return {
 		concurrency,
 		rps: rateLimit.rps,
 		retryDelays: [...retryDelays],
-		respectHeaders: rateLimit.respectHeaders ?? true
+		buckets: rateLimit.buckets ?? true,
+		pacing: resolvePacing(rateLimit.pacing),
+		bucketConcurrency: requireConcurrency(rateLimit.bucketConcurrency ?? concurrency, "rateLimit.bucketConcurrency"),
+		bucketOverrides: resolveBucketOverrides(rateLimit.bucketOverrides, rateLimit.bucket),
+		bucket: rateLimit.bucket
 	};
 }
 /**
@@ -1412,6 +1618,7 @@ function resolveConfig(options = {}) {
 	const mode = options.mode ?? RuntimeMode.Auto;
 	if (!Object.values(RuntimeMode).includes(mode)) throw new require_storage.ItdConfigError(`mode должен быть одним из ${Object.values(RuntimeMode).join(", ")}, получено: ${mode}`);
 	const timeout = requirePositive(options.timeout ?? 3e4, "timeout");
+	const shutdownTimeout = requirePositive(options.shutdownTimeout ?? 1e4, "shutdownTimeout");
 	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");
@@ -1427,6 +1634,7 @@ function resolveConfig(options = {}) {
 		fetch: resolveFetch(options.fetch),
 		clock: options.clock ?? systemClock,
 		timeout,
+		shutdownTimeout,
 		retry: resolveRetry(options.retry),
 		rateLimit: resolveRateLimit(options.rateLimit),
 		hooks: resolveHooks(options.hooks),
@@ -1442,6 +1650,7 @@ function resolveConfig(options = {}) {
 //#endregion
 //#region src/core/pipeline.ts
 const REQUEST_ATTEMPT_STATE = Symbol("itd-api.request-attempt-state");
+const REQUEST_QUEUE_KEY = Symbol("itd-api.request-queue-key");
 const DISPOSE_CLEANUP_REQUEST = Symbol("itd-api.dispose-cleanup-request");
 /** Один раз присваивает низкоуровневому запросу семантический ID до входа в middleware. */
 function identifyRequest(request) {
@@ -1473,6 +1682,23 @@ function beginTransportAttempt(request) {
 function currentTransportAttempt(request) {
 	return request[REQUEST_ATTEMPT_STATE]?.value ?? 0;
 }
+/**
+* Вычисляет ключ очереди один раз на логическую операцию.
+*
+* Ключ спрашивают трижды: при постановке в очередь, при чтении заголовков ответа и при
+* паузе после `429`. Значение пишется прямо в объект запроса — слои ниже копируют его
+* через spread, и перечислимое символьное поле переходит в копии.
+*
+* @internal
+*/
+function requestQueueKey(request, compute) {
+	const internal = request;
+	const cached = internal[REQUEST_QUEUE_KEY];
+	if (cached) return cached;
+	const key = compute(request);
+	internal[REQUEST_QUEUE_KEY] = key;
+	return key;
+}
 /** Помечает запрос как часть внутренней финализации уже начатого `dispose()`. @internal */
 function markDisposeCleanupRequest(request) {
 	return {
@@ -1817,7 +2043,7 @@ function createRetryMiddleware(deps) {
 			const transportAttempt = currentTransportAttempt(trackedRequest);
 			if (require_storage.isItdRateLimitError(error)) rateLimitAttempt += 1;
 			else retryAttempt += 1;
-			const delay = nextDelay(error, retryAttempt, rateLimitAttempt, request, policy, backoff);
+			const delay = nextDelay(error, retryAttempt, rateLimitAttempt, trackedRequest, policy, backoff);
 			if (delay === void 0) throw error;
 			await dispatchRequestHook(deps.hooks, "onRetry", {
 				operationId: request.operationId,
@@ -1995,7 +2221,11 @@ var PluginRegistry = class {
 	#entries = /* @__PURE__ */ new Map();
 	#removing = /* @__PURE__ */ new Set();
 	#cleanups = /* @__PURE__ */ new Set();
+	#options;
 	#ordered = [];
+	constructor(options) {
+		this.#options = options;
+	}
 	/** Сколько плагинов подключено. */
 	get size() {
 		return this.#entries.size;
@@ -2069,9 +2299,11 @@ var PluginRegistry = class {
 	* Отключает плагин и вызывает его функцию очистки.
 	*
 	* Новые запросы перестают видеть расширения плагина сразу. Снимок уже начавшейся операции,
-	* включая её будущие retry, остаётся неизменным; очистка дождётся завершения операции.
+	* включая её будущие retry, остаётся неизменным; очистка дождётся завершения операции,
+	* но не дольше отведённого срока.
 	*
 	* @returns `false`, если такого плагина не было
+	* @throws {ItdStateError} если операции плагина не завершились за отведённый срок
 	*/
 	async remove(name) {
 		const entry = this.#entries.get(name);
@@ -2080,21 +2312,24 @@ var PluginRegistry = class {
 		this.#entries.delete(name);
 		this.#ordered = this.#ordered.filter((current) => current !== entry);
 		this.#removing.add(name);
+		const deadline = createDeadline(this.#options.shutdownTimeout, this.#options.clock);
 		const cleanup = this.#trackCleanup((async () => {
-			await this.#waitForDrain(entry);
-			await entry.teardown?.();
+			const expired = await this.#release(entry, deadline);
+			if (expired) throw expired;
 		})());
 		try {
 			await cleanup;
 			return true;
 		} finally {
+			deadline.cancel();
 			this.#removing.delete(name);
 		}
 	}
 	/**
 	* Отключает все плагины окончательно.
 	*
-	* Очистка идёт изнутри наружу — в порядке, обратном выполнению расширений.
+	* Очистка идёт изнутри наружу — в порядке, обратном выполнению расширений. Срок ожидания
+	* общий на все плагины.
 	*/
 	async dispose() {
 		const entries = [...this.#ordered].reverse();
@@ -2102,13 +2337,14 @@ var PluginRegistry = class {
 		this.#entries.clear();
 		this.#ordered = [];
 		for (const { plugin } of entries) this.#removing.add(plugin.name);
-		await this.#trackCleanup((async () => {
+		const deadline = createDeadline(this.#options.shutdownTimeout, this.#options.clock);
+		const cleanup = this.#trackCleanup((async () => {
 			const errors = [];
 			const previous = await Promise.allSettled(previousCleanups);
 			for (const result of previous) if (result.status === "rejected") errors.push(result.reason);
 			for (const entry of entries) try {
-				await this.#waitForDrain(entry);
-				await entry.teardown?.();
+				const expired = await this.#release(entry, deadline);
+				if (expired) errors.push(expired);
 			} catch (error) {
 				errors.push(error);
 			} finally {
@@ -2116,6 +2352,11 @@ var PluginRegistry = class {
 			}
 			if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить ресурсы плагинов");
 		})());
+		try {
+			await cleanup;
+		} finally {
+			deadline.cancel();
+		}
 	}
 	/**
 	* Прогоняет запрос через operation transformers и прикрепляет attempt interceptors.
@@ -2123,6 +2364,9 @@ var PluginRegistry = class {
 	* Снимки обеих цепочек берутся в начале: `unuse()` влияет на новые операции, но не меняет
 	* уже выполняющуюся и не удаляет interceptors из её последующих retry.
 	*
+	* Каждый `next` одноразовый: transformer может завершить операцию сам, но не может породить
+	* вторую — для `posts.create` это была бы вторая публикация.
+	*
 	* @param execute выполнение логической операции, вызываемое самым внутренним transformer
 	*/
 	async run(request, execute) {
@@ -2133,7 +2377,17 @@ var PluginRegistry = class {
 			interceptor
 		})));
 		const scoped = (current) => withAttemptInterceptorScope(current, interceptorScope);
-		const chain = entries.flatMap((entry) => entry.transformers).reduceRight((next, transformer) => (current) => transformer(scoped(current), (prepared) => next(scoped(prepared))), (current) => execute(scoped(current)));
+		const chain = entries.flatMap((entry) => entry.transformers.map((transformer) => ({
+			plugin: entry.plugin.name,
+			transformer
+		}))).reduceRight((next, { plugin, transformer }) => (current) => {
+			let called = false;
+			return transformer(scoped(current), (prepared) => {
+				if (called) throw new require_storage.ItdConfigError(`operation transformer плагина «${plugin}» вызвал next() больше одного раза`);
+				called = true;
+				return next(scoped(prepared));
+			});
+		}, (current) => execute(scoped(current)));
 		try {
 			return await chain(scoped(request));
 		} finally {
@@ -2147,6 +2401,18 @@ var PluginRegistry = class {
 			}
 		}
 	}
+	/**
+	* Дожидается операций плагина и освобождает его ресурсы.
+	*
+	* `teardown` выполняется в любом случае, в том числе после истечения срока.
+	*
+	* @returns ошибка истёкшего срока, если ждать пришлось дольше отведённого
+	*/
+	async #release(entry, deadline) {
+		const finished = await deadline.wait(this.#waitForDrain(entry));
+		await entry.teardown?.();
+		return finished ? void 0 : new require_storage.ItdStateError(`плагин «${entry.plugin.name}» не завершил операции за ${this.#options.shutdownTimeout} мс; ожидание прекращено, ресурсы плагина освобождены`);
+	}
 	#waitForDrain(entry) {
 		if (entry.activeRequests === 0) return Promise.resolve();
 		entry.drain ??= new Promise((resolve) => {
@@ -2166,6 +2432,10 @@ var PluginRegistry = class {
 function queueAbortError() {
 	return new require_storage.ItdAbortError("Запрос отменён во время ожидания очереди");
 }
+/** Ошибка запроса, которого застала остановка очереди. */
+function queueStoppedError() {
+	return new require_storage.ItdAbortError("Клиент закрыт, запрос отменён");
+}
 /**
 * Очередь запросов: ограничивает одновременность и частоту.
 *
@@ -2181,6 +2451,7 @@ var RequestQueue = class {
 	#concurrency;
 	/** Минимальный промежуток между стартами, мс. `0` — без ограничения частоты. */
 	#minGap;
+	#onDispatch;
 	#waiting = [];
 	#active = 0;
 	/** Момент, раньше которого следующий запрос стартовать не должен. */
@@ -2190,6 +2461,7 @@ var RequestQueue = class {
 	constructor(options, clock = systemClock) {
 		this.#concurrency = options.concurrency;
 		this.#minGap = options.rps ? 1e3 / options.rps : 0;
+		this.#onDispatch = options.onDispatch;
 		this.#clock = clock;
 	}
 	/** Сколько задач выполняется прямо сейчас. */
@@ -2221,6 +2493,7 @@ var RequestQueue = class {
 				run: () => {
 					detach();
 					this.#active += 1;
+					this.#onDispatch?.();
 					Promise.resolve().then(task).then(resolve, reject).finally(() => {
 						this.#active -= 1;
 						this.#drain();
@@ -2246,16 +2519,10 @@ var RequestQueue = class {
 			this.#cancelTimer();
 			this.#cancelTimer = void 0;
 		}
-		this.#nextSlot = 0;
 		const pending = this.#waiting.splice(0, this.#waiting.length);
-		for (const task of pending) task.cancel(new require_storage.ItdAbortError("Клиент закрыт, запрос отменён"));
+		for (const task of pending) task.cancel(queueStoppedError());
 	}
-	/**
-	* Придерживает всю очередь на заданное время.
-	*
-	* Вызывается при получении `429` с заголовком `Retry-After`: тормозить нужно все запросы,
-	* а не только тот, который наткнулся на лимит, — иначе остальные продолжат добивать API.
-	*/
+	/** Придерживает очередь на заданное время: ждут все её задачи, а не только одна. */
 	pause(ms) {
 		if (ms <= 0) return;
 		this.#nextSlot = Math.max(this.#nextSlot, this.#clock.now() + ms);
@@ -2286,39 +2553,241 @@ var RequestQueue = class {
 		this.#drain();
 	}
 };
+/** Длина окна лимита на сервере. */
+const RATE_LIMIT_WINDOW = 6e4;
+/**
+* Пауза при исчерпании бакета неизвестной ёмкости.
+*
+* Ёмкость приходит в заголовке вместе с остатком, поэтому случай возможен только у чужого
+* прокси, который прислал `remaining` без `limit`.
+*/
+const UNKNOWN_CAPACITY_PAUSE = 1e3;
+/**
+* Очередь одного бакета поверх общей очереди направления.
+*
+* Задача занимает слот бакета, затем общий слот направления, поэтому суммарная
+* одновременность остаётся равной `concurrency`. Пауза бакета удерживает задачу до
+* захвата общего слота: притормозивший счётчик не занимает общую ёмкость.
+*
+* @internal
+*/
+var BucketQueue = class {
+	#destination;
+	#bucket;
+	#gate;
+	#shared;
+	#clock;
+	#pacing;
+	/** Ровный темп. Требует раздельных бакетов: без них ёмкость счётчика неизвестна. */
+	#smooth;
+	/**
+	* Пауза на исчерпанный остаток в режиме `buckets: false`; `undefined` — бакеты разделены.
+	*
+	* Одна очередь на направление принимает заголовки всех счётчиков вперемешку, поэтому
+	* `x-ratelimit-limit` принадлежит тому счётчику, который ответил последним, и ёмкость
+	* очереди из него не выводится: ответ `posts.create` с ёмкостью 5 остановил бы всё
+	* направление на двенадцать секунд. Вместо расчёта берётся первая ступень `retryDelays`.
+	*/
+	#flatPause;
+	/** Лимит бакета до первого ответа. */
+	#seedLimit;
+	/** Последнее, что сказал сервер. Живёт и в режиме `off` — ради `rateLimitState()`. */
+	#limit;
+	#remaining;
+	/**
+	* Оценка остатка для режима `smooth`.
+	*
+	* Начинается с единицы, а не с полной ёмкости: где сейчас граница минутного окна,
+	* из ответа не вывести, и считать бакет нетронутым нельзя.
+	*/
+	#tokens = 1;
+	#tokensAt;
+	/**
+	* Номер поколения очереди. `stop()` увеличивает его, отсекая задачи, которые уже взяли
+	* слот бакета, но до общей очереди ещё не дошли.
+	*/
+	#generation = 0;
+	constructor(destination, bucket, shared, options, clock) {
+		this.#destination = destination;
+		this.#bucket = bucket;
+		this.#shared = shared;
+		this.#clock = clock;
+		this.#pacing = options.pacing;
+		this.#smooth = options.buckets && options.pacing === RateLimitPacing.Smooth;
+		this.#flatPause = options.buckets ? void 0 : options.retryDelays[0] ?? 0;
+		this.#seedLimit = options.buckets ? seedLimit(bucket, options) : void 0;
+		this.#gate = new RequestQueue({
+			concurrency: options.buckets ? options.bucketOverrides[bucket]?.concurrency ?? options.bucketConcurrency : options.concurrency,
+			onDispatch: this.#smooth ? () => this.#spend() : void 0
+		}, clock);
+	}
+	/** Имя счётчика. При `buckets: false` — всегда `default`, каким бы ни был запрос. */
+	get bucket() {
+		return this.#bucket;
+	}
+	/** Запросов бакета прошло в общую очередь и ещё не завершилось. */
+	get active() {
+		return this.#gate.active;
+	}
+	/** Запросов бакета ждёт своей очереди. */
+	get pending() {
+		return this.#gate.pending;
+	}
+	/** Ставит запрос в очередь: сначала слот бакета, затем общий слот направления. */
+	schedule(task, signal) {
+		const generation = this.#generation;
+		return this.#gate.schedule(() => {
+			if (generation !== this.#generation) return Promise.reject(queueStoppedError());
+			return this.#shared.schedule(task, signal);
+		}, signal);
+	}
+	/**
+	* Учитывает заголовки ответа.
+	*
+	* Вызывается после каждого ответа, включая ошибочные: сервер списывает квоту одинаково
+	* с `404`, `422` и `200`.
+	*
+	* @returns на сколько миллисекунд придержан бакет; `0` — темп не ограничен
+	*/
+	observe(limit, remaining) {
+		if (limit !== void 0 && Number.isFinite(limit) && limit > 0) this.#limit = limit;
+		if (remaining !== void 0) this.#remaining = remaining;
+		if (this.#pacing === RateLimitPacing.Off || remaining === void 0) return 0;
+		if (this.#flatPause !== void 0) {
+			if (remaining > 0) return 0;
+			this.#gate.pause(this.#flatPause);
+			return this.#flatPause;
+		}
+		const capacity = this.#capacity();
+		if (this.#smooth) {
+			if (capacity === void 0) return 0;
+			this.#refill(capacity);
+			if (remaining < this.#tokens) this.#tokens = remaining;
+			return this.#armPause(capacity);
+		}
+		if (remaining > 0) return 0;
+		const wait = capacity === void 0 ? UNKNOWN_CAPACITY_PAUSE : Math.ceil(RATE_LIMIT_WINDOW / Math.max(capacity, 1));
+		this.#gate.pause(wait);
+		return wait;
+	}
+	/** Придерживает бакет на названное время — путь ответа `429`. Оценка остатка обнуляется. */
+	pause(ms) {
+		if (this.#smooth) {
+			this.#tokens = 0;
+			this.#tokensAt = this.#clock.now();
+		}
+		this.#gate.pause(ms);
+	}
+	/** Снимок для `rateLimitState()`. */
+	state() {
+		return {
+			destination: this.#destination,
+			bucket: this.#bucket,
+			limit: this.#limit,
+			remaining: this.#remaining,
+			active: this.#gate.active,
+			pending: this.#gate.pending
+		};
+	}
+	/**
+	* Останавливает уровень бакета. Общая очередь направления гасится пулом.
+	*
+	*/
+	stop() {
+		this.#generation += 1;
+		this.#gate.stop();
+	}
+	/** Лимит бакета: сказанный сервером, иначе табличный. */
+	#capacity() {
+		return this.#limit ?? this.#seedLimit;
+	}
+	/** Списывает токен на уходящий запрос и придерживает бакет до следующего. */
+	#spend() {
+		const capacity = this.#capacity();
+		if (capacity === void 0) return;
+		this.#refill(capacity);
+		this.#tokens -= 1;
+		this.#armPause(capacity);
+	}
+	/** Возвращает накопленное с прошлой проверки: `limit` единиц за минуту. */
+	#refill(capacity) {
+		const now = this.#clock.now();
+		if (this.#tokensAt !== void 0) {
+			const restored = (now - this.#tokensAt) * capacity / RATE_LIMIT_WINDOW;
+			this.#tokens = Math.min(capacity, this.#tokens + restored);
+		}
+		this.#tokensAt = now;
+	}
+	/** Держит бакет, пока не накопится хотя бы один токен. */
+	#armPause(capacity) {
+		if (this.#tokens >= 1) return 0;
+		const wait = Math.ceil((1 - this.#tokens) * RATE_LIMIT_WINDOW / capacity);
+		this.#gate.pause(wait);
+		return wait;
+	}
+};
+/** Лимит бакета до первого ответа: поправка пользователя важнее табличного значения. */
+function seedLimit(bucket, options) {
+	const override = options.bucketOverrides[bucket]?.limit;
+	if (override !== void 0) return override;
+	return isKnownBucket(bucket) ? BUCKET_LIMITS[bucket] : void 0;
+}
 /**
-* Очереди по конечным направлениям запросов.
+* Очереди по парам «направление — серверный счётчик частоты».
 *
-* Ключом обычно служит origin уже разрешённого URL. Поэтому разные локальные имена одного
-* хоста разделяют лимит, а запрос с разовым внешним `baseUrl` не попадает в основную очередь.
+* Направление — origin уже разрешённого URL: разные локальные имена одного хоста делят
+* лимит, а запрос с разовым внешним `baseUrl` не попадает в основную очередь. Мощность
+* карты ограничена каталогом операций, поэтому ни TTL, ни вытеснение не нужны.
 *
 * @internal
 */
 var RequestQueuePool = class {
 	#options;
 	#clock;
-	#main;
-	/** Очереди направлений заводятся при первом запросе. */
-	#byDestination = /* @__PURE__ */ new Map();
+	/** Ключ `undefined` — основная очередь внутренних клиентов без известного направления. */
+	#destinations = /* @__PURE__ */ new Map();
 	constructor(options, clock = systemClock) {
 		this.#options = options;
 		this.#clock = clock;
-		this.#main = new RequestQueue(options, clock);
 	}
-	/** Очередь направления. `undefined` сохраняет основную очередь для внутренних клиентов. */
-	for(destination) {
-		if (destination === void 0) return this.#main;
-		let queue = this.#byDestination.get(destination);
+	/** Очередь бакета на направлении. При `buckets: false` бакет всегда `default`. */
+	for(destination, bucket = DEFAULT_RATE_LIMIT_BUCKET) {
+		const name = this.#options.buckets ? bucket : DEFAULT_RATE_LIMIT_BUCKET;
+		let entry = this.#destinations.get(destination);
+		if (!entry) {
+			entry = {
+				shared: new RequestQueue(this.#options, this.#clock),
+				buckets: /* @__PURE__ */ new Map()
+			};
+			this.#destinations.set(destination, entry);
+		}
+		let queue = entry.buckets.get(name);
 		if (!queue) {
-			queue = new RequestQueue(this.#options, this.#clock);
-			this.#byDestination.set(destination, queue);
+			queue = new BucketQueue(destination, name, entry.shared, this.#options, this.#clock);
+			entry.buckets.set(name, queue);
 		}
 		return queue;
 	}
-	/** Останавливает все очереди. */
+	/** Снимки всех бакетов, о которых что-то известно. */
+	states() {
+		const states = [];
+		for (const entry of this.#destinations.values()) for (const queue of entry.buckets.values()) states.push(queue.state());
+		return states;
+	}
+	/**
+	* Останавливает оба уровня всех очередей: ожидающие задачи отклоняются, а состояние
+	* счётчиков и отложенные паузы сохраняются до следующего запуска — путь `close()`.
+	*/
 	stop() {
-		this.#main.stop();
-		for (const queue of this.#byDestination.values()) queue.stop();
+		for (const entry of this.#destinations.values()) {
+			for (const queue of entry.buckets.values()) queue.stop();
+			entry.shared.stop();
+		}
+	}
+	/** Останавливает очереди и забывает всё, что известно о счётчиках, — путь `dispose()`. */
+	clear() {
+		this.stop();
+		this.#destinations.clear();
 	}
 };
 //#endregion
@@ -2686,6 +3155,11 @@ function readIntHeader(headers, name) {
 	const value = Number.parseInt(raw, 10);
 	return Number.isFinite(value) ? value : void 0;
 }
+/** Читает положительное целое число из заголовка. */
+function readPositiveIntHeader(headers, name) {
+	const value = readIntHeader(headers, name);
+	return value !== void 0 && value > 0 ? value : void 0;
+}
 /**
 * Читает сведения об ограничении частоты.
 *
@@ -2694,7 +3168,7 @@ function readIntHeader(headers, name) {
 */
 function readRateLimit(headers) {
 	return {
-		limit: readIntHeader(headers, "x-ratelimit-limit"),
+		limit: readPositiveIntHeader(headers, "x-ratelimit-limit"),
 		remaining: readIntHeader(headers, "x-ratelimit-remaining")
 	};
 }
@@ -2843,17 +3317,25 @@ function abortable(promise, signal) {
 	});
 }
 /**
-* Объединяет пользовательский `AbortSignal` с таймаутом.
+* Объединяет пользовательский `AbortSignal`, сигнал жизни клиента и таймаут.
 *
 * Реализовано вручную, а не через `AbortSignal.any`: последний появился только в Node 20,
-* а библиотека поддерживает Node 18.
+* а библиотека поддерживает Node 18. Причина отмены переносится от источника как есть.
 */
-function createAbortBundle(userSignal, timeout, clock) {
+function createAbortBundle(userSignal, lifetimeSignal, 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 link = (source) => {
+		if (!source) return void 0;
+		if (source.aborted) {
+			controller.abort(source.reason);
+			return;
+		}
+		const onAbort = () => controller.abort(source.reason);
+		source.addEventListener("abort", onAbort, { once: true });
+		return () => source.removeEventListener("abort", onAbort);
+	};
+	const unlink = [link(userSignal), link(lifetimeSignal)];
 	const cancelTimer = timeout > 0 ? clock.schedule(() => {
 		timedOut = true;
 		controller.abort();
@@ -2863,7 +3345,7 @@ function createAbortBundle(userSignal, timeout, clock) {
 		timedOut: () => timedOut,
 		cleanup: () => {
 			cancelTimer?.();
-			userSignal?.removeEventListener("abort", onUserAbort);
+			for (const detach of unlink) detach?.();
 		}
 	};
 }
@@ -2900,7 +3382,7 @@ 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, this.#config.clock);
+		const abort = createAbortBundle(request.signal, this.#deps.lifetimeSignal, timeout, this.#config.clock);
 		const startedAt = this.#config.clock.now();
 		let cleanupBody;
 		try {
@@ -3117,7 +3599,7 @@ var Transport = class {
 			path: request.path
 		});
 		if (aborted) {
-			const reason = request.signal?.reason;
+			const reason = abort.signal.reason;
 			return new require_storage.ItdAbortError(`Запрос ${method} ${request.path} отменён`, reason !== void 0 ? { cause: reason } : void 0);
 		}
 		if (error instanceof require_storage.ItdError) return error;
@@ -3158,38 +3640,55 @@ function createServiceRegistry(config) {
 function createClientRuntime(options = {}, internals = {}) {
 	const config = resolveConfig(options);
 	const jar = new require_multi_storage.CookieJar();
-	const plugins = new PluginRegistry();
+	const plugins = new PluginRegistry({
+		shutdownTimeout: config.shutdownTimeout,
+		clock: config.clock
+	});
 	const services = createServiceRegistry(config);
+	const lifetime = new AbortController();
 	const sharedQueues = config.rateLimit ? internals.queues : void 0;
 	const queues = sharedQueues ?? (config.rateLimit ? new RequestQueuePool(config.rateLimit, config.clock) : void 0);
 	const ownsQueues = sharedQueues === void 0;
 	let auth;
 	let transport;
+	/**
+	* Бакет, из которого спишется запрос.
+	*
+	* Источники по убыванию приоритета: `rateLimitBucket` запроса, правило `rateLimit.bucket`,
+	* каталог операций.
+	*/
+	const bucketFor = (request) => {
+		if (request.rateLimitBucket !== void 0) return request.rateLimitBucket;
+		return config.rateLimit?.bucket?.({
+			operationId: request.operationId,
+			method: request.method,
+			path: request.path
+		}) ?? operationBucket(request.operationId);
+	};
+	const queueKeyFor = (request) => requestQueueKey(request, (target) => ({
+		destination: require_multi_storage.originOf(transport.buildUrl(target)) || void 0,
+		bucket: bucketFor(target)
+	}));
 	const queueFor = (request) => {
-		const destination = require_multi_storage.originOf(transport.buildUrl(request));
-		return queues?.for(destination || void 0);
+		if (!queues) return void 0;
+		const key = queueKeyFor(request);
+		return queues.for(key.destination, key.bucket);
 	};
-	/**
-	* Сервер сообщает остаток окна в `x-ratelimit-remaining`, но не сообщает момент сброса.
-	* При нуле заранее ставим очередь конечного origin на первую, самую короткую паузу из
-	* `retryDelays`: окно могло почти истечь, поэтому длинный backoff здесь преждевременен.
-	* Если окно всё ещё закрыто, следующий `429` применит самостоятельную лестницу повторов.
-	* Общая пауза очереди не даёт параллельным запросам одновременно ударить в тот же лимит.
-	*/
-	const throttleByHeaders = (limit, remaining, request) => {
-		if (remaining === void 0 || remaining > 0) return;
-		const first = config.rateLimit?.retryDelays[0];
-		if (first === void 0) return;
-		queueFor(request)?.pause(first);
-		config.logger?.debug(`лимит сервера исчерпан (${remaining} из ${limit ?? "?"}), очередь ждёт ${first} мс`);
+	/** Передаёт остаток из заголовков ответа бакету запроса; тот решает, тормозить ли себя. */
+	const observeRateLimit = (limit, remaining, request) => {
+		const queue = queueFor(request);
+		if (!queue) return;
+		const waited = queue.observe(limit, remaining);
+		if (waited > 0) config.logger?.debug(`остаток лимита ${remaining} из ${limit ?? "?"}, бакет ${queue.bucket} ждёт ${waited} мс`);
 	};
 	transport = new Transport({
 		...config,
 		hooks: config.hooks
 	}, {
+		onRateLimit: queues ? observeRateLimit : void 0,
 		cookies: config.useCookieJar ? jar : void 0,
 		getDeviceId: () => auth.getDeviceId(),
-		onRateLimit: queues && config.rateLimit?.respectHeaders ? throttleByHeaders : void 0
+		lifetimeSignal: lifetime.signal
 	});
 	const stages = [
 		{
@@ -3243,6 +3742,7 @@ function createClientRuntime(options = {}, internals = {}) {
 	const clientHandler = (request) => {
 		try {
 			if (!isDisposeCleanupRequest(request)) internals.assertActive?.("выполнить новый запрос");
+			if (request.rateLimitBucket !== void 0) assertKnownBucket(request.rateLimitBucket, "rateLimitBucket", config.rateLimit?.bucket);
 		} catch (error) {
 			return Promise.reject(error);
 		}
@@ -3263,12 +3763,15 @@ function createClientRuntime(options = {}, internals = {}) {
 		services,
 		stageOrder,
 		platformHeaders: (url) => transport.platformHeaders(url),
+		rateLimitState: () => queues?.states() ?? [],
 		close: () => {
 			if (ownsQueues) queues?.stop();
 		},
-		dispose: () => {
+		dispose: async () => {
+			lifetime.abort(new require_storage.ItdAbortError("Клиент освобождён через dispose(), запрос отменён"));
+			if (ownsQueues) queues?.clear();
 			auth.dispose();
-			return plugins.dispose();
+			await plugins.dispose();
 		}
 	};
 }
@@ -3626,7 +4129,12 @@ var RealtimeDispatcher = class {
 			if (index >= 0) this.#handlers.splice(index, 1);
 		};
 	}
-	dispatch(context) {
+	/**
+	* Принимает обновление к обработке.
+	*
+	* @param coalesceKey ожидающая работа с тем же ключом заменяется новой
+	*/
+	dispatch(context, coalesceKey) {
 		let keys;
 		let middleware;
 		try {
@@ -3636,12 +4144,20 @@ var RealtimeDispatcher = class {
 			this.#hooks.middlewareError(error, context);
 			return;
 		}
-		this.#queue.push({
+		const replaced = coalesceKey === void 0 ? -1 : this.#queue.findIndex((pending) => pending.coalesceKey === coalesceKey);
+		if (replaced < 0 && this.#queue.length >= 256) {
+			this.#hooks.overflow();
+			return;
+		}
+		const work = {
 			context,
 			middleware,
 			handlers: [...this.#handlers],
-			keys
-		});
+			keys,
+			coalesceKey
+		};
+		if (replaced >= 0) this.#queue[replaced] = work;
+		else this.#queue.push(work);
 		this.#pump();
 	}
 	/** Отбрасывает обновления, обработка которых ещё не началась. */
@@ -3718,14 +4234,6 @@ const RECONNECT_BACKOFF = Object.freeze([
 	16e3,
 	3e4
 ]);
-/** Доля случайного разброса паузы. */
-const RECONNECT_JITTER = .3;
-/**
-* Сколько раз пытаться переподключиться подряд.
-*
-* После исчерпания поток сообщает `giveup` и ждёт ручного `connect()`.
-*/
-const MAX_RECONNECT_ATTEMPTS = 15;
 /**
 * Вычисляет паузу перед попыткой переподключения.
 *
@@ -4026,7 +4534,8 @@ var RealtimeEngine = class {
 		}, {
 			deliver: (context) => this.#deps.deliver(context.update),
 			middlewareError: (error, context) => this.#reportDispatchError("middlewareError", error, context),
-			handlerError: (error, context) => this.#reportDispatchError("handlerError", error, context)
+			handlerError: (error, context) => this.#reportDispatchError("handlerError", error, context),
+			overflow: () => this.#handleOverflow()
 		});
 	}
 	/** Текущее состояние соединения. */
@@ -4107,7 +4616,23 @@ var RealtimeEngine = class {
 	/** Пропускает актуальное обновление через цепочку обработчиков. */
 	#dispatch(update, raw, origin) {
 		if (!this.#wanted) return;
-		this.#dispatcher.dispatch(this.#deps.createContext(update, raw, origin));
+		this.#dispatcher.dispatch(this.#deps.createContext(update, raw, origin), this.#deps.coalesceKey?.(update));
+	}
+	/**
+	* Очередь обновлений достигла предела: закрывает соединение и переподключается,
+	* когда обработчики разберут очередь.
+	*/
+	#handleOverflow() {
+		const controller = this.#controller;
+		if (!this.#wanted || !controller) return;
+		const generation = this.#generation;
+		controller.abort();
+		this.#controller = void 0;
+		this.#setStatus(RealtimeStatus.Error);
+		const error = /* @__PURE__ */ new Error("Обработчики не успевают за потоком: очередь обновлений переполнена");
+		this.#dispatcher.drain().then(() => {
+			if (this.#isCurrentGeneration(generation) && !this.#controller) this.#scheduleReconnect(error);
+		});
 	}
 	/** Выполняет доменную синхронизацию, не роняя подключение из-за её ошибки. */
 	async #sync(reason, generation, starting) {
@@ -4132,6 +4657,7 @@ var RealtimeEngine = class {
 			baseUrl: this.#deps.baseUrl,
 			authorize: this.#deps.authorize,
 			fetch: this.#deps.fetch,
+			request: this.#deps.request,
 			baseHeaders: this.#deps.baseHeaders,
 			getToken: this.#deps.getToken,
 			signal: controller.signal,
@@ -4230,7 +4756,12 @@ var RealtimeEngine = class {
 		this.#starting = void 0;
 		if (this.#isCurrentGeneration(generation)) this.#run(generation);
 	}
-	/** Завершает автоматические попытки переподключения. */
+	/**
+	* Завершает автоматические попытки переподключения.
+	*
+	* Владелец узнаёт об этом так же, как при {@link disconnect}. `onClose` вызывается
+	* до событий: обработчик `giveup` может тут же вызвать `connect()`.
+	*/
 	#giveUp(error) {
 		this.#wanted = false;
 		this.#generation += 1;
@@ -4238,6 +4769,7 @@ var RealtimeEngine = class {
 		this.#attempt = 0;
 		this.#detachEnvironment?.();
 		this.#detachEnvironment = void 0;
+		this.#deps.onClose?.();
 		this.#emitEngine("error", {
 			error,
 			willReconnect: false
@@ -4310,26 +4842,15 @@ var PollTransport = class {
 		this.#limit = options.limit ?? 20;
 	}
 	async connect(context) {
+		const request = context.request;
+		if (!request) throw new require_storage.ItdConfigError("опрос уведомлений выполняется через конвейер клиента; создайте поток вызовом itd.realtime()");
 		const seen = /* @__PURE__ */ new Set();
 		let firstRun = true;
 		let lastUnreadCount;
 		while (!context.signal.aborted) {
-			const token = context.authorize ? await context.getToken() : null;
-			if (context.authorize && !token) throw new UnauthorizedStreamError();
-			const url = `${require_multi_storage.joinUrl(context.baseUrl, "/api/notifications/")}?limit=${this.#limit}&offset=0`;
-			const headers = await context.baseHeaders(url);
-			headers.set("Accept", "application/json");
-			if (token) headers.set("Authorization", `Bearer ${token}`);
-			const response = await context.fetch(url, {
-				method: "GET",
-				headers,
-				signal: context.signal
-			});
-			if (context.authorize && response.status === 401) throw new UnauthorizedStreamError();
-			if (!response.ok) throw new Error(`Опрос уведомлений вернул статус ${response.status}`);
+			const payload = await this.#readUpdates(request, context.signal);
 			context.onOpen();
-			const body = await response.json();
-			const items = pickArray(typeof body === "object" && body !== null && "data" in body ? body.data : body, "notifications");
+			const items = pickArray(payload, "notifications");
 			for (const item of [...items].reverse()) {
 				const id = typeof item.id === "string" ? item.id : void 0;
 				if (!id || seen.has(id)) continue;
@@ -4343,7 +4864,7 @@ var PollTransport = class {
 				const excess = [...seen].slice(0, seen.size - this.#limit * 2);
 				for (const id of excess) seen.delete(id);
 			}
-			const count = await this.#readCount(context, headers);
+			const count = await this.#readCount(request, context.signal);
 			if (count !== void 0 && count !== lastUnreadCount) {
 				lastUnreadCount = count;
 				context.onEvent({
@@ -4355,16 +4876,29 @@ var PollTransport = class {
 			await this.#wait(context.signal);
 		}
 	}
-	async #readCount(context, headers) {
+	async #readUpdates(request, signal) {
 		try {
-			const response = await context.fetch(require_multi_storage.joinUrl(context.baseUrl, "/api/notifications/count"), {
-				method: "GET",
-				headers,
-				signal: context.signal
+			return await request({
+				operationId: "realtime.poll.updates",
+				path: "/api/notifications/",
+				query: {
+					limit: this.#limit,
+					offset: 0
+				},
+				signal
 			});
-			if (!response.ok) return void 0;
-			const body = await response.json();
-			return pickNumber(typeof body === "object" && body !== null && "data" in body ? body.data : body, "count", 0);
+		} catch (error) {
+			if (require_storage.isItdAuthError(error)) throw new UnauthorizedStreamError();
+			throw error;
+		}
+	}
+	async #readCount(request, signal) {
+		try {
+			return pickNumber(await request({
+				operationId: "realtime.poll.unread",
+				path: "/api/notifications/count",
+				signal
+			}), "count", 0);
 		} catch {
 			return;
 		}
@@ -4724,6 +5258,7 @@ var ItdRealtime = class {
 			baseUrl: deps.baseUrl,
 			authorize: deps.authorize ?? true,
 			fetch: deps.fetch,
+			request: deps.request,
 			clock: deps.clock,
 			baseHeaders: deps.baseHeaders,
 			getToken: deps.getToken,
@@ -4734,6 +5269,7 @@ var ItdRealtime = class {
 			transport: createTransport(deps, options),
 			handleFrame: (event) => this.#handleFrame(event),
 			readUpdate: readRealtimeUpdate,
+			coalesceKey: (update) => update.type === RealtimeUpdateType.UnreadCount ? update.type : void 0,
 			createContext: (update, raw, origin) => ({
 				update,
 				stream: this,
@@ -6010,10 +6546,6 @@ function createMultipartFileBody(file) {
 		cancel
 	};
 }
-//#endregion
-//#region src/resources/files.ts
-/** Таймаут одной попытки загрузки файла — 5 минут. */
-const DEFAULT_UPLOAD_TIMEOUT = 3e5;
 /** Файлы и медиа. */
 var FilesResource = class extends BaseResource {
 	#fetch;
@@ -8960,6 +9492,22 @@ var ItdClient = class ItdClient {
 		});
 	}
 	/**
+	* Остаток серверных лимитов по бакетам, через которые уже проходили запросы.
+	*
+	* Значения берутся из последнего ответа каждого бакета и быстро устаревают: сервер
+	* восстанавливает квоту линейно и границу окна не сообщает. Пустой массив при
+	* `rateLimit: false`. {@link close} снимок сохраняет, {@link dispose} очищает.
+	*
+	* @example
+	* ```ts
+	* const posts = itd.rateLimitState().find((state) => state.bucket === 'posts.create');
+	* if ((posts?.remaining ?? Number.POSITIVE_INFINITY) < 3) await sleep(60_000);
+	* ```
+	*/
+	rateLimitState() {
+		return this.#runtime.rateLimitState();
+	}
+	/**
 	* Подключает плагин.
 	*
 	* Плагин может независимо регистрировать transformer логической операции и interceptor
@@ -9095,6 +9643,11 @@ var ItdClient = class ItdClient {
 		stream = new ItdRealtime({
 			baseUrl: this.#runtime.config.baseUrl,
 			fetch: this.#runtime.config.fetch,
+			request: ({ operationId, path, query, signal }) => this.#runtime.http.operation(operationId, {
+				path,
+				query,
+				signal
+			}),
 			baseHeaders: (url) => this.#runtime.platformHeaders(url),
 			getAuthIdentity: () => this.#runtime.auth.getCurrentAuthIdentity(),
 			getAuthScope: () => this.#runtime.auth.getAuthScope(),
@@ -9114,13 +9667,16 @@ var ItdClient = class ItdClient {
 	* Освобождает ресурсы клиента: закрывает все потоки уведомлений, отправляет открытые
 	* накопители {@link telemetry}, затем останавливает очередь запросов.
 	*
-	* Метод дожидается активных обработчиков потока. После вызова клиентом можно пользоваться
-	* снова; ранее созданный поток можно запустить повторным `connect()`.
+	* Метод дожидается активных обработчиков потока, но не дольше `shutdownTimeout`. После
+	* вызова клиентом можно пользоваться снова; ранее созданный поток можно запустить
+	* повторным `connect()`.
 	*
 	* Общая очередь, полученная от {@link ItdAccounts}, не останавливается: её гасит сам
 	* контейнер, когда закрывает все аккаунты разом.
 	*
 	* Терминальное освобождение — это {@link dispose}.
+	*
+	* @throws {ItdStateError} если обработчики потока не завершились за отведённый срок
 	*/
 	async close() {
 		return this.#close(false);
@@ -9128,22 +9684,30 @@ var ItdClient = class ItdClient {
 	async #close(disposeCleanup) {
 		const streams = this.#disconnectStreams();
 		if (disposeCleanup) prepareTelemetryForDispose(this.#telemetry);
+		const { shutdownTimeout, clock } = this.#runtime.config;
+		const deadline = createDeadline(shutdownTimeout, clock);
+		let stuck = [];
 		try {
-			await Promise.all(streams.map((stream) => stream.drain()));
+			stuck = (await Promise.all(streams.map(async (stream) => await deadline.wait(stream.drain()) ? void 0 : stream))).filter((stream) => stream !== void 0);
 			if (disposeCleanup) await closeTelemetryForDispose(this.#telemetry);
 			else await this.#telemetry?.close();
 		} finally {
+			deadline.cancel();
 			this.#runtime.close();
 		}
+		if (stuck.length > 0) throw new require_storage.ItdStateError(`обработчики потоков (${stuck.map((stream) => stream.transport).join(", ")}) не завершились за ${shutdownTimeout} мс; ожидание прекращено`);
 	}
 	/**
-	* Окончательно освобождает клиент: выполняет {@link close} и отключает все плагины.
+	* Окончательно освобождает клиент: выполняет {@link close}, отменяет незавершённые
+	* запросы и отключает все плагины.
 	*
 	* Терминальное состояние устанавливается сразу при первом вызове. После этого новые
 	* запросы, подключение плагинов, регистрация сервисов и создание или повторный запуск
 	* realtime-потоков завершаются с {@link ItdStateError}. Повторные вызовы возвращают
 	* тот же результат очистки.
 	*
+	* Ожидание обработчиков потока и операций плагинов ограничено `shutdownTimeout`.
+	*
 	* @example
 	* ```ts
 	* await using itd = new ItdClient({ auth: token });
@@ -9313,7 +9877,7 @@ var ItdAccounts = class ItdAccounts {
 		this.#base = base;
 		this.#storage = storage ?? new require_multi_storage.MemoryMultiTokenStorage();
 		this.#plugins = orderPluginDefinitions(plugins ?? []);
-		this.#rateLimitScope = rateLimitScope ?? "account";
+		this.#rateLimitScope = rateLimitScope ?? "shared";
 		const rateLimit = this.#rateLimitScope === "shared" ? resolveRateLimit(base.rateLimit) : void 0;
 		this.#queues = rateLimit ? new RequestQueuePool(rateLimit, base.clock ?? systemClock) : void 0;
 		const logger = typeof base.logger === "object" ? base.logger : void 0;
@@ -9605,7 +10169,7 @@ var ItdAccounts = class ItdAccounts {
 			...clients.map((client) => client.dispose()),
 			...controls.map((control) => control.drain()),
 			...accountRemovals,
-			Promise.resolve().then(() => this.#queues?.stop())
+			Promise.resolve().then(() => this.#queues?.clear())
 		]);
 		this.#plugins.splice(0);
 		this.#removingPlugins.clear();
@@ -10122,10 +10686,6 @@ var RealtimeComposer = class RealtimeComposer {
 		return (context, next) => runRealtimeMiddleware(snapshot, context, next);
 	}
 };
-//#endregion
-//#region src/realtime/websocket.ts
-/** Стандартный путь WebSocket-подключения. */
-const WEBSOCKET_PATH = "/api/ws";
 const CONNECTING = 0;
 const OPEN = 1;
 const NORMAL_CLOSURE = 1e3;
@@ -10263,6 +10823,7 @@ var WebSocketTransport = class {
 			let discardMessages = false;
 			let socketError;
 			let messageQueue = Promise.resolve();
+			let pendingFrames = 0;
 			let cancelHandshake;
 			let cancelIdle;
 			let cancelKeepAlive;
@@ -10341,7 +10902,13 @@ var WebSocketTransport = class {
 					pending = Promise.resolve({ error });
 				}
 				if (pending === void 0) return;
+				if (pendingFrames >= 256) {
+					closeWithError(/* @__PURE__ */ new Error(`WebSocket ${redactUrl(url)}: очередь кадров переполнена`), 4e3, "queue overflow");
+					return;
+				}
+				pendingFrames += 1;
 				messageQueue = messageQueue.then(async () => {
+					pendingFrames -= 1;
 					if (settled || discardMessages) return;
 					const decoded = await pending;
 					if ("error" in decoded) {
@@ -10636,21 +11203,12 @@ function renderSpans(content, spans = [], options = {}) {
 //#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;
-exports.AUTH_PATHS = AUTH_PATHS;
 exports.AccessType = AccessType;
 exports.AttachmentType = AttachmentType;
-exports.BUILT_IN_SERVICES = BUILT_IN_SERVICES;
+exports.BUCKET_LIMITS = BUCKET_LIMITS;
 exports.CommentSort = CommentSort;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
-exports.DEFAULT_FILE_STREAM_BUFFER_BYTES = require_multi_storage.DEFAULT_FILE_STREAM_BUFFER_BYTES;
-exports.DEFAULT_STATUS_BASE_URL = DEFAULT_STATUS_BASE_URL;
-exports.DEFAULT_TIMEOUT = DEFAULT_TIMEOUT;
-exports.DEFAULT_UPLOAD_TIMEOUT = DEFAULT_UPLOAD_TIMEOUT;
-exports.DEFAULT_URL_FILE_MAX_BYTES = require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES;
-exports.DEFAULT_USER_AGENT = DEFAULT_USER_AGENT;
-exports.DEVICE_ID_HEADER = DEVICE_ID_HEADER;
-exports.DetectedRuntime = DetectedRuntime;
+exports.DEFAULT_RATE_LIMIT_BUCKET = DEFAULT_RATE_LIMIT_BUCKET;
 exports.FeedTab = FeedTab;
 exports.FileTransferMode = require_multi_storage.FileTransferMode;
 exports.IMAGE_MIME_TYPES = IMAGE_MIME_TYPES;
@@ -10681,19 +11239,14 @@ exports.ItdTimeoutError = require_storage.ItdTimeoutError;
 exports.ItdValidationError = require_storage.ItdValidationError;
 exports.LIBRARY_VERSION = LIBRARY_VERSION;
 exports.LikesVisibility = LikesVisibility;
-exports.MAX_RECONNECT_ATTEMPTS = MAX_RECONNECT_ATTEMPTS;
 exports.MemoryKeyValueStore = require_storage.MemoryKeyValueStore;
 exports.MemoryMultiTokenStorage = require_multi_storage.MemoryMultiTokenStorage;
 exports.MemoryTokenStorage = require_storage.MemoryTokenStorage;
-exports.NOTIFICATION_TYPE_ALIASES = NOTIFICATION_TYPE_ALIASES;
 exports.NotificationType = NotificationType;
 exports.OPERATIONS = OPERATIONS;
 exports.PaginationMode = PaginationMode;
 exports.Paginator = Paginator;
-exports.RECONNECT_BACKOFF = RECONNECT_BACKOFF;
-exports.RECONNECT_JITTER = RECONNECT_JITTER;
-exports.REFRESH_COOKIE = require_multi_storage.REFRESH_COOKIE;
-exports.REFRESH_COOKIE_PATH = require_multi_storage.REFRESH_COOKIE_PATH;
+exports.RateLimitPacing = RateLimitPacing;
 exports.RealtimeComposer = RealtimeComposer;
 exports.RealtimeRouter = RealtimeRouter;
 exports.RealtimeStatus = RealtimeStatus;
@@ -10705,8 +11258,6 @@ exports.ReportTargetType = ReportTargetType;
 exports.RetrySafety = RetrySafety;
 exports.RuntimeMode = RuntimeMode;
 exports.STATUS_SERVICE = STATUS_SERVICE;
-exports.STREAM_PATH = STREAM_PATH;
-exports.ServiceRegistry = ServiceRegistry;
 exports.ServiceState = ServiceState;
 exports.SignInStatus = SignInStatus;
 exports.SpanRenderFormat = SpanRenderFormat;
@@ -10716,7 +11267,6 @@ exports.UnauthorizedStreamError = UnauthorizedStreamError;
 exports.VIDEO_MIME_TYPES = VIDEO_MIME_TYPES;
 exports.ViewReason = ViewReason;
 exports.ViewSource = ViewSource;
-exports.WEBSOCKET_PATH = WEBSOCKET_PATH;
 exports.WallAccess = WallAccess;
 exports.WebSocketTransport = WebSocketTransport;
 exports.autoSpans = autoSpans;
@@ -10751,14 +11301,13 @@ exports.isMyProfile = isMyProfile;
 exports.mapPage = mapPage;
 exports.markup = markup;
 exports.normalizeNotification = normalizeNotification;
+exports.operationBucket = operationBucket;
 exports.operationMethod = operationMethod;
 exports.operationRetrySafety = operationRetrySafety;
 exports.parseHtml = parseHtml;
 exports.parseMarkdown = parseMarkdown;
 exports.poll = poll;
 exports.post = post;
-exports.readNotificationEvent = readNotificationEvent;
-exports.readUnreadCountEvent = readUnreadCountEvent;
 exports.renderSpans = renderSpans;
 exports.report = report;
 exports.resolveNotificationUrl = resolveNotificationUrl;