itd-api 0.7.0 → 0.7.1

package/dist/shared/url-CYXgxqGx.js

@@ -0,0 +1,3673 @@
+import { O as isItdRateLimitError, _ as ItdStateError, a as ItdConfigError, b as isItdApiError, d as ItdForbiddenError, f as ItdNetworkError, g as ItdServerError, h as ItdRateLimitError, i as ItdAuthError, l as ItdFileError, m as ItdPhoneVerificationError, n as ItdApiError, o as ItdConflictError, p as ItdNotFoundError, s as ItdError, t as ItdAbortError, v as ItdTimeoutError, y as ItdValidationError } from "./errors-Bhrd2fJd.js";
+import { a as buildQuery, c as isSameSite, d as originOf, l as joinUrl, n as CookieJar, s as hostOf, u as normalizeBaseUrl } from "./cookies-tX2sNwxb.js";
+//#region src/core/async-dispose.ts
+/**
+* Подставляет метод `await using` там, где `Symbol.asyncDispose` отсутствует.
+*
+* В Node 18 символа нет, поэтому объявление метода `[Symbol.asyncDispose]()` кладёт его
+* под ключ `"undefined"`. Здесь он переносится на ключ, который среда ищет фактически, —
+* `Symbol.for('Symbol.asyncDispose')`.
+*
+* Вызывается из статического блока класса: так поведение привязано к самому классу и не
+* зависит от того, дошёл ли bundler до модуля с побочным эффектом.
+*/
+function installAsyncDisposeFallback(target) {
+	if (typeof Symbol.asyncDispose === "symbol") return;
+	const prototype = target.prototype;
+	prototype[Symbol.for("Symbol.asyncDispose")] = prototype.undefined;
+	delete prototype.undefined;
+}
+//#endregion
+//#region src/core/clock.ts
+/** Системные часы, используемые клиентом по умолчанию. */
+const systemClock = Object.freeze({
+	now: () => Date.now(),
+	schedule(callback, delay) {
+		const timer = setTimeout(callback, delay);
+		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/runtime.ts
+/**
+* Как библиотека обращается с cookie.
+*
+* - `browser` — cookie ведёт браузер, запросы уходят с `credentials: 'include'`;
+* - `server` — cookie ведёт встроенный jar, заголовок `Cookie` подставляется вручную;
+* - `auto` — определяется по среде исполнения (значение по умолчанию).
+*/
+const RuntimeMode = Object.freeze({
+	/** Определяется по среде исполнения. Значение по умолчанию. */
+	Auto: "auto",
+	/** Cookie ведёт браузер, запросы уходят с `credentials: 'include'`. */
+	Browser: "browser",
+	/** Cookie ведёт встроенный jar, заголовок `Cookie` подставляется вручную. */
+	Server: "server"
+});
+/** Распознанная среда исполнения. */
+const DetectedRuntime = Object.freeze({
+	Browser: "browser",
+	/** Есть `window`, но нет `document`; cookie ведёт нативный сетевой слой. */
+	ReactNative: "react-native",
+	Server: "server"
+});
+/**
+* Определяет среду исполнения.
+*
+* React Native выделен отдельно намеренно: там есть `window`, но нет `document`, а cookie
+* хранит нативный сетевой слой (`NSHTTPCookieStorage` / `OkHttp`). Свой jar в этой среде
+* привёл бы к отправке cookie дважды.
+*/
+function detectRuntime() {
+	if (globalThis.navigator?.product === "ReactNative") return DetectedRuntime.ReactNative;
+	if (typeof document !== "undefined") return DetectedRuntime.Browser;
+	return DetectedRuntime.Server;
+}
+/**
+* Нужно ли вести собственный cookie-jar.
+*
+* Только в серверных средах: в браузере `Set-Cookie` из JS не читается и не нужен,
+* в React Native cookie ведёт нативный слой.
+*/
+function shouldUseCookieJar(mode) {
+	if (mode === RuntimeMode.Browser) return false;
+	if (mode === RuntimeMode.Server) return true;
+	return detectRuntime() === DetectedRuntime.Server;
+}
+/**
+* Нужно ли отправлять запросы с `credentials: 'include'`.
+*
+* Только в браузере: именно так refresh-cookie попадает в запрос `POST /api/v1/auth/refresh`.
+* Требует настроенного CORS на стороне итд.com — если его нет, укажите свой прокси в `baseUrl`.
+*/
+function shouldSendCredentials(mode) {
+	if (mode === RuntimeMode.Browser) return true;
+	if (mode === RuntimeMode.Server) return false;
+	return detectRuntime() === DetectedRuntime.Browser;
+}
+/**
+* Возвращает реализацию `fetch`.
+*
+* @param custom реализация из конфигурации клиента, если пользователь её передал
+* @throws {ItdConfigError} если `fetch` недоступен — например, на Node ниже 18
+*/
+function resolveFetch(custom) {
+	if (custom !== void 0) {
+		if (typeof custom !== "function") throw new ItdConfigError("fetch должен быть функцией");
+		return custom;
+	}
+	if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+	throw new ItdConfigError("В этой среде нет глобального fetch. Обновитесь до Node 18+ либо передайте свою реализацию через опцию fetch.");
+}
+/**
+* Проверки бинарных типов, безопасные в любой среде.
+*
+* Обычный `instanceof` здесь недостаточен: конструктора может не быть вовсе, и тогда
+* проверка падает с `ReferenceError`, а не возвращает `false`. `Blob` есть в Node с 18.0,
+* но `File` стал глобальным только в Node 20 — при заявленной поддержке Node 18 голый
+* `instanceof File` ронял бы любую загрузку.
+*/
+function isBlob(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+/** @see {@link isBlob} */
+function isFile(value) {
+	return typeof File !== "undefined" && value instanceof File;
+}
+/** Доступно ли потоковое чтение тела ответа — от этого зависит, сработает ли SSE. */
+function supportsStreamingBody() {
+	return typeof ReadableStream !== "undefined" && typeof TextDecoder !== "undefined";
+}
+/**
+* Создаёт идентификатор устройства для заголовка `X-Device-Id` — UUID v4.
+*
+* `crypto.randomUUID` есть в Node 19+, браузерах и Deno, но отсутствует в Node 18 вне
+* защищённого контекста, поэтому предусмотрен запасной путь.
+*/
+function createDeviceId() {
+	const webCrypto = globalThis.crypto;
+	if (typeof webCrypto?.randomUUID === "function") return webCrypto.randomUUID();
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	if (typeof webCrypto?.getRandomValues === "function") webCrypto.getRandomValues(bytes);
+	else for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20, 32)
+	].join("-");
+}
+//#endregion
+//#region src/core/scheduling/pacing.ts
+/** Реакция на остаток лимита из заголовков ответа. */
+const RateLimitPacing = Object.freeze({
+	/** Задержек нет, пока в бакете есть остаток; исчерпанный бакет ждёт `60000 / limit`. */
+	React: "react",
+	/** Ровный темп в пределах минутного лимита: задержки идут с первого запроса. */
+	Smooth: "smooth",
+	/** Остаток на темп не влияет; остаётся пауза после `429`. */
+	Off: "off"
+});
+//#endregion
+//#region src/core/validate.ts
+/**
+* Проверки, общие для резолверов конфигурации.
+*
+* Настройки исполнения и настройки сессии разбираются в разных модулях, но сообщать
+* об ошибке должны одинаково: пользователю всё равно, какой слой отверг его значение.
+*/
+/** Похоже ли значение на объект настроек, а не на массив или `null`. */
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** @throws {ItdConfigError} если значение задано и не является неотрицательным числом */
+function requirePositive(value, name) {
+	if (!Number.isFinite(value) || value < 0) throw new ItdConfigError(`${name} должен быть неотрицательным числом, получено: ${value}`);
+	return value;
+}
+/** @throws {ItdConfigError} если значение задано и не является boolean */
+function requireOptionalBoolean(value, name) {
+	if (value !== void 0 && typeof value !== "boolean") throw new ItdConfigError(`${name} должен быть boolean`);
+}
+//#endregion
+//#region src/core/version.ts
+/** Версия библиотеки. Попадает в `User-Agent`. */
+const LIBRARY_VERSION = "0.7.1";
+//#endregion
+//#region src/core/config.ts
+/** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
+const DEFAULT_BASE_URL = "https://xn--d1ah4a.com";
+/** Базовый URL страницы статуса. Домен записан в punycode: `статус.итд.com`. */
+const DEFAULT_STATUS_BASE_URL = "https://xn--80a7abcbg.xn--d1ah4a.com";
+/** Имя встроенного сервиса статуса. */
+const STATUS_SERVICE = "status";
+/** Сервисы, зарегистрированные у любого клиента. */
+const BUILT_IN_SERVICES = Object.freeze([Object.freeze({
+	name: STATUS_SERVICE,
+	baseUrl: DEFAULT_STATUS_BASE_URL,
+	auth: false
+})]);
+/**
+* `User-Agent` по умолчанию.
+*
+* Сайт стоит за DDoS-Guard, и запросы вовсе без `User-Agent` (так делает `fetch` в Node)
+* имеют шанс не пройти фильтр. Префикс `Mozilla/5.0` — дань традиции таких фильтров,
+* дальше идёт честное имя библиотеки: подделываться под браузер она не должна.
+*
+* В браузере заголовок не выставляется — `User-Agent` там запрещён к изменению, и среда
+* молча его игнорирует.
+*/
+const DEFAULT_USER_AGENT = `Mozilla/5.0 (compatible; itd-api/${LIBRARY_VERSION}; +https://github.com/KiowDev/itd-api)`;
+/**
+* Паузы перед повторами при ответе `429`.
+*
+* Сервер итд.com не присылает `Retry-After` и не сообщает время сброса окна, поэтому паузу
+* приходится подбирать лестницей: от секунды, если окно почти истекло, до полутора минут.
+*/
+const DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([
+	1e3,
+	5e3,
+	3e4,
+	6e4,
+	9e4
+]);
+function resolveHeaders(headers) {
+	if (headers === void 0) return {};
+	if (!isRecord$1(headers)) throw new ItdConfigError("headers должен быть объектом строк");
+	for (const [name, value] of Object.entries(headers)) if (typeof value !== "string") throw new ItdConfigError(`headers.${name} должен быть строкой`);
+	return { ...headers };
+}
+function resolveHooks(hooks) {
+	if (hooks === void 0) return {};
+	if (!isRecord$1(hooks)) throw new ItdConfigError("hooks должен быть объектом");
+	for (const name of [
+		"onRequest",
+		"onResponse",
+		"onError",
+		"onRetry"
+	]) if (hooks[name] !== void 0 && typeof hooks[name] !== "function") throw new ItdConfigError(`hooks.${name} должен быть функцией`);
+	return { ...hooks };
+}
+function resolveLogger(logger) {
+	if (logger === void 0 || logger === false) return void 0;
+	if (logger === true) return consoleLogger();
+	if (!isRecord$1(logger)) throw new ItdConfigError("logger должен быть boolean или объектом Logger");
+	for (const method of [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]) if (typeof logger[method] !== "function") throw new ItdConfigError(`logger.${method} должен быть функцией`);
+	return logger;
+}
+/** Логгер поверх `console` — включается опцией `logger: true`. */
+function consoleLogger() {
+	return {
+		debug: (message, ...args) => console.debug(`[itd-api] ${message}`, ...args),
+		info: (message, ...args) => console.info(`[itd-api] ${message}`, ...args),
+		warn: (message, ...args) => console.warn(`[itd-api] ${message}`, ...args),
+		error: (message, ...args) => console.error(`[itd-api] ${message}`, ...args)
+	};
+}
+/**
+* Приводит настройки повторов к полному виду.
+*
+* Вызывается и при создании клиента (для глобальной настройки), и на каждый запрос,
+* у которого задан свой `retry`. Возвращает `undefined`, когда повторять не нужно
+* (`retry: false` или единственная попытка).
+*
+* @throws {ItdConfigError} при некорректных значениях
+*/
+function resolveRetry(retry) {
+	if (retry === false) return void 0;
+	if (retry !== void 0 && !isRecord$1(retry)) throw new ItdConfigError("retry должен быть объектом или false");
+	const options = retry ?? {};
+	const attempts = options.attempts ?? 3;
+	if (!Number.isInteger(attempts) || attempts < 1) throw new ItdConfigError(`retry.attempts должен быть целым числом от 1, получено: ${attempts}`);
+	const jitter = options.jitter ?? .3;
+	if (!Number.isFinite(jitter) || jitter < 0 || jitter > 1) throw new ItdConfigError(`retry.jitter должен быть в диапазоне 0…1, получено: ${jitter}`);
+	if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") throw new ItdConfigError("retry.shouldRetry должен быть функцией");
+	const baseDelay = requirePositive(options.baseDelay ?? 500, "retry.baseDelay");
+	const maxDelay = requirePositive(options.maxDelay ?? 3e4, "retry.maxDelay");
+	if (attempts === 1) return void 0;
+	return {
+		attempts,
+		baseDelay,
+		maxDelay,
+		jitter,
+		shouldRetry: options.shouldRetry
+	};
+}
+/**
+* Сверяет имя бакета со встроенной картой.
+*
+* Своё правило выбора заводит собственное пространство имён, и встроенные имена в нём
+* необязательны — тогда проверка снимается.
+*
+* @param option путь опции для текста ошибки
+* @throws {ItdConfigError} если имени нет во встроенной карте
+*
+* @internal
+*/
+function assertKnownBucket(name, option, bucket, catalog) {
+	if (bucket !== void 0 || catalog.isKnownBucket(name)) return;
+	throw new ItdConfigError(`${option}: бакета «${name}» нет. Известны: ${Object.keys(catalog.bucketLimits).join(", ")}`);
+}
+function requireConcurrency(value, name) {
+	if (!Number.isInteger(value) || value < 1) throw new ItdConfigError(`${name} должен быть целым числом от 1, получено: ${value}`);
+	return value;
+}
+function resolvePacing(pacing) {
+	const known = Object.values(RateLimitPacing);
+	if (pacing !== void 0 && !known.includes(pacing)) throw new ItdConfigError(`rateLimit.pacing должен быть одним из ${known.join(", ")}, получено: ${pacing}`);
+	return pacing ?? RateLimitPacing.React;
+}
+/**
+* Проверяет поправки бакетов и накладывает их на встроенные.
+*
+* Имена сверяются со встроенной картой, пока не задано своё правило выбора бакета.
+* Поля сливаются по отдельности: своя ёмкость `files.upload` не снимает встроенный
+* предел одновременности.
+*/
+function resolveBucketOverrides(overrides, bucket, catalog) {
+	const builtIn = catalog.bucketOverrides;
+	if (overrides === void 0) return builtIn;
+	if (!isRecord$1(overrides)) throw new ItdConfigError("rateLimit.bucketOverrides должен быть объектом");
+	const resolved = { ...builtIn };
+	for (const [name, override] of Object.entries(overrides)) {
+		if (!isRecord$1(override)) throw new ItdConfigError(`rateLimit.bucketOverrides.${name} должен быть объектом`);
+		assertKnownBucket(name, "rateLimit.bucketOverrides", bucket, catalog);
+		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 ItdConfigError(`rateLimit.bucketOverrides.${name}.limit должен быть положительным числом, получено: ${override.limit}`);
+		const built = builtIn[name];
+		resolved[name] = Object.freeze({
+			concurrency: override.concurrency ?? built?.concurrency,
+			limit: override.limit ?? built?.limit
+		});
+	}
+	return Object.freeze(resolved);
+}
+/**
+* Приводит настройки очереди к полному виду. `undefined` — очередь не нужна.
+*
+* Кроме создания клиента вызывается ещё из {@link ItdAccounts}: общая на всех аккаунтов
+* очередь заводится из тех же опций и с теми же проверками.
+*
+* @throws {ItdConfigError} при некорректных значениях
+*
+* @internal
+*/
+function resolveRateLimit(rateLimit, catalog) {
+	if (rateLimit === false) return void 0;
+	if (rateLimit !== void 0 && !isRecord$1(rateLimit)) throw new ItdConfigError("rateLimit должен быть объектом или false");
+	const defaults = {
+		concurrency: 6,
+		rps: void 0,
+		retryDelays: DEFAULT_RATE_LIMIT_DELAYS,
+		buckets: true,
+		pacing: RateLimitPacing.React,
+		bucketConcurrency: 6,
+		bucketOverrides: catalog.bucketOverrides,
+		bucket: void 0,
+		bucketLimits: catalog.bucketLimits,
+		defaultBucket: catalog.defaultBucket
+	};
+	if (!rateLimit) return defaults;
+	const concurrency = requireConcurrency(rateLimit.concurrency ?? 6, "rateLimit.concurrency");
+	if (rateLimit.rps !== void 0 && (!Number.isFinite(rateLimit.rps) || rateLimit.rps <= 0)) throw new ItdConfigError(`rateLimit.rps должен быть положительным числом, получено: ${rateLimit.rps}`);
+	const retryDelays = rateLimit.retryDelays ?? defaults.retryDelays;
+	if (!Array.isArray(retryDelays)) throw new ItdConfigError("rateLimit.retryDelays должен быть массивом чисел");
+	for (const delay of retryDelays) requirePositive(delay, "rateLimit.retryDelays");
+	requireOptionalBoolean(rateLimit.buckets, "rateLimit.buckets");
+	if (rateLimit.bucket !== void 0 && typeof rateLimit.bucket !== "function") throw new ItdConfigError("rateLimit.bucket должен быть функцией");
+	return {
+		concurrency,
+		rps: rateLimit.rps,
+		retryDelays: [...retryDelays],
+		buckets: rateLimit.buckets ?? true,
+		pacing: resolvePacing(rateLimit.pacing),
+		bucketConcurrency: requireConcurrency(rateLimit.bucketConcurrency ?? concurrency, "rateLimit.bucketConcurrency"),
+		bucketOverrides: resolveBucketOverrides(rateLimit.bucketOverrides, rateLimit.bucket, catalog),
+		bucket: rateLimit.bucket,
+		bucketLimits: catalog.bucketLimits,
+		defaultBucket: catalog.defaultBucket
+	};
+}
+/**
+* Разворачивает запись сервисов из опций в определения: имя берётся из ключа, строка
+* означает один только базовый URL. URL проверяется при регистрации сервиса.
+*/
+function resolveServices(services) {
+	if (services === void 0) return [];
+	if (!isRecord$1(services)) throw new ItdConfigError("services должен быть объектом");
+	return Object.entries(services).map(([name, value]) => {
+		if (typeof value === "string") return {
+			name,
+			baseUrl: value
+		};
+		if (!isRecord$1(value)) throw new ItdConfigError(`services.${name} должен быть URL или объектом сервиса`);
+		return {
+			...value,
+			name
+		};
+	});
+}
+/**
+* Приводит настройки исполнения запросов к полному виду.
+*
+* Все проверки выполняются здесь, до единого сетевого запроса: неверная настройка должна
+* проявляться при создании клиента, а не через полчаса работы бота. Сессионные опции
+* разбирает `resolveSessionConfig` — ядру они не нужны.
+*
+* @throws {ItdConfigError} при некорректных значениях
+*/
+function resolveRuntimeConfig(options, catalog) {
+	if (!isRecord$1(options)) throw new ItdConfigError("опции клиента должны быть объектом");
+	const mode = options.mode ?? RuntimeMode.Auto;
+	if (!Object.values(RuntimeMode).includes(mode)) throw new 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 ItdConfigError("clock должен предоставлять методы now() и schedule()");
+	if (options.userAgent !== void 0 && options.userAgent !== false && typeof options.userAgent !== "string") throw new ItdConfigError("userAgent должен быть строкой или false");
+	return {
+		baseUrl: normalizeBaseUrl(options.baseUrl ?? "https://xn--d1ah4a.com"),
+		services: resolveServices(options.services),
+		fetch: resolveFetch(options.fetch),
+		clock: options.clock ?? systemClock,
+		timeout,
+		shutdownTimeout,
+		retry: resolveRetry(options.retry),
+		rateLimit: resolveRateLimit(options.rateLimit, catalog),
+		hooks: resolveHooks(options.hooks),
+		headers: resolveHeaders(options.headers),
+		userAgent: options.userAgent === false ? void 0 : options.userAgent ?? DEFAULT_USER_AGENT,
+		mode,
+		useCookieJar: shouldUseCookieJar(mode),
+		sendCredentials: shouldSendCredentials(mode),
+		logger: resolveLogger(options.logger)
+	};
+}
+//#endregion
+//#region src/core/plugins/attempts.ts
+const ATTEMPT_SCOPE = Symbol("itd-api.attempt-interceptors");
+/** Структурная проверка сохраняет совместимость с fetch-polyfill из другого realm. */
+function isResponse(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.status === "number" && typeof candidate.clone === "function" && typeof candidate.headers?.get === "function";
+}
+/** Привязывает к логической операции неизменяемый снимок attempt interceptors. @internal */
+function withAttemptInterceptorScope(request, interceptors) {
+	return request[ATTEMPT_SCOPE] === interceptors ? request : {
+		...request,
+		[ATTEMPT_SCOPE]: interceptors
+	};
+}
+/** Читает снимок attempt interceptors логической операции. @internal */
+function attemptInterceptorScope(request) {
+	return request[ATTEMPT_SCOPE] ?? [];
+}
+/**
+* Выполняет обёртки одной попытки.
+*
+* Каждый `next` одноразовый: interceptor может short-circuit попытку синтетическим
+* `Response`, но не может незаметно породить два сетевых запроса внутри одного attempt.
+*/
+async function runAttemptInterceptors(request, context, execute) {
+	return attemptInterceptorScope(request).reduceRight((next, { plugin, interceptor }) => async () => {
+		let called = false;
+		const response = await interceptor(context, () => {
+			if (called) throw new ItdConfigError(`attempt interceptor плагина «${plugin}» вызвал next() больше одного раза`);
+			called = true;
+			return next();
+		});
+		if (!isResponse(response)) throw new ItdConfigError(`attempt interceptor плагина «${plugin}» должен вернуть Response`);
+		return response;
+	}, execute)();
+}
+//#endregion
+//#region src/core/plugins/order.ts
+const RELATION_FIELDS = [
+	"requires",
+	"conflicts",
+	"before",
+	"after"
+];
+function validateNameList(plugin, field) {
+	const values = plugin[field];
+	if (values === void 0) return;
+	if (!Array.isArray(values)) throw new ItdConfigError(`плагин «${plugin.name}»: ${field} должен быть массивом`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (typeof value !== "string" || value.trim() === "") throw new ItdConfigError(`плагин «${plugin.name}»: ${field} содержит пустое имя плагина`);
+		if (value === plugin.name) throw new ItdConfigError(`плагин «${plugin.name}» не может указать себя в ${field}`);
+		if (seen.has(value)) throw new ItdConfigError(`плагин «${plugin.name}»: ${field} повторяет имя «${value}»`);
+		seen.add(value);
+	}
+}
+/**
+* Проверяет описание плагина без его установки.
+*
+* Нужна не только {@link PluginRegistry}: контейнер аккаунтов обязан отклонять сломанный
+* плагин сразу, даже когда внутри ещё нет ни одного клиента, которому можно поручить
+* полноценную установку.
+*
+* @internal
+*/
+function validatePluginDefinition(plugin) {
+	if (typeof plugin?.install !== "function") throw new ItdConfigError("Плагин должен быть объектом с методом install()");
+	const name = plugin.name;
+	if (typeof name !== "string" || name.trim() === "") throw new ItdConfigError("У плагина должно быть непустое имя");
+	for (const field of RELATION_FIELDS) validateNameList(plugin, field);
+}
+function addEdge(from, to, edges, indegree) {
+	const targets = edges.get(from);
+	if (!targets || targets.has(to)) return;
+	targets.add(to);
+	indegree.set(to, (indegree.get(to) ?? 0) + 1);
+}
+/**
+* Проверяет зависимости и возвращает плагины в порядке обёрток: внешний идёт раньше.
+*
+* @internal
+*/
+function orderPluginDefinitions(plugins) {
+	const entries = [];
+	const byName = /* @__PURE__ */ new Map();
+	for (const [sequence, plugin] of plugins.entries()) {
+		validatePluginDefinition(plugin);
+		if (byName.has(plugin.name)) throw new ItdConfigError(`плагин «${plugin.name}» уже подключён`);
+		const entry = {
+			plugin,
+			sequence
+		};
+		entries.push(entry);
+		byName.set(plugin.name, entry);
+	}
+	for (const { plugin } of entries) {
+		for (const required of plugin.requires ?? []) if (!byName.has(required)) throw new ItdConfigError(`плагину «${plugin.name}» требуется плагин «${required}»`);
+		for (const conflict of plugin.conflicts ?? []) if (byName.has(conflict)) throw new ItdConfigError(`плагин «${plugin.name}» несовместим с плагином «${conflict}»`);
+		for (const { plugin: other } of entries) if (other.conflicts?.includes(plugin.name)) throw new ItdConfigError(`плагин «${plugin.name}» несовместим с плагином «${other.name}»`);
+	}
+	const edges = /* @__PURE__ */ new Map();
+	const indegree = /* @__PURE__ */ new Map();
+	for (const { plugin } of entries) {
+		edges.set(plugin.name, /* @__PURE__ */ new Set());
+		indegree.set(plugin.name, 0);
+	}
+	for (const { plugin } of entries) {
+		for (const required of plugin.requires ?? []) addEdge(required, plugin.name, edges, indegree);
+		for (const target of plugin.before ?? []) if (byName.has(target)) addEdge(plugin.name, target, edges, indegree);
+		for (const target of plugin.after ?? []) if (byName.has(target)) addEdge(target, plugin.name, edges, indegree);
+	}
+	const ready = entries.filter(({ plugin }) => indegree.get(plugin.name) === 0);
+	ready.sort((a, b) => a.sequence - b.sequence);
+	const ordered = [];
+	while (ready.length > 0) {
+		const current = ready.shift();
+		if (!current) break;
+		ordered.push(current.plugin);
+		for (const target of edges.get(current.plugin.name) ?? []) {
+			const next = (indegree.get(target) ?? 0) - 1;
+			indegree.set(target, next);
+			if (next === 0) {
+				const entry = byName.get(target);
+				if (entry) {
+					ready.push(entry);
+					ready.sort((a, b) => a.sequence - b.sequence);
+				}
+			}
+		}
+	}
+	if (ordered.length !== entries.length) {
+		const cycle = entries.filter(({ plugin }) => (indegree.get(plugin.name) ?? 0) > 0).map(({ plugin }) => plugin.name);
+		throw new ItdConfigError(`циклический порядок плагинов: ${cycle.join(" → ")}`);
+	}
+	return ordered;
+}
+/** Проверяет, можно ли удалить плагин без нарушения обязательных зависимостей. @internal */
+function assertPluginRemovable(plugins, name) {
+	const dependent = plugins.find((plugin) => plugin.requires?.includes(name));
+	if (dependent) throw new ItdConfigError(`нельзя отключить плагин «${name}»: от него зависит «${dependent.name}»`);
+}
+//#endregion
+//#region src/core/plugins/registry.ts
+/**
+* Список подключённых плагинов и зарегистрированных ими расширений.
+*
+* {@link run} собирает operation transformers вокруг одной логической операции и прикрепляет
+* к ней неизменяемый снимок attempt interceptors. Transport исполняет этот снимок отдельно
+* для каждой сетевой попытки. Порядок плагинов одинаков для обеих цепочек.
+*
+* @internal
+*/
+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;
+	}
+	/** Имена плагинов в фактическом порядке выполнения. */
+	names() {
+		return this.#ordered.map(({ plugin }) => plugin.name);
+	}
+	/** Подключён ли плагин с таким именем. */
+	has(name) {
+		return this.#entries.has(name);
+	}
+	/** Проверяет добавление без вызова `install()`. @internal */
+	assertCanAdd(plugin) {
+		validatePluginDefinition(plugin);
+		if (this.#removing.has(plugin.name)) throw new ItdConfigError(`плагин «${plugin.name}» ещё отключается; дождитесь завершения unuse() или dispose()`);
+		orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
+	}
+	/** Проверяет удаление без изменения реестра. @internal */
+	assertCanRemove(name) {
+		if (!this.#entries.get(name)) return;
+		assertPluginRemovable(this.#ordered.map((current) => current.plugin), name);
+	}
+	/**
+	* Подключает плагин.
+	*
+	* `install()` выполняется синхронно. Каждая регистрация принадлежит установившему её
+	* плагину и участвует в общем порядке `before`/`after`.
+	*
+	* @throws {ItdConfigError} если плагин задан неверно, уже подключён или нарушает зависимости
+	*/
+	add(plugin, context) {
+		this.assertCanAdd(plugin);
+		const ordered = orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
+		const transformers = [];
+		const interceptors = [];
+		const register = (values, value, kind) => {
+			if (typeof value !== "function") throw new ItdConfigError(`плагин «${plugin.name}» передал в ${kind}.use() не функцию`);
+			values.push(value);
+			let active = true;
+			return () => {
+				if (!active) return;
+				active = false;
+				const index = values.indexOf(value);
+				if (index >= 0) values.splice(index, 1);
+			};
+		};
+		const installed = plugin.install({
+			...context,
+			operations: { use: (transformer) => register(transformers, transformer, "operations") },
+			attempts: { use: (interceptor) => register(interceptors, interceptor, "attempts") }
+		});
+		if (installed !== void 0 && typeof installed !== "function") throw new ItdConfigError(`install() плагина «${plugin.name}» должен вернуть функцию или void`);
+		const teardown = installed;
+		this.#entries.set(plugin.name, {
+			plugin,
+			transformers,
+			interceptors,
+			teardown,
+			activeRequests: 0,
+			drain: void 0,
+			finishDrain: void 0
+		});
+		this.#ordered = ordered.map((definition) => {
+			const entry = this.#entries.get(definition.name);
+			if (!entry) throw new ItdConfigError(`плагин «${definition.name}» не установлен`);
+			return entry;
+		});
+	}
+	/**
+	* Отключает плагин и вызывает его функцию очистки.
+	*
+	* Новые запросы перестают видеть расширения плагина сразу. Снимок уже начавшейся операции,
+	* включая её будущие retry, остаётся неизменным; очистка дождётся завершения операции,
+	* но не дольше отведённого срока.
+	*
+	* @returns `false`, если такого плагина не было
+	* @throws {ItdStateError} если операции плагина не завершились за отведённый срок
+	*/
+	async remove(name) {
+		const entry = this.#entries.get(name);
+		if (!entry) return false;
+		this.assertCanRemove(name);
+		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 () => {
+			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();
+		const previousCleanups = [...this.#cleanups];
+		this.#entries.clear();
+		this.#ordered = [];
+		for (const { plugin } of entries) this.#removing.add(plugin.name);
+		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 {
+				const expired = await this.#release(entry, deadline);
+				if (expired) errors.push(expired);
+			} catch (error) {
+				errors.push(error);
+			} finally {
+				this.#removing.delete(entry.plugin.name);
+			}
+			if (errors.length > 0) throw new AggregateError(errors, "Не удалось освободить ресурсы плагинов");
+		})());
+		try {
+			await cleanup;
+		} finally {
+			deadline.cancel();
+		}
+	}
+	/**
+	* Прогоняет запрос через operation transformers и прикрепляет attempt interceptors.
+	*
+	* Снимки обеих цепочек берутся в начале: `unuse()` влияет на новые операции, но не меняет
+	* уже выполняющуюся и не удаляет interceptors из её последующих retry.
+	*
+	* Каждый `next` одноразовый: transformer может завершить операцию сам, но не может породить
+	* вторую — для `posts.create` это была бы вторая публикация.
+	*
+	* @param execute выполнение логической операции, вызываемое самым внутренним transformer
+	*/
+	async run(request, execute) {
+		const entries = [...this.#ordered];
+		for (const entry of entries) entry.activeRequests += 1;
+		const interceptorScope = entries.flatMap((entry) => entry.interceptors.map((interceptor) => ({
+			plugin: entry.plugin.name,
+			interceptor
+		})));
+		const scoped = (current) => withAttemptInterceptorScope(current, interceptorScope);
+		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 ItdConfigError(`operation transformer плагина «${plugin}» вызвал next() больше одного раза`);
+				called = true;
+				return next(scoped(prepared));
+			});
+		}, (current) => execute(scoped(current)));
+		try {
+			return await chain(scoped(request));
+		} finally {
+			for (const entry of entries) {
+				entry.activeRequests -= 1;
+				if (entry.activeRequests === 0) {
+					entry.finishDrain?.();
+					entry.finishDrain = void 0;
+					entry.drain = void 0;
+				}
+			}
+		}
+	}
+	/**
+	* Дожидается операций плагина и освобождает его ресурсы.
+	*
+	* `teardown` выполняется в любом случае, в том числе после истечения срока.
+	*
+	* @returns ошибка истёкшего срока, если ждать пришлось дольше отведённого
+	*/
+	async #release(entry, deadline) {
+		const finished = await deadline.wait(this.#waitForDrain(entry));
+		await entry.teardown?.();
+		return finished ? void 0 : new ItdStateError(`плагин «${entry.plugin.name}» не завершил операции за ${this.#options.shutdownTimeout} мс; ожидание прекращено, ресурсы плагина освобождены`);
+	}
+	#waitForDrain(entry) {
+		if (entry.activeRequests === 0) return Promise.resolve();
+		entry.drain ??= new Promise((resolve) => {
+			entry.finishDrain = resolve;
+		});
+		return entry.drain;
+	}
+	#trackCleanup(cleanup) {
+		this.#cleanups.add(cleanup);
+		cleanup.then(() => this.#cleanups.delete(cleanup), () => this.#cleanups.delete(cleanup));
+		return cleanup;
+	}
+};
+//#endregion
+//#region src/core/scheduling/rate-limit.ts
+/** Ошибка отмены запроса, который ещё не дошёл до транспорта. */
+function queueAbortError() {
+	return new ItdAbortError("Запрос отменён во время ожидания очереди");
+}
+/** Ошибка запроса, которого застала остановка очереди. */
+function queueStoppedError() {
+	return new ItdAbortError("Клиент закрыт, запрос отменён");
+}
+/**
+* Очередь запросов: ограничивает одновременность и частоту.
+*
+* Нужна прежде всего ботам: без неё цикл по сотне постов уходит в API одним залпом
+* и упирается в `RATE_LIMIT_EXCEEDED`.
+*
+* Частота выдерживается равномерным разносом стартов (`1000 / rps` между запросами),
+* а не окном со счётчиком: так нагрузка ровная, без всплеска в начале каждой секунды.
+*
+* @internal
+*/
+var RequestQueue = class {
+	#concurrency;
+	/** Минимальный промежуток между стартами, мс. `0` — без ограничения частоты. */
+	#minGap;
+	#onDispatch;
+	#waiting = [];
+	#active = 0;
+	/** Момент, раньше которого следующий запрос стартовать не должен. */
+	#nextSlot = 0;
+	#clock;
+	#cancelTimer;
+	constructor(options, clock = systemClock) {
+		this.#concurrency = options.concurrency;
+		this.#minGap = options.rps ? 1e3 / options.rps : 0;
+		this.#onDispatch = options.onDispatch;
+		this.#clock = clock;
+	}
+	/** Сколько задач выполняется прямо сейчас. */
+	get active() {
+		return this.#active;
+	}
+	/** Сколько задач ждёт очереди. */
+	get pending() {
+		return this.#waiting.length;
+	}
+	/**
+	* Ставит задачу в очередь.
+	*
+	* @returns результат задачи; ошибка задачи пробрасывается без изменений
+	*/
+	schedule(task, signal) {
+		if (signal?.aborted) return Promise.reject(queueAbortError());
+		return new Promise((resolve, reject) => {
+			let queued;
+			const detach = () => signal?.removeEventListener("abort", onAbort);
+			const onAbort = () => {
+				const index = this.#waiting.indexOf(queued);
+				if (index < 0) return;
+				this.#waiting.splice(index, 1);
+				queued.cancel(queueAbortError());
+				this.#drain();
+			};
+			queued = {
+				run: () => {
+					detach();
+					this.#active += 1;
+					this.#onDispatch?.();
+					Promise.resolve().then(task).then(resolve, reject).finally(() => {
+						this.#active -= 1;
+						this.#drain();
+					});
+				},
+				cancel: (reason) => {
+					detach();
+					reject(reason);
+				}
+			};
+			this.#waiting.push(queued);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted) onAbort();
+			else this.#drain();
+		});
+	}
+	/**
+	* Останавливает очередь: снимает отложенную паузу и отклоняет ещё не начатые задачи
+	* ошибкой `ItdAbortError`. Уже выполняющиеся задачи доводятся до конца.
+	*/
+	stop() {
+		if (this.#cancelTimer) {
+			this.#cancelTimer();
+			this.#cancelTimer = void 0;
+		}
+		const pending = this.#waiting.splice(0, this.#waiting.length);
+		for (const task of pending) task.cancel(queueStoppedError());
+	}
+	/** Придерживает очередь на заданное время: ждут все её задачи, а не только одна. */
+	pause(ms) {
+		if (ms <= 0) return;
+		this.#nextSlot = Math.max(this.#nextSlot, this.#clock.now() + ms);
+	}
+	/** Запускает столько ожидающих задач, сколько позволяют ограничения. */
+	#drain() {
+		if (this.#waiting.length === 0) {
+			if (this.#cancelTimer) {
+				this.#cancelTimer();
+				this.#cancelTimer = void 0;
+			}
+			return;
+		}
+		if (this.#active >= this.#concurrency) return;
+		if (this.#cancelTimer) return;
+		const now = this.#clock.now();
+		if (this.#nextSlot > now) {
+			this.#cancelTimer = this.#clock.schedule(() => {
+				this.#cancelTimer = void 0;
+				this.#drain();
+			}, this.#nextSlot - now);
+			return;
+		}
+		const next = this.#waiting.shift();
+		if (!next) return;
+		if (this.#minGap > 0) this.#nextSlot = now + this.#minGap;
+		next.run();
+		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 options.bucketLimits[bucket];
+}
+/**
+* Очереди по парам «направление — серверный счётчик частоты».
+*
+* Направление — origin уже разрешённого URL: разные локальные имена одного хоста делят
+* лимит, а запрос с разовым внешним `baseUrl` не попадает в основную очередь. Мощность
+* карты ограничена каталогом операций, поэтому ни TTL, ни вытеснение не нужны.
+*
+* @internal
+*/
+var RequestQueuePool = class {
+	#options;
+	#clock;
+	/** Ключ `undefined` — основная очередь внутренних клиентов без известного направления. */
+	#destinations = /* @__PURE__ */ new Map();
+	constructor(options, clock = systemClock) {
+		this.#options = options;
+		this.#clock = clock;
+	}
+	/** Очередь бакета на направлении. При `buckets: false` бакет всегда `default`. */
+	for(destination, bucket) {
+		const fallback = this.#options.defaultBucket;
+		const name = this.#options.buckets ? bucket ?? fallback : fallback;
+		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 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() {
+		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
+//#region src/core/services.ts
+/**
+* Накладывает пользовательское определение на встроенное.
+*
+* `auth` и `headers` наследуются от встроенного, пока ключ не задан явно: авторизация
+* относится к сервису, а не к адресу. Явный `undefined` возвращает вывод по хосту.
+*
+* @internal
+*/
+function mergeService(builtIn, override) {
+	const auth = "auth" in override ? override.auth : builtIn.auth;
+	const headers = "headers" in override ? override.headers : builtIn.headers;
+	return {
+		name: builtIn.name,
+		baseUrl: override.baseUrl,
+		...headers === void 0 ? {} : { headers },
+		...auth === void 0 ? {} : { auth }
+	};
+}
+/**
+* Именованные сервисы клиента.
+*
+* @internal
+*/
+var ServiceRegistry = class {
+	#services = /* @__PURE__ */ new Map();
+	/** Хост основного API. */
+	#primaryHost;
+	/** @param primaryBaseUrl базовый URL клиента */
+	constructor(primaryBaseUrl) {
+		this.#primaryHost = primaryBaseUrl ? hostOf(primaryBaseUrl) : "";
+	}
+	/**
+	* Регистрирует сервис. Имя очищается от краевых пробелов, базовый URL приводится
+	* к каноничному виду, а незаданный `auth` выводится из хоста.
+	*
+	* @throws {ItdConfigError} если имя пустое, имя занято или `baseUrl` не абсолютный URL
+	*/
+	define(definition) {
+		const raw = definition?.name;
+		if (typeof raw !== "string" || raw.trim() === "") throw new ItdConfigError("У сервиса должно быть непустое имя");
+		const name = raw.trim();
+		if (this.#services.has(name)) throw new ItdConfigError(`Сервис «${name}» уже зарегистрирован и не может быть заменён`);
+		const baseUrl = normalizeBaseUrl(definition.baseUrl);
+		if (definition.auth !== void 0 && typeof definition.auth !== "boolean") throw new ItdConfigError(`services.${name}.auth должен быть boolean`);
+		let headers;
+		if (definition.headers !== void 0) {
+			if (typeof definition.headers !== "object" || definition.headers === null || Array.isArray(definition.headers)) throw new ItdConfigError(`services.${name}.headers должен быть объектом строк`);
+			for (const [header, value] of Object.entries(definition.headers)) if (typeof value !== "string") throw new ItdConfigError(`services.${name}.headers.${header} должен быть строкой`);
+			headers = Object.freeze({ ...definition.headers });
+		}
+		const normalized = {
+			...definition,
+			name,
+			baseUrl,
+			auth: definition.auth ?? isSameSite(this.#primaryHost, hostOf(baseUrl)),
+			...headers ? { headers } : {}
+		};
+		this.#services.set(name, Object.freeze(normalized));
+	}
+	/** Определение сервиса либо `undefined`, если такого нет. */
+	get(name) {
+		return this.#services.get(name);
+	}
+	/** Зарегистрирован ли сервис с таким именем. */
+	has(name) {
+		return this.#services.has(name);
+	}
+	/**
+	* Определение сервиса.
+	*
+	* @throws {ItdConfigError} если сервис не зарегистрирован
+	*/
+	require(name) {
+		const service = this.#services.get(name);
+		if (!service) {
+			const known = [...this.#services.keys()];
+			throw new ItdConfigError(`Сервис «${name}» не зарегистрирован. ` + (known.length > 0 ? `Известны: ${known.join(", ")}` : "Зарегистрируйте его через itd.defineService() или опцию services"));
+		}
+		return service;
+	}
+	/**
+	* Базовый URL сервиса.
+	*
+	* @throws {ItdConfigError} если сервис не зарегистрирован
+	*/
+	resolveBaseUrl(name) {
+		return this.require(name).baseUrl;
+	}
+	/**
+	* Принадлежит ли URL основному хосту клиента или его поддомену.
+	*
+	* Используется для безопасного значения по умолчанию у разового `baseUrl`: Bearer-токен
+	* не должен уходить на посторонний хост без явного `skipAuth: false`.
+	*
+	* @internal
+	*/
+	isPrimarySite(baseUrl) {
+		return isSameSite(this.#primaryHost, hostOf(baseUrl));
+	}
+};
+//#endregion
+//#region src/core/execution/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) {
+	return request.operationId === void 0 ? {
+		...request,
+		operationId: "raw"
+	} : request;
+}
+/** Привязывает счётчик транспортных попыток к одной логической операции. @internal */
+function trackRequestAttempts(request) {
+	if (request[REQUEST_ATTEMPT_STATE]) return request;
+	return {
+		...request,
+		[REQUEST_ATTEMPT_STATE]: { value: 0 }
+	};
+}
+/** Начинает следующую фактическую транспортную попытку логической операции. @internal */
+function beginTransportAttempt(request) {
+	const tracked = trackRequestAttempts(request);
+	const state = tracked[REQUEST_ATTEMPT_STATE];
+	if (!state) throw new Error("request attempt state was not initialized");
+	state.value += 1;
+	return {
+		...tracked,
+		attempt: state.value
+	};
+}
+/** Возвращает номер последней начатой транспортной попытки. @internal */
+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 {
+		...request,
+		[DISPOSE_CLEANUP_REQUEST]: true
+	};
+}
+/** Разрешено ли запросу завершать внутреннюю очистку после перехода клиента в terminal state. @internal */
+function isDisposeCleanupRequest(request) {
+	return request[DISPOSE_CLEANUP_REQUEST] === true;
+}
+/**
+* Собирает слои в один обработчик.
+*
+* Первый слой оказывается самым внешним. Порядок задаётся внутренним client runtime.
+*
+* @example
+* ```ts
+* const handler = composePipeline(
+*   [plugins, services, retry, authRecovery, authPreparation, queue, attempt, authHeaders],
+*   transport.send,
+* );
+* ```
+*/
+function composePipeline(middlewares, final) {
+	return middlewares.reduceRight((next, middleware) => (request) => middleware(request, next), final);
+}
+/** Добавляет заголовки слоя, не трогая пользовательские. */
+function withLayerHeaders(request, headers) {
+	return {
+		...request,
+		layerHeaders: {
+			...request.layerHeaders,
+			...headers
+		}
+	};
+}
+//#endregion
+//#region src/core/execution/http.ts
+/**
+* Точка входа ресурсов в конвейер запросов.
+*
+* Принимает готовый обработчик — цепочку слоёв поверх транспорта, собранную
+* во внутреннем runtime клиента, — и отдаёт ресурсам методы `request`/`operation`.
+* О слоях и их порядке ресурсы не знают.
+*/
+var HttpClient = class {
+	#handler;
+	#baseUrl;
+	#catalog;
+	constructor(deps) {
+		this.#handler = deps.handler;
+		this.#baseUrl = deps.baseUrl;
+		this.#catalog = deps.catalog;
+	}
+	/** Метод операции из каталога. Отсутствие описания — ошибка сборки клиента, не запроса. */
+	#methodOf(operationId) {
+		const method = this.#catalog.methodOf(operationId);
+		if (method === void 0) throw new ItdConfigError(`каталог операций не знает «${operationId}»`);
+		return method;
+	}
+	/** Базовый URL, к которому обращается клиент. */
+	get baseUrl() {
+		return this.#baseUrl;
+	}
+	/**
+	* Выполняет запрос к API через собранный конвейер.
+	*
+	* @typeParam T ожидаемая форма ответа после снятия обёртки `{ data: … }`
+	* @throws {ItdApiError} если сервер ответил статусом ≥ 400
+	* @throws {ItdTimeoutError} если истёк таймаут
+	* @throws {ItdAbortError} если запрос отменён через `signal`
+	* @throws {ItdNetworkError} если запрос не дошёл до сервера
+	*/
+	request(options) {
+		return this.#handler(identifyRequest(options));
+	}
+	/** Выполняет встроенную семантическую операцию, подставляя её HTTP-метод из каталога. */
+	operation(operationId, options) {
+		return this.request({
+			...options,
+			operationId,
+			method: this.#methodOf(operationId)
+		});
+	}
+	/** Выполняет внутреннюю операцию финализации после начала `ItdClient.dispose()`. @internal */
+	cleanupOperation(operationId, options) {
+		return this.request(markDisposeCleanupRequest({
+			...options,
+			operationId,
+			method: this.#methodOf(operationId)
+		}));
+	}
+};
+//#endregion
+//#region src/core/plugins/hooks.ts
+/** Проверяет наличие публичного hook, не создавая дорогой контекст. @internal */
+function hasRequestHook(hooks, field) {
+	return hooks[field] !== void 0;
+}
+/** Последовательно вызывает публичный hook конструктора. @internal */
+async function dispatchRequestHook(hooks, field, context) {
+	const hook = hooks[field];
+	await hook?.(context);
+}
+//#endregion
+//#region src/core/operation.ts
+/** Семантическая безопасность автоматического повтора операции. */
+const RetrySafety = Object.freeze({
+	/** Автоматический повтор не создаёт неприемлемого эффекта; обычно это чтение. */
+	Safe: "safe",
+	/** Повтор операции приводит к тому же состоянию, что и один вызов. */
+	Idempotent: "idempotent",
+	/** Повтор может создать ещё один побочный эффект. */
+	Unsafe: "unsafe"
+});
+//#endregion
+//#region src/core/scheduling/retry.ts
+/** Методы raw-запроса, безопасность которых гарантирована самим HTTP-контрактом. */
+const SAFE_RAW_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+/** Может ли транспорт заново получить эквивалентное тело запроса. */
+function isRequestBodyReplayable(request) {
+	if (request.bodyFactory !== void 0) return true;
+	return !(typeof ReadableStream !== "undefined" && request.body instanceof ReadableStream);
+}
+/** Разрешает retrySafety запроса из явного override, каталога либо raw fallback. */
+function resolveRetryPolicy(request, catalog) {
+	let retrySafety;
+	const known = catalog.retrySafetyOf(request.operationId);
+	if (request.retrySafety !== void 0) retrySafety = request.retrySafety;
+	else if (known !== void 0) retrySafety = known;
+	else if (request.operationId === "raw" && SAFE_RAW_METHODS.has(request.method.toUpperCase())) retrySafety = RetrySafety.Safe;
+	else retrySafety = RetrySafety.Unsafe;
+	return {
+		operationId: request.operationId,
+		retrySafety,
+		bodyReplayable: isRequestBodyReplayable(request),
+		method: request.method.toUpperCase(),
+		path: request.path
+	};
+}
+/**
+* Стоит ли повторять запрос после этой ошибки.
+*
+* `429` гарантирует, что операция не была обработана, поэтому допускает даже unsafe retry.
+* Обрыв сети, timeout и `5xx` такой гарантии не дают и требуют safe/idempotent операции.
+* Ошибка подготовки файла возникает до обращения к серверу и потому зависит только от
+* собственного признака retryable и повторяемости тела.
+*/
+function isRetryable(error, policy) {
+	if (error instanceof ItdAbortError || !policy.bodyReplayable) return false;
+	const repeatableOperation = policy.retrySafety === RetrySafety.Safe || policy.retrySafety === RetrySafety.Idempotent;
+	if (error instanceof ItdApiError) {
+		if (error.status === 429) return true;
+		if (error.status >= 500) return repeatableOperation;
+		return false;
+	}
+	if (error instanceof ItdNetworkError || error instanceof ItdTimeoutError) return repeatableOperation;
+	if (error instanceof ItdFileError) return error.retryable;
+	return false;
+}
+/** Экспоненциальная пауза со случайным разбросом. */
+function backoffDelay(retryAttempt, options, random) {
+	const exponential = options.baseDelay * 2 ** (retryAttempt - 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`, повтор не выполняется — вызывающий код получает ошибку.
+* Rate-limit ladder основного pipeline ведёт отдельный счётчик и обрабатывается middleware.
+*/
+function createRetryScheduler(options, random = Math.random) {
+	return (error, retryAttempt, policy) => {
+		if (retryAttempt >= options.attempts) return void 0;
+		if (error instanceof ItdAbortError || !policy.bodyReplayable) return void 0;
+		if (options.shouldRetry) return options.shouldRetry(error, retryAttempt, policy) ? backoffDelay(retryAttempt, options, random) : void 0;
+		if (!isRetryable(error, policy)) return void 0;
+		if (error instanceof ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
+		return backoffDelay(retryAttempt, options, random);
+	};
+}
+//#endregion
+//#region src/core/execution/middleware.ts
+/** Ожидание повтора, которое уважает отмену запроса. */
+function sleep(clock, ms, signal) {
+	if (!signal) return new Promise((resolve) => clock.schedule(resolve, ms));
+	if (signal.aborted) return Promise.reject(new ItdAbortError("Запрос отменён во время ожидания повтора"));
+	return new Promise((resolve, reject) => {
+		const cancel = clock.schedule(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			cancel();
+			reject(new ItdAbortError("Запрос отменён во время ожидания повтора"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Слой очереди: ограничение конкурентности и частоты.
+*
+* Должен стоять непосредственно вокруг одной транспортной попытки: тогда ожидание retry
+* не занимает слот, а каждый реальный HTTP-вызов заново учитывается ограничителем частоты.
+*
+* `skipQueue` оставляет продвинутому вызывающему явный способ обойти планировщик.
+*/
+function createQueueMiddleware(schedule) {
+	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
+}
+/**
+* Слой плагинов.
+*
+* Стоит снаружи повторов и очереди: operation transformers видят запрос и ответ по одному
+* разу, иначе, например, текст поста зашифруется дважды. Здесь же к операции привязывается
+* snapshot attempt interceptors; сами они выполняются транспортом на каждой попытке.
+*/
+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);
+	};
+}
+/**
+* Подготавливает auth state до входа транспортной попытки в очередь.
+*
+* Загрузка storage, внешний `getToken` и ленивый sign-in могут быть асинхронными; sign-in
+* сам входит в ту же queue. Поэтому эти действия обязаны завершиться до захвата её слота.
+*/
+function createAuthPreparationMiddleware(auth) {
+	return async (request, next) => {
+		if (!request.skipAuth) await auth.prepare();
+		return next(request);
+	};
+}
+/**
+* Добавляет уже подготовленные заголовки непосредственно перед transport.
+*
+* Слой стоит внутри queue, поэтому источник заголовков обязан быть синхронным и не
+* запускать I/O — это выражено типом {@link AuthProvider.currentHeaders}. Если token
+* изменился, пока запрос ждал slot, будет использовано новое значение.
+*/
+function createAuthHeadersMiddleware(auth) {
+	return (request, next) => {
+		if (request.skipAuth) return next(request);
+		const headers = auth.currentHeaders();
+		return next(Object.keys(headers).length > 0 ? withLayerHeaders(request, headers) : request);
+	};
+}
+/**
+* Нумерует фактические входы в transport для одной логической операции.
+*
+* Слой находится внутри auth recovery: повтор исходного запроса после успешного refresh
+* получает следующий номер, а сам `auth.refresh` ведёт собственный счётчик.
+*/
+function createAttemptMiddleware() {
+	return (request, next) => next(beginTransportAttempt(request));
+}
+/**
+* Обрабатывает `401`: обновляет токен и повторяет транспортную попытку ровно один раз.
+*
+* Стоит снаружи подготовки auth и очереди, поэтому не удерживает её slot во время refresh.
+* Его `next` включает все эти слои: повтор заново готовит auth state и планируется.
+*/
+function createAuthRecoveryMiddleware(auth) {
+	return async (request, next) => {
+		try {
+			return await next(request);
+		} catch (error) {
+			if (request.skipAuthRefresh || !isItdApiError(error) || error.status !== 401) throw error;
+			if (!await auth.recover()) throw error;
+			return next({
+				...request,
+				skipAuthRefresh: true
+			});
+		}
+	};
+}
+/**
+* Выбирает планировщик отката для конкретного запроса.
+*
+* `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, retryAttempt, rateLimitAttempt, request, policy, backoff) => {
+		if (isItdRateLimitError(error)) {
+			if (!policy.bodyReplayable) return void 0;
+			const wait = error.retryAfter ?? deps.rateLimitDelays[rateLimitAttempt - 1];
+			if (wait === void 0) return void 0;
+			deps.pauseQueue?.(wait, request);
+			deps.logger?.debug(`лимит частоты, повтор ${rateLimitAttempt} через ${wait} мс`);
+			return wait;
+		}
+		return backoff?.(error, retryAttempt, policy);
+	};
+	return async (request, next) => {
+		const trackedRequest = trackRequestAttempts(request);
+		const method = request.method.toUpperCase();
+		const policy = resolveRetryPolicy(request, deps.catalog);
+		const backoff = resolveBackoff(request.retry, globalScheduler);
+		let retryAttempt = 0;
+		let rateLimitAttempt = 0;
+		for (;;) try {
+			return await next(trackedRequest);
+		} catch (error) {
+			const transportAttempt = currentTransportAttempt(trackedRequest);
+			if (isItdRateLimitError(error)) rateLimitAttempt += 1;
+			else retryAttempt += 1;
+			const delay = nextDelay(error, retryAttempt, rateLimitAttempt, trackedRequest, policy, backoff);
+			if (delay === void 0) throw error;
+			await dispatchRequestHook(deps.hooks, "onRetry", {
+				operationId: request.operationId,
+				method,
+				path: request.path,
+				url: deps.buildUrl(request),
+				headers: new Headers({
+					...request.layerHeaders,
+					...request.headers
+				}),
+				attempt: transportAttempt,
+				error,
+				delay
+			});
+			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${transportAttempt + 1} через ${delay} мс`);
+			await sleep(deps.clock ?? systemClock, delay, request.signal);
+		}
+	};
+}
+//#endregion
+//#region src/core/redact.ts
+/** Заголовки, значение которых нельзя писать в лог целиком. */
+const SECRET_HEADERS = /* @__PURE__ */ new Set([
+	"authorization",
+	"cookie",
+	"set-cookie",
+	"x-api-key"
+]);
+/** Поля тела запроса, значение которых нельзя писать в лог. */
+const SECRET_FIELDS = /* @__PURE__ */ new Set([
+	"password",
+	"oldpassword",
+	"newpassword",
+	"accesstoken",
+	"refreshtoken",
+	"currentpassword",
+	"flowtoken",
+	"token",
+	"turnstiletoken",
+	"otp"
+]);
+/** Query-параметры, содержащие секреты. */
+const SECRET_QUERY_PARAMS = /* @__PURE__ */ new Set(["token", "access_token"]);
+/**
+* Прячет середину секрета, оставляя концы для сопоставления.
+*
+* @example
+* ```ts
+* maskSecret('eyJhbGciOiJIUzI1NiJ9.abc'); // 'eyJh…(24)…abc'
+* ```
+*/
+function maskSecret(value) {
+	if (value.length <= 8) return "…";
+	return `${value.slice(0, 4)}…(${value.length})…${value.slice(-3)}`;
+}
+/** Маскирует секретные query-параметры URL перед записью в логи и ошибки. */
+function redactUrl(url) {
+	try {
+		const parsed = new URL(url);
+		const entries = [...parsed.searchParams.entries()];
+		parsed.search = "";
+		for (const [name, value] of entries) parsed.searchParams.append(name, SECRET_QUERY_PARAMS.has(name.toLowerCase()) ? maskSecret(value) : value);
+		return parsed.toString();
+	} catch {
+		return url.replace(/([?&](?:token|access_token)=)[^&#]*/gi, "$1[скрыто]");
+	}
+}
+/**
+* Готовит заголовки к записи в лог.
+*
+* `Authorization` и `Cookie` маскируются: логи часто уезжают в системы сбора,
+* и токен доступа в них попадать не должен.
+*/
+function redactHeaders(headers) {
+	const result = {};
+	headers.forEach((value, name) => {
+		if (SECRET_HEADERS.has(name.toLowerCase())) {
+			const spaceAt = value.indexOf(" ");
+			result[name] = spaceAt > 0 ? `${value.slice(0, spaceAt)} ${maskSecret(value.slice(spaceAt + 1))}` : maskSecret(value);
+			return;
+		}
+		result[name] = value;
+	});
+	return result;
+}
+/**
+* Готовит тело запроса к записи в лог: пароли, токены и коды OTP заменяются заглушкой.
+*
+* Обходит вложенные объекты и массивы. `FormData` и бинарные тела не раскрываются вовсе.
+*/
+function redactBody(body) {
+	if (body === null || body === void 0) return body;
+	if (typeof FormData !== "undefined" && body instanceof FormData) return "[FormData]";
+	if (isBlob(body)) return "[Blob]";
+	if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return "[binary]";
+	if (Array.isArray(body)) return body.map(redactBody);
+	if (typeof body === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(body)) result[key] = SECRET_FIELDS.has(key.toLowerCase()) ? "[скрыто]" : redactBody(value);
+		return result;
+	}
+	return body;
+}
+//#endregion
+//#region src/core/unwrap.ts
+/**
+* Снимает внешнюю обёртку `{ data: … }`.
+*
+* Это единственное преобразование ответа, которое делает транспортный слой. Формы ответов у
+* итд.com непоследовательны: одни эндпоинты заворачивают полезную нагрузку в `data`, другие
+* отдают её напрямую (`GET /api/notifications/` → `{ notifications, hasMore }`), третьи кладут
+* список в поле по имени сущности. Угадывать имя поля опасно, поэтому его разбирает каждый
+* метод ресурса явно, а здесь снимается только однозначная обёртка.
+*
+* Обёртка считается обёрткой, лишь когда `data` — **единственный** ключ объекта. Ответ
+* `{ data: …, meta: … }` вернётся как есть.
+*
+* @example
+* ```ts
+* unwrapData({ data: { posts: [] } });        // { posts: [] }
+* unwrapData({ notifications: [], hasMore }); // без изменений
+* unwrapData({ data: [], hasMore: true });    // без изменений — ключей больше одного
+* ```
+*/
+function unwrapData(body) {
+	if (typeof body !== "object" || body === null || Array.isArray(body)) return body;
+	const keys = Object.keys(body);
+	if (keys.length !== 1 || keys[0] !== "data") return body;
+	return body.data;
+}
+/**
+* Обычный объект — не `null`, не массив.
+*
+* Живёт здесь, а не в каждом разборщике ответа: одна и та же проверка нужна и фабрике
+* ошибок, и приведению уведомлений.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Непустая строка либо `undefined`. Отличается от {@link pickString} тем, что берёт значение, а не поле. */
+function asString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* Достаёт поле-список из ответа, уже прошедшего {@link unwrapData}.
+*
+* Если поля нет или оно не массив, возвращается пустой массив: сервер иногда опускает
+* пустые коллекции, и падать из-за этого библиотека не должна.
+*/
+function pickArray(source, field) {
+	if (typeof source !== "object" || source === null) return [];
+	const value = source[field];
+	return Array.isArray(value) ? value : [];
+}
+/** Достаёт объект по имени поля. Возвращает `undefined`, если это не объект. */
+function pickObject(source, field) {
+	if (typeof source !== "object" || source === null) return void 0;
+	const value = source[field];
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	return value;
+}
+/** Достаёт булево поле. Возвращает `fallback`, если поля нет или тип не тот. */
+function pickBoolean(source, field, fallback = false) {
+	if (typeof source !== "object" || source === null) return fallback;
+	const value = source[field];
+	return typeof value === "boolean" ? value : fallback;
+}
+/** Достаёт числовое поле. Возвращает `fallback`, если поля нет или значение не конечное число. */
+function pickNumber(source, field, fallback) {
+	if (typeof source !== "object" || source === null) return fallback;
+	const value = source[field];
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+/** Достаёт строковое поле. Возвращает `undefined`, если поля нет, оно пустое или не строка. */
+function pickString(source, field) {
+	if (typeof source !== "object" || source === null) return void 0;
+	const value = source[field];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+//#endregion
+//#region src/core/error-factory.ts
+/**
+* Сводит ошибки по полям к единой форме `{ поле: [сообщения] }`.
+*
+* Понимает две документированные формы:
+* - `errors: { email: ['…'] }` либо `errors: { email: '…' }`
+* - `violations: [{ field: 'email', message: '…' }]`
+*/
+function collectFieldErrors(source) {
+	const result = {};
+	const errors = source.errors;
+	if (isRecord(errors)) {
+		for (const [field, value] of Object.entries(errors)) if (Array.isArray(value)) {
+			const messages = value.filter((item) => typeof item === "string");
+			if (messages.length > 0) result[field] = messages;
+		} else if (typeof value === "string") result[field] = [value];
+	}
+	const violations = source.violations;
+	if (Array.isArray(violations)) for (const violation of violations) {
+		if (!isRecord(violation)) continue;
+		const field = asString(violation.field) ?? asString(violation.property);
+		const message = asString(violation.message);
+		if (!field || !message) continue;
+		const existing = result[field];
+		if (existing) existing.push(message);
+		else result[field] = [message];
+	}
+	return result;
+}
+/**
+* Разбирает тело ответа с ошибкой.
+*
+* API отдаёт ошибки в двух формах — с обёрткой `{ error: … }` и без неё, — а при сбое на
+* уровне прокси может вернуть вообще не JSON. Все три случая сводятся к одной структуре.
+*
+* @param body тело ответа: разобранный JSON, строка или `undefined`
+* @param status HTTP-статус, используется для сообщения по умолчанию
+* @param statusText текст статуса из ответа
+*/
+function parseErrorBody(body, status, statusText = "") {
+	const fallbackMessage = statusText ? `HTTP ${status} ${statusText}` : `HTTP ${status}`;
+	if (typeof body === "string") return {
+		code: "UNKNOWN_ERROR",
+		message: asString(body.trim()) ?? fallbackMessage,
+		detail: void 0,
+		title: void 0,
+		fieldErrors: {},
+		userId: void 0
+	};
+	if (!isRecord(body)) return {
+		code: "UNKNOWN_ERROR",
+		message: fallbackMessage,
+		detail: void 0,
+		title: void 0,
+		fieldErrors: {},
+		userId: void 0
+	};
+	if (body.type === "validation") {
+		const target = asString(body.on);
+		return {
+			code: "VALIDATION_ERROR",
+			message: target ? `Проверка не пройдена: некорректные данные в «${target}»` : "Проверка входных данных не пройдена",
+			detail: void 0,
+			title: void 0,
+			fieldErrors: {},
+			userId: void 0
+		};
+	}
+	const inner = isRecord(body.error) ? body.error : body;
+	const message = asString(inner.message) ?? asString(inner.detail) ?? asString(inner.title) ?? asString(body.error) ?? fallbackMessage;
+	return {
+		code: asString(inner.code) ?? asString(body.code) ?? "UNKNOWN_ERROR",
+		message,
+		detail: asString(inner.detail),
+		title: asString(inner.title),
+		fieldErrors: {
+			...collectFieldErrors(body),
+			...collectFieldErrors(inner)
+		},
+		userId: asString(inner.userId) ?? asString(body.userId)
+	};
+}
+/**
+* Переводит заголовок `Retry-After` в миллисекунды.
+*
+* Поддерживает обе формы из спецификации HTTP: число секунд и дату.
+* Возвращает `undefined`, если заголовка нет или он не разбирается.
+*/
+function parseRetryAfter(header, now = Date.now()) {
+	if (!header) return void 0;
+	const seconds = Number(header);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const date = Date.parse(header);
+	if (Number.isFinite(date)) return Math.max(0, date - now);
+}
+/** Читает целое число из заголовка. */
+function readIntHeader(headers, name) {
+	const raw = headers?.get(name);
+	if (raw === null || raw === void 0) return void 0;
+	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;
+}
+/**
+* Читает сведения об ограничении частоты.
+*
+* Сервер сообщает размер окна и остаток, но **не сообщает время сброса** — поэтому
+* точный момент, когда можно повторить, из ответа не вывести.
+*/
+function readRateLimit(headers) {
+	return {
+		limit: readPositiveIntHeader(headers, "x-ratelimit-limit"),
+		remaining: readIntHeader(headers, "x-ratelimit-remaining")
+	};
+}
+const REQUEST_ID_HEADERS = [
+	"x-request-id",
+	"x-requestid",
+	"request-id",
+	"x-correlation-id"
+];
+/** Достаёт идентификатор запроса из заголовков ответа — пригодится при обращении в поддержку. */
+function getRequestId(headers) {
+	if (!headers) return void 0;
+	for (const name of REQUEST_ID_HEADERS) {
+		const value = headers.get(name);
+		if (value) return value;
+	}
+}
+/** Соответствие кода ошибки конкретному классу. Приоритетнее, чем HTTP-статус. */
+const CODE_TO_CLASS = {
+	VALIDATION_ERROR: ItdValidationError,
+	RATE_LIMIT_EXCEEDED: ItdRateLimitError,
+	UNAUTHORIZED: ItdAuthError,
+	SESSION_EXPIRED: ItdAuthError,
+	SESSION_REVOKED: ItdAuthError,
+	SESSION_INVALID_REFRESH_TOKEN: ItdAuthError,
+	REFRESH_TOKEN_MISSING: ItdAuthError,
+	SESSION_NOT_FOUND: ItdAuthError,
+	ACCOUNT_INVALID_CREDENTIALS: ItdAuthError,
+	ACCESS_DENIED: ItdForbiddenError,
+	ENTITY_NOT_FOUND: ItdNotFoundError,
+	NOT_FOUND: ItdNotFoundError,
+	ENTITY_ALREADY_EXISTS: ItdConflictError
+};
+/** Соответствие HTTP-статуса классу — запасной вариант, когда код ничего не говорит. */
+function classByStatus(status) {
+	if (status === 401) return ItdAuthError;
+	if (status === 403) return ItdForbiddenError;
+	if (status === 404) return ItdNotFoundError;
+	if (status === 409) return ItdConflictError;
+	if (status === 422) return ItdValidationError;
+	if (status === 429) return ItdRateLimitError;
+	if (status >= 500) return ItdServerError;
+	return ItdApiError;
+}
+/**
+* Готовит тело ответа к сохранению в `ItdApiError.raw`.
+*
+* При `422` сервер возвращает присланное тело эхом: `{ type: 'validation', on: 'body',
+* found: { email: '…', password: '…' } }`. Ошибка обычно доезжает до логов и систем сбора
+* вроде Sentry — пароль в ней оказаться не должен. Имена полей для диагностики остаются,
+* значения секретов заменяются заглушкой.
+*/
+function safeRawBody(body) {
+	if (!isRecord(body) || body.type !== "validation" || !isRecord(body.found)) return body;
+	return {
+		...body,
+		found: redactBody(body.found)
+	};
+}
+/**
+* Строит типизированную ошибку из ответа сервера.
+*
+* Класс выбирается сначала по коду ошибки, затем по HTTP-статусу — так `VALIDATION_ERROR`
+* со статусом `400` всё равно станет {@link ItdValidationError}.
+*/
+function createApiError(context) {
+	const parsed = parseErrorBody(context.body, context.status, context.statusText);
+	const rateLimit = readRateLimit(context.headers);
+	const init = {
+		rateLimit: rateLimit.limit,
+		rateLimitRemaining: rateLimit.remaining,
+		status: context.status,
+		code: parsed.code,
+		message: parsed.message,
+		detail: parsed.detail,
+		title: parsed.title,
+		fieldErrors: parsed.fieldErrors,
+		requestId: getRequestId(context.headers),
+		method: context.method,
+		path: context.path,
+		raw: safeRawBody(context.body),
+		response: context.response,
+		retryAfter: parseRetryAfter(context.headers?.get("retry-after"), context.now)
+	};
+	if (parsed.code === "PHONE_VERIFICATION_REQUIRED") return new ItdPhoneVerificationError({
+		...init,
+		userId: parsed.userId
+	});
+	return new (CODE_TO_CLASS[parsed.code] ?? (classByStatus(context.status)))(init);
+}
+//#endregion
+//#region src/core/execution/transport.ts
+/** Ставит заголовок, превращая ошибку среды в понятную ошибку конфигурации. */
+function setHeader(headers, name, value) {
+	try {
+		headers.set(name, value);
+	} catch (cause) {
+		throw new ItdConfigError(`Некорректный HTTP-заголовок ${JSON.stringify(name)}: проверьте его имя и значение.`, { cause });
+	}
+}
+/** Тело, которое отправляется как есть, без сериализации в JSON. */
+function isRawBody(body) {
+	if (typeof body !== "object" || body === null) return typeof body === "string";
+	return typeof FormData !== "undefined" && body instanceof FormData || isBlob(body) || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || typeof ReadableStream !== "undefined" && body instanceof ReadableStream || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+/**
+* Читает тело ответа один раз.
+*
+* Ответ можно прочитать только однократно, а тело нужно и при успехе, и при ошибке,
+* поэтому чтение происходит здесь, до ветвления по статусу.
+*/
+async function readBody(response) {
+	if (response.status === 204 || response.status === 205) return void 0;
+	if (response.headers.get("content-length") === "0") return void 0;
+	if ((response.headers.get("content-type") ?? "").includes("json")) {
+		const text = await response.text();
+		if (text === "") return void 0;
+		try {
+			return JSON.parse(text);
+		} catch {
+			return text;
+		}
+	}
+	const text = await response.text();
+	return text === "" ? void 0 : text;
+}
+/** Ошибка отмены в формате `fetch`. */
+function createAbortError() {
+	const error = /* @__PURE__ */ new Error("Операция прервана");
+	error.name = "AbortError";
+	return error;
+}
+/** Прерывает ожидание промиса при срабатывании сигнала. */
+function abortable(promise, signal) {
+	if (signal.aborted) {
+		promise.catch(() => {});
+		return Promise.reject(createAbortError());
+	}
+	let onAbort;
+	const interrupted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(createAbortError());
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	return Promise.race([promise, interrupted]).finally(() => {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	});
+}
+/**
+* Объединяет пользовательский `AbortSignal`, сигнал жизни клиента и таймаут.
+*
+* Реализовано вручную, а не через `AbortSignal.any`: последний появился только в Node 20,
+* а библиотека поддерживает Node 18. Причина отмены переносится от источника как есть.
+*/
+function createAbortBundle(userSignal, lifetimeSignal, timeout, clock) {
+	const controller = new AbortController();
+	let timedOut = false;
+	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();
+	}, timeout) : void 0;
+	return {
+		signal: controller.signal,
+		timedOut: () => timedOut,
+		cleanup: () => {
+			cancelTimer?.();
+			for (const detach of unlink) detach?.();
+		}
+	};
+}
+/**
+* Единственное место, откуда библиотека ходит в сеть.
+*
+* Отвечает за сборку URL, заголовки, cookie, таймауты, разбор ответа и превращение любой
+* неудачи в типизированную ошибку. Авторизация, повторы, очередь и плагины — отдельные
+* слои конвейера, и транспорт о них не знает.
+*/
+var Transport = class {
+	#config;
+	#deps;
+	constructor(config, deps) {
+		this.#config = config;
+		this.#deps = deps;
+	}
+	/** Базовый URL, к которому обращается транспорт. */
+	get baseUrl() {
+		return this.#config.baseUrl;
+	}
+	/**
+	* Выполняет один сетевой запрос.
+	*
+	* @throws {ItdApiError} если сервер ответил статусом ≥ 400
+	* @throws {ItdTimeoutError} если истёк таймаут
+	* @throws {ItdAbortError} если запрос отменён через `signal`
+	* @throws {ItdNetworkError} если запрос не дошёл до сервера
+	*/
+	send = async (input) => {
+		const request = identifyRequest(input);
+		const method = request.method.toUpperCase();
+		const url = this.buildUrl(request);
+		const headers = await this.#buildHeaders(request, url);
+		const attempt = request.attempt ?? 1;
+		const timeout = request.timeout ?? this.#config.timeout;
+		const abort = createAbortBundle(request.signal, this.#deps.lifetimeSignal, timeout, this.#config.clock);
+		const startedAt = this.#config.clock.now();
+		let cleanupBody;
+		try {
+			let body;
+			try {
+				const prepared = await this.#prepareBody(request, headers, abort.signal, attempt);
+				body = prepared.body;
+				cleanupBody = prepared.cleanup;
+			} catch (error) {
+				const failure = this.#toTransportError(error, abort, request, method, timeout);
+				const context = {
+					operationId: request.operationId,
+					method,
+					path: request.path,
+					url,
+					headers,
+					attempt
+				};
+				await dispatchRequestHook(this.#config.hooks, "onError", {
+					...context,
+					duration: this.#config.clock.now() - startedAt,
+					error: failure
+				});
+				throw failure;
+			}
+			const context = {
+				operationId: request.operationId,
+				method,
+				path: request.path,
+				url,
+				headers,
+				attempt
+			};
+			await dispatchRequestHook(this.#config.hooks, "onRequest", context);
+			this.#config.logger?.debug(`→ ${method} ${request.path}`, {
+				headers: redactHeaders(headers),
+				body: request.bodyFactory ? "[повторяемое тело]" : redactBody(request.body)
+			});
+			let response;
+			try {
+				const init = {
+					method,
+					headers,
+					signal: abort.signal,
+					...body !== void 0 ? { body } : {},
+					...this.#config.sendCredentials ? { credentials: "include" } : {}
+				};
+				if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) init.duplex = "half";
+				response = await runAttemptInterceptors(request, {
+					...context,
+					body,
+					signal: abort.signal
+				}, async () => {
+					try {
+						return await this.#config.fetch(url, init);
+					} catch (error) {
+						throw this.#toTransportError(error, abort, request, method, timeout);
+					}
+				});
+			} catch (error) {
+				const duration = this.#config.clock.now() - startedAt;
+				await dispatchRequestHook(this.#config.hooks, "onError", {
+					...context,
+					duration,
+					error
+				});
+				this.#config.logger?.warn(`× ${method} ${request.path} (${duration} мс): ${error instanceof Error ? error.message : String(error)}`);
+				throw error;
+			}
+			if (this.#deps.onRateLimit) {
+				const { limit, remaining } = readRateLimit(response.headers);
+				this.#deps.onRateLimit(limit, remaining, request);
+			}
+			if (this.#config.useCookieJar) this.#deps.cookies?.setFromResponse(url, response);
+			if (response.ok && hasRequestHook(this.#config.hooks, "onResponse")) await dispatchRequestHook(this.#config.hooks, "onResponse", {
+				...context,
+				status: response.status,
+				duration: this.#config.clock.now() - startedAt,
+				response: response.clone()
+			});
+			const payload = await this.#readBodyOrFail(response, context, request, method, abort, timeout);
+			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,
+					body: payload
+				});
+				await dispatchRequestHook(this.#config.hooks, "onError", {
+					...context,
+					duration,
+					error
+				});
+				this.#config.logger?.warn(`← ${response.status} ${method} ${request.path} (${duration} мс): ${error.message}`);
+				throw error;
+			}
+			this.#config.logger?.debug(`← ${response.status} ${method} ${request.path} (${duration} мс)`);
+			return request.raw ? payload : unwrapData(payload);
+		} finally {
+			try {
+				await cleanupBody?.();
+			} catch (error) {
+				this.#config.logger?.warn(`не удалось закрыть тело ${method} ${request.path}`, error);
+			} finally {
+				abort.cleanup();
+			}
+		}
+	};
+	/** Подготавливает тело внутри попытки, чтобы поток можно было открыть заново при retry. */
+	async #prepareBody(request, headers, signal, attempt) {
+		if (request.bodyFactory) {
+			if (request.body !== void 0 && request.body !== null) throw new ItdConfigError("body и bodyFactory нельзя задавать одновременно");
+			const pending = Promise.resolve(request.bodyFactory({
+				signal,
+				attempt
+			}));
+			let prepared;
+			try {
+				prepared = await abortable(pending, signal);
+			} catch (error) {
+				if (signal.aborted) pending.then(async (late) => {
+					try {
+						await late.cleanup?.();
+					} catch (cleanupError) {
+						this.#config.logger?.warn(`не удалось закрыть отложенное тело ${request.method} ${request.path}`, cleanupError);
+					}
+				}).catch(() => {});
+				throw error;
+			}
+			for (const [name, value] of Object.entries(prepared.headers ?? {})) if (!headers.has(name)) setHeader(headers, name, value);
+			return {
+				body: prepared.body,
+				cleanup: prepared.cleanup
+			};
+		}
+		if (request.body === void 0 || request.body === null) return {
+			body: void 0,
+			cleanup: void 0
+		};
+		if (isRawBody(request.body)) return {
+			body: request.body,
+			cleanup: void 0
+		};
+		if (!headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+		return {
+			body: JSON.stringify(request.body),
+			cleanup: void 0
+		};
+	}
+	/** Читает тело и преобразует ошибку чтения в транспортную ошибку библиотеки. */
+	async #readBodyOrFail(response, context, request, method, abort, timeout) {
+		const startedAt = this.#config.clock.now();
+		try {
+			return await abortable(readBody(response), abort.signal);
+		} catch (error) {
+			await response.body?.cancel().catch(() => {});
+			const failure = this.#toTransportError(error, abort, request, method, timeout);
+			await dispatchRequestHook(this.#config.hooks, "onError", {
+				...context,
+				duration: this.#config.clock.now() - startedAt,
+				error: failure
+			});
+			this.#config.logger?.warn(`× ${method} ${request.path}: не удалось прочитать тело ответа — ${failure.message}`);
+			throw failure;
+		}
+	}
+	/**
+	* Итоговый URL со строкой запроса. Нужен и слою повторов — для хука `onRetry`.
+	*
+	* Хост берётся из самого запроса, если он там задан: у сервисов платформы свои домены.
+	*/
+	buildUrl(request) {
+		const base = request.baseUrl ?? this.#config.baseUrl;
+		return joinUrl(base, request.path) + buildQuery(request.query);
+	}
+	/**
+	* Собирает общие заголовки клиента: `User-Agent`, идентификатор устройства,
+	* заголовки конфигурации и cookie для указанного адреса.
+	*/
+	async platformHeaders(url) {
+		const headers = new Headers();
+		headers.set("X-Requested-With", "XMLHttpRequest");
+		if (this.#config.userAgent) setHeader(headers, "User-Agent", this.#config.userAgent);
+		if (this.#deps.getDeviceId) setHeader(headers, "X-Device-Id", await this.#deps.getDeviceId());
+		for (const [name, value] of Object.entries(this.#config.headers)) setHeader(headers, name, value);
+		if (this.#config.useCookieJar && this.#deps.cookies) {
+			const cookie = this.#deps.cookies.getHeader(url);
+			if (cookie) setHeader(headers, "Cookie", cookie);
+		}
+		return headers;
+	}
+	/**
+	* Дополняет общие заголовки значением `Accept`, заголовками конвейера и вызова.
+	* Заголовки вызова применяются последними.
+	*/
+	async #buildHeaders(request, url) {
+		const headers = await this.platformHeaders(url);
+		if (!headers.has("Accept")) headers.set("Accept", "application/json");
+		for (const [name, value] of Object.entries(request.layerHeaders ?? {})) setHeader(headers, name, value);
+		for (const [name, value] of Object.entries(request.headers ?? {})) setHeader(headers, name, value);
+		return headers;
+	}
+	/** Превращает исключение `fetch` в понятную ошибку библиотеки. */
+	#toTransportError(error, abort, request, method, timeout) {
+		const aborted = abort.signal.aborted || error instanceof Error && error.name === "AbortError";
+		if (aborted && abort.timedOut()) return new ItdTimeoutError({
+			timeout,
+			method,
+			path: request.path
+		});
+		if (aborted) {
+			const reason = abort.signal.reason;
+			return new ItdAbortError(`Запрос ${method} ${request.path} отменён`, reason !== void 0 ? { cause: reason } : void 0);
+		}
+		if (error instanceof ItdError) return error;
+		return new ItdNetworkError(`Не удалось выполнить ${method} ${request.path}: ${error instanceof Error ? error.message : String(error)}`, {
+			method,
+			path: request.path,
+			cause: error
+		});
+	}
+};
+//#endregion
+//#region src/core/execution/client-runtime.ts
+/** Имена стадий основного request pipeline в порядке выполнения. @internal */
+const ClientRuntimeStage = Object.freeze({
+	OperationPlugins: "operation_plugins",
+	Services: "services",
+	Retry: "retry",
+	AuthRecovery: "auth_recovery",
+	AuthPreparation: "auth_preparation",
+	Queue: "queue",
+	Attempt: "attempt",
+	AuthHeaders: "auth_headers",
+	Transport: "transport"
+});
+/** Регистрирует встроенные сервисы и накладывает пользовательские overrides. */
+function createServiceRegistry(config) {
+	const services = new ServiceRegistry(config.baseUrl);
+	const overrides = new Map(config.services.map((service) => [service.name.trim(), service]));
+	for (const builtIn of BUILT_IN_SERVICES) {
+		const override = overrides.get(builtIn.name);
+		overrides.delete(builtIn.name);
+		services.define(override ? mergeService(builtIn, override) : builtIn);
+	}
+	for (const service of overrides.values()) services.define(service);
+	return services;
+}
+/** Собирает внутренний runtime клиента и единственный request pipeline. @internal */
+function createClientRuntime(options, internals) {
+	const catalog = internals.catalog;
+	const config = resolveRuntimeConfig(options, catalog);
+	const jar = new CookieJar();
+	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
+		}) ?? catalog.bucketOf(request.operationId);
+	};
+	const queueKeyFor = (request) => requestQueueKey(request, (target) => ({
+		destination: originOf(transport.buildUrl(target)) || void 0,
+		bucket: bucketFor(target)
+	}));
+	const queueFor = (request) => {
+		if (!queues) return void 0;
+		const key = queueKeyFor(request);
+		return queues.for(key.destination, key.bucket);
+	};
+	/** Передаёт остаток из заголовков ответа бакету запроса; тот решает, тормозить ли себя. */
+	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.deviceId(),
+		lifetimeSignal: lifetime.signal
+	});
+	const stages = [
+		{
+			name: ClientRuntimeStage.OperationPlugins,
+			middleware: createPluginsMiddleware(plugins)
+		},
+		{
+			name: ClientRuntimeStage.Services,
+			middleware: createServicesMiddleware(services)
+		},
+		{
+			name: ClientRuntimeStage.Retry,
+			middleware: createRetryMiddleware({
+				clock: config.clock,
+				catalog,
+				retry: config.retry,
+				rateLimitDelays: config.rateLimit?.retryDelays ?? [],
+				pauseQueue: queues ? (ms, request) => queueFor(request)?.pause(ms) : void 0,
+				hooks: config.hooks,
+				logger: config.logger,
+				buildUrl: (request) => transport.buildUrl(request)
+			})
+		},
+		{
+			name: ClientRuntimeStage.AuthRecovery,
+			middleware: createAuthRecoveryMiddleware({ recover: () => auth.recover() })
+		},
+		{
+			name: ClientRuntimeStage.AuthPreparation,
+			middleware: createAuthPreparationMiddleware({ prepare: () => auth.prepare() })
+		}
+	];
+	if (queues) stages.push({
+		name: ClientRuntimeStage.Queue,
+		middleware: createQueueMiddleware((request, task) => {
+			const queue = queueFor(request);
+			return queue ? queue.schedule(task, request.signal) : task();
+		})
+	});
+	stages.push({
+		name: ClientRuntimeStage.Attempt,
+		middleware: createAttemptMiddleware()
+	});
+	stages.push({
+		name: ClientRuntimeStage.AuthHeaders,
+		middleware: createAuthHeadersMiddleware({ currentHeaders: () => auth.currentHeaders() })
+	});
+	const handler = composePipeline(stages.map(({ middleware }) => middleware), transport.send);
+	const clientHandler = (request) => {
+		try {
+			if (!isDisposeCleanupRequest(request)) internals.assertActive?.("выполнить новый запрос");
+			if (request.rateLimitBucket !== void 0) assertKnownBucket(request.rateLimitBucket, "rateLimitBucket", config.rateLimit?.bucket, catalog);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		return handler(request);
+	};
+	auth = internals.auth({
+		config,
+		handler: clientHandler,
+		cookies: jar
+	});
+	const http = new HttpClient({
+		handler: clientHandler,
+		baseUrl: config.baseUrl,
+		catalog
+	});
+	const stageOrder = Object.freeze([...stages.map(({ name }) => name), ClientRuntimeStage.Transport]);
+	return {
+		config,
+		http,
+		auth,
+		cookies: jar,
+		plugins,
+		services,
+		stageOrder,
+		platformHeaders: (url) => transport.platformHeaders(url),
+		rateLimitState: () => queues?.states() ?? [],
+		close: () => {
+			if (ownsQueues) queues?.stop();
+		},
+		dispose: async () => {
+			lifetime.abort(new ItdAbortError("Клиент освобождён через dispose(), запрос отменён"));
+			if (ownsQueues) queues?.clear();
+			auth.dispose();
+			await plugins.dispose();
+		}
+	};
+}
+//#endregion
+//#region src/domain/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 DEFAULT_BUCKET_OVERRIDES = Object.freeze({ "files.upload": Object.freeze({ concurrency: 1 }) });
+//#endregion
+//#region src/domain/operations.ts
+function freezeOperations(operations) {
+	for (const definition of Object.values(operations)) Object.freeze(definition);
+	return Object.freeze(operations);
+}
+/**
+* Каталог встроенных операций.
+*
+* ID описывает смысл вызова и не меняется при переносе HTTP-пути. Method и retrySafety
+* хранятся здесь, чтобы resources, retry и плагины не вели независимые таблицы операций.
+*/
+const OPERATIONS = freezeOperations({
+	"auth.check": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"auth.signUp": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.signIn": {
+		method: "POST",
+		retrySafety: RetrySafety.Safe,
+		bucket: "auth"
+	},
+	"auth.verifyOtp": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.resendOtp": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.refresh": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth.refresh"
+	},
+	"auth.logout": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.forgotPassword": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.resetPassword": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.changePassword": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.sessions": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "auth"
+	},
+	"auth.revokeSession": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"auth.revokeOtherSessions": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "auth"
+	},
+	"users.me": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.updateMe": {
+		method: "PUT",
+		retrySafety: RetrySafety.Idempotent,
+		bucket: "users.updateMe"
+	},
+	"users.deactivate": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"users.restore": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"users.createProfile": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"users.get": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.checkUsername": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.search": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.whoToFollow": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.topClans": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.follow": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "users.follow"
+	},
+	"users.unfollow": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "users.follow"
+	},
+	"users.followers": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.following": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.followStatus": {
+		method: "POST",
+		retrySafety: RetrySafety.Safe
+	},
+	"users.block": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"users.unblock": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"users.blocked": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.getPrivacy": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.updatePrivacy": {
+		method: "PUT",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"users.pins": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "users"
+	},
+	"users.setPin": {
+		method: "PUT",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"users.removePin": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.list": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "feed"
+	},
+	"posts.create": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.create"
+	},
+	"posts.get": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"posts.update": {
+		method: "PUT",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"posts.remove": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.restore": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.like": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.like"
+	},
+	"posts.unlike": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.like"
+	},
+	"posts.repost": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.repost"
+	},
+	"posts.unrepost": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.repost"
+	},
+	"posts.pin": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.unpin": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.vote": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"posts.stats": {
+		method: "POST",
+		retrySafety: RetrySafety.Safe,
+		bucket: "posts.stats"
+	},
+	"posts.byUser": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"posts.likedByUser": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"posts.comments": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "posts.comments"
+	},
+	"posts.comment": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "posts.comment"
+	},
+	"comments.replies": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"comments.reply": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"comments.update": {
+		method: "PATCH",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"comments.remove": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"comments.restore": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"comments.like": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "comments.like"
+	},
+	"comments.unlike": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "comments.like"
+	},
+	"files.upload": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "files.upload"
+	},
+	"files.get": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "files.get"
+	},
+	"files.remove": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "files.remove"
+	},
+	"notifications.list": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
+	},
+	"notifications.count": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "notifications"
+	},
+	"notifications.markRead": {
+		method: "POST",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"notifications.markReadBatch": {
+		method: "POST",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"notifications.markAllRead": {
+		method: "POST",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"notifications.getSettings": {
+		method: "GET",
+		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,
+		bucket: "hashtags"
+	},
+	"hashtags.trending": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "hashtags.trending"
+	},
+	"hashtags.posts": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "hashtags"
+	},
+	"search.all": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "search"
+	},
+	"reports.create": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "reports.create"
+	},
+	"subscription.status": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"subscription.pay": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"subscription.setAutoRenewal": {
+		method: "POST",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"subscription.bindCard": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"subscription.methods": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"subscription.setDefaultMethod": {
+		method: "POST",
+		retrySafety: RetrySafety.Idempotent
+	},
+	"subscription.removeMethod": {
+		method: "DELETE",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"verification.status": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe,
+		bucket: "verification.status"
+	},
+	"verification.submit": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe,
+		bucket: "verification.submit"
+	},
+	"platform.version": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"platform.changelog": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"platform.announcements": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"platform.portal": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"platform.status": {
+		method: "GET",
+		retrySafety: RetrySafety.Safe
+	},
+	"telemetry.dwell": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	},
+	"telemetry.interaction": {
+		method: "POST",
+		retrySafety: RetrySafety.Unsafe
+	}
+});
+const BUILT_IN_IDS = new Set(Object.keys(OPERATIONS));
+/** Проверяет принадлежность ID встроенному каталогу. */
+function isBuiltInOperationId(value) {
+	return BUILT_IN_IDS.has(value);
+}
+/** HTTP-метод встроенной операции. */
+function operationMethod(id) {
+	return OPERATIONS[id].method;
+}
+/** Политика автоматического повтора встроенной операции. */
+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/domain/catalog.ts
+/**
+* Каталог операций итд.com, которым пользуется ядро.
+*
+* Единственное место, где generic request executor встречается с таблицами конкретного API.
+* Собирается из уже существующих функций каталога: собственной логики здесь нет.
+*
+* @internal
+*/
+const ITD_CATALOG = Object.freeze({
+	retrySafetyOf: (id) => isBuiltInOperationId(id) ? operationRetrySafety(id) : void 0,
+	methodOf: (id) => isBuiltInOperationId(id) ? operationMethod(id) : void 0,
+	bucketOf: (id) => operationBucket(id),
+	isKnownBucket,
+	bucketLimits: BUCKET_LIMITS,
+	bucketOverrides: DEFAULT_BUCKET_OVERRIDES,
+	defaultBucket: DEFAULT_RATE_LIMIT_BUCKET
+});
+//#endregion
+//#region src/types/enums.ts
+/**
+* Вкладка ленты `GET /api/posts`.
+*
+* Множество закрытое: неизвестное значение сервер отвергнет.
+*/
+const FeedTab = Object.freeze({
+	/** Популярное. Курсор здесь — номер страницы в виде строки (`"2"`, `"6"`…). */
+	Popular: "popular",
+	/** Записи тех, на кого вы подписаны. Курсор — отметка времени последнего поста. */
+	Following: "following",
+	/** Лента клана. Курсор, как и в подписках, — отметка времени. */
+	Clan: "clan"
+});
+/** Порядок комментариев к посту. */
+const CommentSort = Object.freeze({
+	/** Сначала новые. */
+	Newest: "newest",
+	/** Сначала старые. */
+	Oldest: "oldest",
+	/** Сначала популярные. */
+	Popular: "popular"
+});
+/** Тип вложения. */
+const AttachmentType = Object.freeze({
+	Image: "image",
+	Video: "video",
+	/** Голосовые комментарии: `audio/ogg`, с полем `duration`. */
+	Audio: "audio"
+});
+/**
+* Тип фрагмента разметки в тексте поста или комментария.
+*
+* Первые два сервер расставляет сам при разборе текста, остальные приходят от редактора.
+* Тип открытый: набор может пополниться.
+*
+* @example
+* ```ts
+* await itd.posts.update(postId, {
+*   content: 'жирное слово',
+*   spans: [{ type: SpanType.Bold, offset: 0, length: 6 }],
+* });
+* ```
+*/
+const SpanType = Object.freeze({
+	/** Хэштег. Название без решётки лежит в `tag`. */
+	Hashtag: "hashtag",
+	/** Упоминание. Имя пользователя лежит в `tag`. */
+	Mention: "mention",
+	/** Ссылка. Адрес лежит в `url`, а не в `tag`. */
+	Link: "link",
+	Bold: "bold",
+	Italic: "italic",
+	Underline: "underline",
+	/** Зачёркнутый. */
+	Strike: "strike",
+	/** Спойлер: текст скрыт до нажатия. */
+	Spoiler: "spoiler",
+	/** Моноширинный. */
+	Monospace: "monospace",
+	Quote: "quote"
+});
+/** На что подаётся жалоба. */
+const ReportTargetType = Object.freeze({
+	Post: "post",
+	Comment: "comment",
+	User: "user"
+});
+/** Причина жалобы. Множество закрытое. */
+const ReportReason = Object.freeze({
+	Spam: "spam",
+	Violence: "violence",
+	Hate: "hate",
+	Adult: "adult",
+	Fraud: "fraud",
+	Other: "other"
+});
+/** Состояние realtime-соединения. */
+const RealtimeStatus = Object.freeze({
+	Connecting: "connecting",
+	Connected: "connected",
+	Error: "error",
+	Disconnected: "disconnected"
+});
+/** Состояние сервиса платформы. Тип открытый. */
+const ServiceState = Object.freeze({
+	/** Работает штатно. */
+	Operational: "operational",
+	/** Работает с деградацией. */
+	Degraded: "degraded",
+	/** Недоступен. */
+	Downtime: "downtime"
+});
+/** Вид происшествия в истории сервиса. Тип открытый. */
+const IncidentKind = Object.freeze({
+	/** Недоступен. */
+	Down: "down",
+	/** Деградация. */
+	Degraded: "deg"
+});
+/**
+* Уровень доступа к разделу профиля.
+*
+* Общий набор значений для полей `wallAccess` и `likesVisibility` настроек приватности.
+* Тип открытый: сервер может прислать значение вне этого перечня.
+*/
+const AccessType = Object.freeze({
+	/** Никто. */
+	Nobody: "nobody",
+	/** Только взаимные подписки. */
+	Mutual: "mutual",
+	/** Подписчики. */
+	Followers: "followers",
+	/** Все. */
+	Everyone: "everyone"
+});
+/** Кто может писать на стену профиля. Псевдоним {@link AccessType}. */
+const WallAccess = AccessType;
+/** Кто видит реакции пользователя. Псевдоним {@link AccessType}. */
+const LikesVisibility = AccessType;
+/**
+* Канонический тип уведомления (новое поколение имён).
+*
+* REST-эндпоинт `/api/notifications/` отдаёт старые имена (`like`, `comment`, `reply`,
+* `repost`, `mention`), SSE-поток — новые. Библиотека приводит их к этому набору,
+* сохраняя исходное значение в поле `rawType`.
+*/
+const NotificationType = Object.freeze({
+	/** Реакция на пост. Старое имя — `like`. */
+	PostReaction: "post_reaction",
+	/** Комментарий к посту. Старое имя — `comment`. */
+	PostComment: "post_comment",
+	/** Ответ на комментарий. Старое имя — `reply`. */
+	CommentReply: "comment_reply",
+	/** Репост. Старое имя — `repost`. */
+	PostRepost: "post_repost",
+	/** Упоминание в посте. Старое имя — `mention`. */
+	PostMention: "post_mention",
+	/** Реакция на комментарий. */
+	CommentReaction: "comment_reaction",
+	/** Упоминание в комментарии. */
+	CommentMention: "comment_mention",
+	/** Запись на вашей стене. */
+	WallPost: "wall_post",
+	/** На вас подписались. */
+	Follow: "follow",
+	/** Заявка на подписку (закрытый профиль). */
+	FollowRequest: "follow_request",
+	/** Заявка на подписку принята. */
+	FollowAccepted: "follow_accepted",
+	/** Верификация одобрена. Приходит только по REST. */
+	VerificationApproved: "verification_approved",
+	/** Верификация отклонена. Приходит только по REST. */
+	VerificationRejected: "verification_rejected"
+});
+/**
+* Тип взаимодействия с контентом в телеметрии (`POST /api/v1/x`, поле `t`).
+*
+* Кодируется числом.
+*/
+const InteractionType = Object.freeze({
+	/** Открытие фотографии. */
+	PhotoOpen: 1,
+	/** Прогресс просмотра видео. Несёт поля `pm`/`dm`. */
+	VideoProgress: 2
+});
+/**
+* Источник показа поста в телеметрии (поле `s`).
+*
+* Кодируется числом. Поле применимо к источникам `PostPage` и `Link`; для лент источник
+* передаётся контекстом `sc`.
+*/
+const ViewSource = Object.freeze({
+	FeedGlobal: 1,
+	FeedFollowing: 2,
+	FeedClan: 3,
+	Profile: 4,
+	Hashtag: 5,
+	PostPage: 6,
+	Link: 7,
+	Search: 8
+});
+/**
+* Причина завершения просмотра поста в телеметрии (`POST /api/v1/i`, поле `r`).
+*
+* Кодируется числом.
+*/
+const ViewReason = Object.freeze({
+	/** Пост ушёл из зоны видимости при обычной прокрутке. */
+	Normal: 0,
+	/** Потеря фокуса окна. */
+	Blur: 1,
+	/** Вкладка скрыта. */
+	Hidden: 2,
+	/** Уход со страницы (`pagehide`). */
+	PageHide: 3,
+	/** Элемент перестал наблюдаться. */
+	Unobserve: 4,
+	/** Достигнут порог времени просмотра. */
+	ThresholdMet: 5
+});
+/**
+* Строковые коды ошибок из поля `code`.
+*
+* Ключи намеренно повторяют написание сервера: код из ответа API можно найти здесь
+* поиском один в один, без мысленного перевода регистра.
+*
+* Список открыт — сервер может добавить новый код, и это не должно ломать типизацию.
+*
+* @example
+* ```ts
+* if (err.hasCode(ItdErrorCode.OTP_INVALID)) await restartOtpFlow();
+* ```
+*/
+const ItdErrorCode = Object.freeze({
+	BAD_REQUEST: "BAD_REQUEST",
+	UNAUTHORIZED: "UNAUTHORIZED",
+	ACCESS_DENIED: "ACCESS_DENIED",
+	ENTITY_NOT_FOUND: "ENTITY_NOT_FOUND",
+	ENTITY_ALREADY_EXISTS: "ENTITY_ALREADY_EXISTS",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	BUSINESS_RULE_VIOLATION: "BUSINESS_RULE_VIOLATION",
+	RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR",
+	/** Сервер отвечает так на `404`, `ENTITY_NOT_FOUND` в этом случае не приходит. */
+	NOT_FOUND: "NOT_FOUND",
+	/** На практике не приходит: вместо него сервер шлёт `TURNSTILE_VERIFICATION_FAILED`. */
+	CAPTCHA_FAILED: "CAPTCHA_FAILED",
+	/** Капча не пройдена: токен Turnstile недействителен, просрочен или уже использован. */
+	TURNSTILE_VERIFICATION_FAILED: "TURNSTILE_VERIFICATION_FAILED",
+	OTP_INVALID: "OTP_INVALID",
+	/** `flowToken` неизвестен или просрочен — поток подтверждения нужно начинать заново. */
+	INVALID_FLOW_TOKEN: "INVALID_FLOW_TOKEN",
+	ACCOUNT_DEACTIVATED: "ACCOUNT_DEACTIVATED",
+	ACCOUNT_EMAIL_DOMAIN_NOT_ALLOWED: "ACCOUNT_EMAIL_DOMAIN_NOT_ALLOWED",
+	ACCOUNT_INVALID_CREDENTIALS: "ACCOUNT_INVALID_CREDENTIALS",
+	ACCOUNT_TEMPORARILY_LOCKED: "ACCOUNT_TEMPORARILY_LOCKED",
+	ACCOUNT_CURRENT_PASSWORD_INCORRECT: "ACCOUNT_CURRENT_PASSWORD_INCORRECT",
+	SESSION_EXPIRED: "SESSION_EXPIRED",
+	SESSION_REVOKED: "SESSION_REVOKED",
+	SESSION_INVALID_REFRESH_TOKEN: "SESSION_INVALID_REFRESH_TOKEN",
+	/** Запрос обновления пришёл без cookie `refresh_token` — продлевать нечего. */
+	REFRESH_TOKEN_MISSING: "REFRESH_TOKEN_MISSING",
+	/** Cookie `refresh_token` есть, но сессии за ней уже нет: отозвана или истекла. */
+	SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+	MISSING_FLOW_TOKEN: "MISSING_FLOW_TOKEN",
+	PROFILE_USERNAME_TAKEN: "PROFILE_USERNAME_TAKEN",
+	PROFILE_RESTRICTION_ACTIVE: "PROFILE_RESTRICTION_ACTIVE",
+	PROFILE_MODIFICATION_RESTRICTED: "PROFILE_MODIFICATION_RESTRICTED",
+	CONTENT_MODERATION_FAILED: "CONTENT_MODERATION_FAILED",
+	FILE_TOO_LARGE: "FILE_TOO_LARGE",
+	UNSUPPORTED_FILE_TYPE: "UNSUPPORTED_FILE_TYPE",
+	UPLOAD_FAILED: "UPLOAD_FAILED",
+	VIDEO_REQUIRES_VERIFICATION: "VIDEO_REQUIRES_VERIFICATION",
+	PHONE_VERIFICATION_REQUIRED: "PHONE_VERIFICATION_REQUIRED",
+	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
+	};
+}
+/**
+* Разбирает событие `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/notifications/text.ts
+/** Имя, которое подставляется, если участник неизвестен. */
+const UNKNOWN_ACTOR = "Пользователь";
+/** Текст, который подставляется для неизвестного типа уведомления. */
+const FALLBACK_TEXT = "Новое уведомление";
+/**
+* Шаблоны текстов уведомлений.
+*
+* Для каждого типа задано две формы: для одного участника и для схлопнутого уведомления,
+* где действие совершили несколько человек.
+*/
+const TEMPLATES = Object.freeze({
+	[NotificationType.Follow]: {
+		one: (name) => `${name} подписался(-ась) на вас`,
+		many: (name, others) => `${name} и ещё ${others} подписались на вас`
+	},
+	[NotificationType.FollowRequest]: {
+		one: (name) => `${name} хочет подписаться на вас`,
+		many: (name, others) => `${name} и ещё ${others} хотят подписаться на вас`
+	},
+	[NotificationType.FollowAccepted]: {
+		one: (name) => `${name} принял(а) вашу заявку`,
+		many: (name, others) => `${name} и ещё ${others} приняли вашу заявку`
+	},
+	[NotificationType.PostReaction]: {
+		one: (name) => `${name} оценил(а) ваш пост`,
+		many: (name, others) => `${name} и ещё ${others} оценили ваш пост`
+	},
+	[NotificationType.PostComment]: {
+		one: (name) => `${name} прокомментировал(а) ваш пост`,
+		many: (name, others) => `${name} и ещё ${others} прокомментировали ваш пост`
+	},
+	[NotificationType.PostRepost]: {
+		one: (name) => `${name} сделал(а) репост`,
+		many: (name, others) => `${name} и ещё ${others} сделали репост`
+	},
+	[NotificationType.CommentReaction]: {
+		one: (name) => `${name} оценил(а) ваш комментарий`,
+		many: (name, others) => `${name} и ещё ${others} оценили ваш комментарий`
+	},
+	[NotificationType.CommentReply]: {
+		one: (name) => `${name} ответил(а) на ваш комментарий`,
+		many: (name, others) => `${name} и ещё ${others} ответили на ваш комментарий`
+	},
+	[NotificationType.PostMention]: {
+		one: (name) => `${name} упомянул(а) вас в посте`,
+		many: (name, others) => `${name} и ещё ${others} упомянули вас в посте`
+	},
+	[NotificationType.CommentMention]: {
+		one: (name) => `${name} упомянул(а) вас в комментарии`,
+		many: (name, others) => `${name} и ещё ${others} упомянули вас в комментарии`
+	},
+	[NotificationType.WallPost]: {
+		one: (name) => `${name} написал(а) на вашей стене`,
+		many: (name, others) => `${name} и ещё ${others} написали на вашей стене`
+	},
+	[NotificationType.VerificationApproved]: {
+		one: () => "Ваша заявка на верификацию одобрена",
+		many: () => "Ваша заявка на верификацию одобрена"
+	},
+	[NotificationType.VerificationRejected]: {
+		one: () => "Ваша заявка на верификацию отклонена",
+		many: () => "Ваша заявка на верификацию отклонена"
+	}
+});
+/**
+* Собирает текст уведомления на русском.
+*
+* Повторяет формулировки сайта итд.com. Для неизвестного типа возвращает
+* «Новое уведомление» — библиотека не выдумывает текст, которого нет.
+*
+* @example
+* ```ts
+* formatNotificationText(notification);
+* // 'Аня и ещё 2 оценили ваш пост'
+* ```
+*/
+function formatNotificationText(notification) {
+	const template = TEMPLATES[notification.type];
+	if (!template) return FALLBACK_TEXT;
+	const first = notification.actors[0];
+	const name = first?.displayName || first?.username || UNKNOWN_ACTOR;
+	const others = notification.count - 1;
+	return others > 0 ? template.many(name, others) : template.one(name);
+}
+//#endregion
+//#region src/notifications/url.ts
+/** Типы, ведущие на пост. */
+const POST_TYPES = /* @__PURE__ */ new Set([
+	NotificationType.PostReaction,
+	NotificationType.PostRepost,
+	NotificationType.PostMention,
+	NotificationType.WallPost
+]);
+/** Типы, ведущие на комментарий внутри поста. */
+const COMMENT_TYPES = /* @__PURE__ */ new Set([
+	NotificationType.PostComment,
+	NotificationType.CommentReaction,
+	NotificationType.CommentReply,
+	NotificationType.CommentMention
+]);
+/** Типы, ведущие на профиль. */
+const FOLLOW_TYPES = /* @__PURE__ */ new Set([
+	NotificationType.Follow,
+	NotificationType.FollowRequest,
+	NotificationType.FollowAccepted
+]);
+/**
+* Вычисляет адрес, на который ведёт уведомление.
+*
+* Возвращает путь внутри сайта — без домена, чтобы его можно было передать роутеру
+* приложения. Поле `clickUrl` от сервера используется только как запасной вариант:
+* вычисленный путь точнее, поскольку учитывает родительский пост у комментариев.
+*
+* @example
+* ```ts
+* const url = resolveNotificationUrl(notification);
+* // '/@nowkie/post/9f1c…?comment=2b7e…'
+* ```
+*/
+function resolveNotificationUrl(notification) {
+	const { type, entityId, parentEntityId, clickUrl } = notification;
+	const username = notification.actors[0]?.username;
+	if (username && entityId) {
+		if (POST_TYPES.has(type)) return `/@${username}/post/${entityId}`;
+		if (COMMENT_TYPES.has(type)) return parentEntityId ? `/@${username}/post/${parentEntityId}?comment=${entityId}` : `/@${username}/post/${entityId}`;
+	}
+	if (username && FOLLOW_TYPES.has(type)) return `/@${username}`;
+	return clickUrl || "/notifications";
+}
+//#endregion
+export { RuntimeMode as $, operationRetrySafety as A, maskSecret as B, ViewSource as C, isBuiltInOperationId as D, OPERATIONS as E, pickArray as F, orderPluginDefinitions as G, RetrySafety as H, pickBoolean as I, resolveRateLimit as J, DEFAULT_BASE_URL as K, pickNumber as L, DEFAULT_RATE_LIMIT_BUCKET as M, createClientRuntime as N, operationBucket as O, isRecord as P, RateLimitPacing as Q, pickObject as R, ViewReason as S, ITD_CATALOG as T, RequestQueuePool as U, redactUrl as V, assertPluginRemovable as W, isRecord$1 as X, LIBRARY_VERSION as Y, requireOptionalBoolean as Z, RealtimeStatus as _, readUnreadCountEvent as a, systemClock as at, ServiceState as b, AccessType as c, FeedTab as d, createDeviceId as et, IncidentKind as f, NotificationType as g, LikesVisibility as h, readNotificationEvent as i, createDeadline as it, BUCKET_LIMITS as j, operationMethod as k, AttachmentType as l, ItdErrorCode as m, formatNotificationText as n, isFile as nt, canonicalNotificationType as o, installAsyncDisposeFallback as ot, InteractionType as p, STATUS_SERVICE as q, normalizeNotification as r, supportsStreamingBody as rt, isKnownNotificationType as s, resolveNotificationUrl as t, isBlob as tt, CommentSort as u, ReportReason as v, WallAccess as w, SpanType as x, ReportTargetType as y, pickString as z };
+
+//# sourceMappingURL=url-CYXgxqGx.js.map