itd-api 0.7.0 → 0.7.2

package/dist/shared/url-BaMCQpYH.cjs

@@ -0,0 +1,4084 @@
+const require_errors = require("./errors-DfU8M5eS.cjs");
+const require_cookies = require("./cookies-DZwFq6kr.cjs");
+//#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 require_errors.ItdConfigError("fetch должен быть функцией");
+		return custom;
+	}
+	if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+	throw new require_errors.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 require_errors.ItdConfigError(`${name} должен быть неотрицательным числом, получено: ${value}`);
+	return value;
+}
+/** @throws {ItdConfigError} если значение задано и не является boolean */
+function requireOptionalBoolean(value, name) {
+	if (value !== void 0 && typeof value !== "boolean") throw new require_errors.ItdConfigError(`${name} должен быть boolean`);
+}
+//#endregion
+//#region src/core/version.ts
+/** Версия библиотеки. Попадает в `User-Agent`. */
+const LIBRARY_VERSION = "0.7.2";
+//#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";
+/**
+* `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 require_errors.ItdConfigError("headers должен быть объектом строк");
+	for (const [name, value] of Object.entries(headers)) if (typeof value !== "string") throw new require_errors.ItdConfigError(`headers.${name} должен быть строкой`);
+	return { ...headers };
+}
+function resolveHooks(hooks) {
+	if (hooks === void 0) return {};
+	if (!isRecord$1(hooks)) throw new require_errors.ItdConfigError("hooks должен быть объектом");
+	for (const name of [
+		"onRequest",
+		"onResponse",
+		"onError",
+		"onRetry"
+	]) if (hooks[name] !== void 0 && typeof hooks[name] !== "function") throw new require_errors.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 require_errors.ItdConfigError("logger должен быть boolean или объектом Logger");
+	for (const method of [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	]) if (typeof logger[method] !== "function") throw new require_errors.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 require_errors.ItdConfigError("retry должен быть объектом или false");
+	const options = retry ?? {};
+	const attempts = options.attempts ?? 3;
+	if (!Number.isInteger(attempts) || attempts < 1) throw new require_errors.ItdConfigError(`retry.attempts должен быть целым числом от 1, получено: ${attempts}`);
+	const jitter = options.jitter ?? .3;
+	if (!Number.isFinite(jitter) || jitter < 0 || jitter > 1) throw new require_errors.ItdConfigError(`retry.jitter должен быть в диапазоне 0…1, получено: ${jitter}`);
+	if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") throw new require_errors.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 require_errors.ItdConfigError(`${option}: бакета «${name}» нет. Известны: ${Object.keys(catalog.bucketLimits).join(", ")}`);
+}
+function requireConcurrency(value, name) {
+	if (!Number.isInteger(value) || value < 1) throw new require_errors.ItdConfigError(`${name} должен быть целым числом от 1, получено: ${value}`);
+	return value;
+}
+function resolvePacing(pacing) {
+	const known = Object.values(RateLimitPacing);
+	if (pacing !== void 0 && !known.includes(pacing)) throw new require_errors.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 require_errors.ItdConfigError("rateLimit.bucketOverrides должен быть объектом");
+	const resolved = { ...builtIn };
+	for (const [name, override] of Object.entries(overrides)) {
+		if (!isRecord$1(override)) throw new require_errors.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 require_errors.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 require_errors.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 require_errors.ItdConfigError(`rateLimit.rps должен быть положительным числом, получено: ${rateLimit.rps}`);
+	const retryDelays = rateLimit.retryDelays ?? defaults.retryDelays;
+	if (!Array.isArray(retryDelays)) throw new require_errors.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 require_errors.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 require_errors.ItdConfigError("services должен быть объектом");
+	return Object.entries(services).map(([name, value]) => {
+		if (typeof value === "string") return {
+			name,
+			baseUrl: value
+		};
+		if (!isRecord$1(value)) throw new require_errors.ItdConfigError(`services.${name} должен быть URL или объектом сервиса`);
+		return {
+			...value,
+			name
+		};
+	});
+}
+/**
+* Приводит настройки исполнения запросов к полному виду.
+*
+* Все проверки выполняются здесь, до единого сетевого запроса: неверная настройка должна
+* проявляться при создании клиента, а не через полчаса работы бота. Сессионные опции
+* разбирает `resolveSessionConfig` — ядру они не нужны.
+*
+* @throws {ItdConfigError} при некорректных значениях
+*/
+function resolveRuntimeConfig(options, catalog) {
+	if (!isRecord$1(options)) throw new require_errors.ItdConfigError("опции клиента должны быть объектом");
+	const mode = options.mode ?? RuntimeMode.Auto;
+	if (!Object.values(RuntimeMode).includes(mode)) throw new require_errors.ItdConfigError(`mode должен быть одним из ${Object.values(RuntimeMode).join(", ")}, получено: ${mode}`);
+	const timeout = requirePositive(options.timeout ?? 3e4, "timeout");
+	const shutdownTimeout = requirePositive(options.shutdownTimeout ?? 1e4, "shutdownTimeout");
+	if (options.clock !== void 0 && (typeof options.clock !== "object" || options.clock === null || typeof options.clock.now !== "function" || typeof options.clock.schedule !== "function")) throw new require_errors.ItdConfigError("clock должен предоставлять методы now() и schedule()");
+	if (options.userAgent !== void 0 && options.userAgent !== false && typeof options.userAgent !== "string") throw new require_errors.ItdConfigError("userAgent должен быть строкой или false");
+	return {
+		baseUrl: require_cookies.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 require_errors.ItdConfigError(`attempt interceptor плагина «${plugin}» вызвал next() больше одного раза`);
+			called = true;
+			return next();
+		});
+		if (!isResponse(response)) throw new require_errors.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 require_errors.ItdConfigError(`плагин «${plugin.name}»: ${field} должен быть массивом`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (typeof value !== "string" || value.trim() === "") throw new require_errors.ItdConfigError(`плагин «${plugin.name}»: ${field} содержит пустое имя плагина`);
+		if (value === plugin.name) throw new require_errors.ItdConfigError(`плагин «${plugin.name}» не может указать себя в ${field}`);
+		if (seen.has(value)) throw new require_errors.ItdConfigError(`плагин «${plugin.name}»: ${field} повторяет имя «${value}»`);
+		seen.add(value);
+	}
+}
+/**
+* Проверяет описание плагина без его установки.
+*
+* Нужна не только {@link PluginRegistry}: контейнер аккаунтов обязан отклонять сломанный
+* плагин сразу, даже когда внутри ещё нет ни одного клиента, которому можно поручить
+* полноценную установку.
+*
+* @internal
+*/
+function validatePluginDefinition(plugin) {
+	if (typeof plugin?.install !== "function") throw new require_errors.ItdConfigError("Плагин должен быть объектом с методом install()");
+	const name = plugin.name;
+	if (typeof name !== "string" || name.trim() === "") throw new require_errors.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 require_errors.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 require_errors.ItdConfigError(`плагину «${plugin.name}» требуется плагин «${required}»`);
+		for (const conflict of plugin.conflicts ?? []) if (byName.has(conflict)) throw new require_errors.ItdConfigError(`плагин «${plugin.name}» несовместим с плагином «${conflict}»`);
+		for (const { plugin: other } of entries) if (other.conflicts?.includes(plugin.name)) throw new require_errors.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 require_errors.ItdConfigError(`циклический порядок плагинов: ${cycle.join(" → ")}`);
+	}
+	return ordered;
+}
+/** Проверяет, можно ли удалить плагин без нарушения обязательных зависимостей. @internal */
+function assertPluginRemovable(plugins, name) {
+	const dependent = plugins.find((plugin) => plugin.requires?.includes(name));
+	if (dependent) throw new require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.ItdAbortError("Запрос отменён во время ожидания очереди");
+}
+/** Ошибка запроса, которого застала остановка очереди. */
+function queueStoppedError() {
+	return new require_errors.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, featureDefinition) {
+		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 ? featureDefinition?.limit ?? seedLimit(bucket, options) : void 0;
+		this.#gate = new RequestQueue({
+			concurrency: options.buckets ? featureDefinition?.concurrency ?? 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();
+	/** Динамические определения feature вместе с числом использующих их клиентов. */
+	#featureBuckets = /* @__PURE__ */ new Map();
+	constructor(options, clock = systemClock) {
+		this.#options = options;
+		this.#clock = clock;
+	}
+	/**
+	* Регистрирует бакет подключаемого feature.
+	*
+	* Повтор той же декларации разрешён клиентам, разделяющим один pool через `ItdAccounts`.
+	* Возвращённая функция откатывает регистрацию, пока очередь бакета ещё не создана.
+	*/
+	defineBucket(name, definition) {
+		const normalized = Object.freeze({
+			...definition.limit === void 0 ? {} : { limit: definition.limit },
+			...definition.concurrency === void 0 ? {} : { concurrency: definition.concurrency }
+		});
+		const existing = this.#featureBuckets.get(name);
+		if (existing) {
+			if (existing.definition.limit !== normalized.limit || existing.definition.concurrency !== normalized.concurrency) throw new require_errors.ItdConfigError(`Бакет feature «${name}» уже зарегистрирован с другими ограничениями`);
+			existing.references += 1;
+		} else this.#featureBuckets.set(name, {
+			definition: normalized,
+			references: 1
+		});
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const current = this.#featureBuckets.get(name);
+			if (!current) return;
+			current.references -= 1;
+			if (current.references > 0) return;
+			if (![...this.#destinations.values()].some((entry) => entry.buckets.has(name))) this.#featureBuckets.delete(name);
+		};
+	}
+	/** Очередь бакета на направлении. При `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, this.#featureBuckets.get(name)?.definition);
+			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();
+		this.#featureBuckets.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 ? require_cookies.hostOf(primaryBaseUrl) : "";
+	}
+	/**
+	* Регистрирует сервис. Имя очищается от краевых пробелов, базовый URL приводится
+	* к каноничному виду, а незаданный `auth` выводится из хоста.
+	*
+	* @throws {ItdConfigError} если имя пустое, имя занято или `baseUrl` не абсолютный URL
+	*/
+	define(definition) {
+		const raw = definition?.name;
+		if (typeof raw !== "string" || raw.trim() === "") throw new require_errors.ItdConfigError("У сервиса должно быть непустое имя");
+		const name = raw.trim();
+		if (this.#services.has(name)) throw new require_errors.ItdConfigError(`Сервис «${name}» уже зарегистрирован и не может быть заменён`);
+		const baseUrl = require_cookies.normalizeBaseUrl(definition.baseUrl);
+		if (definition.auth !== void 0 && typeof definition.auth !== "boolean") throw new require_errors.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 require_errors.ItdConfigError(`services.${name}.headers должен быть объектом строк`);
+			for (const [header, value] of Object.entries(definition.headers)) if (typeof value !== "string") throw new require_errors.ItdConfigError(`services.${name}.headers.${header} должен быть строкой`);
+			headers = Object.freeze({ ...definition.headers });
+		}
+		const normalized = {
+			...definition,
+			name,
+			baseUrl,
+			auth: definition.auth ?? require_cookies.isSameSite(this.#primaryHost, require_cookies.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);
+	}
+	/** Удаляет сервис при откате атомарной установки feature. @internal */
+	delete(name) {
+		return this.#services.delete(name);
+	}
+	/**
+	* Атомарно заменяет существующее определение и возвращает прежнее.
+	* Используется feature, накладывающим default на сервис из опций клиента.
+	*
+	* @internal
+	*/
+	replace(definition) {
+		const name = definition.name.trim();
+		const previous = this.require(name);
+		this.#services.delete(name);
+		try {
+			this.define(definition);
+		} catch (error) {
+			this.#services.set(name, previous);
+			throw error;
+		}
+		return previous;
+	}
+	/**
+	* Определение сервиса.
+	*
+	* @throws {ItdConfigError} если сервис не зарегистрирован
+	*/
+	require(name) {
+		const service = this.#services.get(name);
+		if (!service) {
+			const known = [...this.#services.keys()];
+			throw new require_errors.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 require_cookies.isSameSite(this.#primaryHost, require_cookies.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 require_errors.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 require_errors.ItdAbortError || !policy.bodyReplayable) return false;
+	const repeatableOperation = policy.retrySafety === RetrySafety.Safe || policy.retrySafety === RetrySafety.Idempotent;
+	if (error instanceof require_errors.ItdApiError) {
+		if (error.status === 429) return true;
+		if (error.status >= 500) return repeatableOperation;
+		return false;
+	}
+	if (error instanceof require_errors.ItdNetworkError || error instanceof require_errors.ItdTimeoutError) return repeatableOperation;
+	if (error instanceof require_errors.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 require_errors.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 require_errors.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 require_errors.ItdAbortError("Запрос отменён во время ожидания повтора"));
+	return new Promise((resolve, reject) => {
+		const cancel = clock.schedule(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			cancel();
+			reject(new require_errors.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 = require_cookies.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 || !require_errors.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 (require_errors.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 (require_errors.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: require_errors.ItdValidationError,
+	RATE_LIMIT_EXCEEDED: require_errors.ItdRateLimitError,
+	UNAUTHORIZED: require_errors.ItdAuthError,
+	SESSION_EXPIRED: require_errors.ItdAuthError,
+	SESSION_REVOKED: require_errors.ItdAuthError,
+	SESSION_INVALID_REFRESH_TOKEN: require_errors.ItdAuthError,
+	REFRESH_TOKEN_MISSING: require_errors.ItdAuthError,
+	SESSION_NOT_FOUND: require_errors.ItdAuthError,
+	ACCOUNT_INVALID_CREDENTIALS: require_errors.ItdAuthError,
+	ACCESS_DENIED: require_errors.ItdForbiddenError,
+	ENTITY_NOT_FOUND: require_errors.ItdNotFoundError,
+	NOT_FOUND: require_errors.ItdNotFoundError,
+	ENTITY_ALREADY_EXISTS: require_errors.ItdConflictError
+};
+/** Соответствие HTTP-статуса классу — запасной вариант, когда код ничего не говорит. */
+function classByStatus(status) {
+	if (status === 401) return require_errors.ItdAuthError;
+	if (status === 403) return require_errors.ItdForbiddenError;
+	if (status === 404) return require_errors.ItdNotFoundError;
+	if (status === 409) return require_errors.ItdConflictError;
+	if (status === 422) return require_errors.ItdValidationError;
+	if (status === 429) return require_errors.ItdRateLimitError;
+	if (status >= 500) return require_errors.ItdServerError;
+	return require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_cookies.joinUrl(base, request.path) + require_cookies.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 require_errors.ItdTimeoutError({
+			timeout,
+			method,
+			path: request.path
+		});
+		if (aborted) {
+			const reason = abort.signal.reason;
+			return new require_errors.ItdAbortError(`Запрос ${method} ${request.path} отменён`, reason !== void 0 ? { cause: reason } : void 0);
+		}
+		if (error instanceof require_errors.ItdError) return error;
+		return new require_errors.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"
+});
+/** Регистрирует сервисы, заранее объявленные в опциях клиента. */
+function createServiceRegistry(config) {
+	const services = new ServiceRegistry(config.baseUrl);
+	for (const service of config.services) 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 require_cookies.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: require_cookies.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() ?? [],
+		registerRateLimitBucket: (name, definition) => queues?.defineBucket(name, definition),
+		close: () => {
+			if (ownsQueues) queues?.stop();
+		},
+		dispose: async () => {
+			lifetime.abort(new require_errors.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
+	},
+	"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
+Object.defineProperty(exports, "AccessType", {
+	enumerable: true,
+	get: function() {
+		return AccessType;
+	}
+});
+Object.defineProperty(exports, "AttachmentType", {
+	enumerable: true,
+	get: function() {
+		return AttachmentType;
+	}
+});
+Object.defineProperty(exports, "BUCKET_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return BUCKET_LIMITS;
+	}
+});
+Object.defineProperty(exports, "CommentSort", {
+	enumerable: true,
+	get: function() {
+		return CommentSort;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_BASE_URL", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_BASE_URL;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_RATE_LIMIT_BUCKET", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_RATE_LIMIT_BUCKET;
+	}
+});
+Object.defineProperty(exports, "DEFAULT_STATUS_BASE_URL", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_STATUS_BASE_URL;
+	}
+});
+Object.defineProperty(exports, "FeedTab", {
+	enumerable: true,
+	get: function() {
+		return FeedTab;
+	}
+});
+Object.defineProperty(exports, "ITD_CATALOG", {
+	enumerable: true,
+	get: function() {
+		return ITD_CATALOG;
+	}
+});
+Object.defineProperty(exports, "IncidentKind", {
+	enumerable: true,
+	get: function() {
+		return IncidentKind;
+	}
+});
+Object.defineProperty(exports, "InteractionType", {
+	enumerable: true,
+	get: function() {
+		return InteractionType;
+	}
+});
+Object.defineProperty(exports, "ItdErrorCode", {
+	enumerable: true,
+	get: function() {
+		return ItdErrorCode;
+	}
+});
+Object.defineProperty(exports, "LIBRARY_VERSION", {
+	enumerable: true,
+	get: function() {
+		return LIBRARY_VERSION;
+	}
+});
+Object.defineProperty(exports, "LikesVisibility", {
+	enumerable: true,
+	get: function() {
+		return LikesVisibility;
+	}
+});
+Object.defineProperty(exports, "NotificationType", {
+	enumerable: true,
+	get: function() {
+		return NotificationType;
+	}
+});
+Object.defineProperty(exports, "OPERATIONS", {
+	enumerable: true,
+	get: function() {
+		return OPERATIONS;
+	}
+});
+Object.defineProperty(exports, "RateLimitPacing", {
+	enumerable: true,
+	get: function() {
+		return RateLimitPacing;
+	}
+});
+Object.defineProperty(exports, "RealtimeStatus", {
+	enumerable: true,
+	get: function() {
+		return RealtimeStatus;
+	}
+});
+Object.defineProperty(exports, "ReportReason", {
+	enumerable: true,
+	get: function() {
+		return ReportReason;
+	}
+});
+Object.defineProperty(exports, "ReportTargetType", {
+	enumerable: true,
+	get: function() {
+		return ReportTargetType;
+	}
+});
+Object.defineProperty(exports, "RequestQueuePool", {
+	enumerable: true,
+	get: function() {
+		return RequestQueuePool;
+	}
+});
+Object.defineProperty(exports, "RetrySafety", {
+	enumerable: true,
+	get: function() {
+		return RetrySafety;
+	}
+});
+Object.defineProperty(exports, "RuntimeMode", {
+	enumerable: true,
+	get: function() {
+		return RuntimeMode;
+	}
+});
+Object.defineProperty(exports, "STATUS_SERVICE", {
+	enumerable: true,
+	get: function() {
+		return STATUS_SERVICE;
+	}
+});
+Object.defineProperty(exports, "ServiceState", {
+	enumerable: true,
+	get: function() {
+		return ServiceState;
+	}
+});
+Object.defineProperty(exports, "SpanType", {
+	enumerable: true,
+	get: function() {
+		return SpanType;
+	}
+});
+Object.defineProperty(exports, "ViewReason", {
+	enumerable: true,
+	get: function() {
+		return ViewReason;
+	}
+});
+Object.defineProperty(exports, "ViewSource", {
+	enumerable: true,
+	get: function() {
+		return ViewSource;
+	}
+});
+Object.defineProperty(exports, "WallAccess", {
+	enumerable: true,
+	get: function() {
+		return WallAccess;
+	}
+});
+Object.defineProperty(exports, "assertPluginRemovable", {
+	enumerable: true,
+	get: function() {
+		return assertPluginRemovable;
+	}
+});
+Object.defineProperty(exports, "canonicalNotificationType", {
+	enumerable: true,
+	get: function() {
+		return canonicalNotificationType;
+	}
+});
+Object.defineProperty(exports, "createClientRuntime", {
+	enumerable: true,
+	get: function() {
+		return createClientRuntime;
+	}
+});
+Object.defineProperty(exports, "createDeadline", {
+	enumerable: true,
+	get: function() {
+		return createDeadline;
+	}
+});
+Object.defineProperty(exports, "createDeviceId", {
+	enumerable: true,
+	get: function() {
+		return createDeviceId;
+	}
+});
+Object.defineProperty(exports, "formatNotificationText", {
+	enumerable: true,
+	get: function() {
+		return formatNotificationText;
+	}
+});
+Object.defineProperty(exports, "installAsyncDisposeFallback", {
+	enumerable: true,
+	get: function() {
+		return installAsyncDisposeFallback;
+	}
+});
+Object.defineProperty(exports, "isBlob", {
+	enumerable: true,
+	get: function() {
+		return isBlob;
+	}
+});
+Object.defineProperty(exports, "isBuiltInOperationId", {
+	enumerable: true,
+	get: function() {
+		return isBuiltInOperationId;
+	}
+});
+Object.defineProperty(exports, "isFile", {
+	enumerable: true,
+	get: function() {
+		return isFile;
+	}
+});
+Object.defineProperty(exports, "isKnownNotificationType", {
+	enumerable: true,
+	get: function() {
+		return isKnownNotificationType;
+	}
+});
+Object.defineProperty(exports, "isRecord", {
+	enumerable: true,
+	get: function() {
+		return isRecord;
+	}
+});
+Object.defineProperty(exports, "isRecord$1", {
+	enumerable: true,
+	get: function() {
+		return isRecord$1;
+	}
+});
+Object.defineProperty(exports, "maskSecret", {
+	enumerable: true,
+	get: function() {
+		return maskSecret;
+	}
+});
+Object.defineProperty(exports, "mergeService", {
+	enumerable: true,
+	get: function() {
+		return mergeService;
+	}
+});
+Object.defineProperty(exports, "normalizeNotification", {
+	enumerable: true,
+	get: function() {
+		return normalizeNotification;
+	}
+});
+Object.defineProperty(exports, "operationBucket", {
+	enumerable: true,
+	get: function() {
+		return operationBucket;
+	}
+});
+Object.defineProperty(exports, "operationMethod", {
+	enumerable: true,
+	get: function() {
+		return operationMethod;
+	}
+});
+Object.defineProperty(exports, "operationRetrySafety", {
+	enumerable: true,
+	get: function() {
+		return operationRetrySafety;
+	}
+});
+Object.defineProperty(exports, "orderPluginDefinitions", {
+	enumerable: true,
+	get: function() {
+		return orderPluginDefinitions;
+	}
+});
+Object.defineProperty(exports, "pickArray", {
+	enumerable: true,
+	get: function() {
+		return pickArray;
+	}
+});
+Object.defineProperty(exports, "pickBoolean", {
+	enumerable: true,
+	get: function() {
+		return pickBoolean;
+	}
+});
+Object.defineProperty(exports, "pickNumber", {
+	enumerable: true,
+	get: function() {
+		return pickNumber;
+	}
+});
+Object.defineProperty(exports, "pickObject", {
+	enumerable: true,
+	get: function() {
+		return pickObject;
+	}
+});
+Object.defineProperty(exports, "pickString", {
+	enumerable: true,
+	get: function() {
+		return pickString;
+	}
+});
+Object.defineProperty(exports, "readNotificationEvent", {
+	enumerable: true,
+	get: function() {
+		return readNotificationEvent;
+	}
+});
+Object.defineProperty(exports, "readUnreadCountEvent", {
+	enumerable: true,
+	get: function() {
+		return readUnreadCountEvent;
+	}
+});
+Object.defineProperty(exports, "redactUrl", {
+	enumerable: true,
+	get: function() {
+		return redactUrl;
+	}
+});
+Object.defineProperty(exports, "requireOptionalBoolean", {
+	enumerable: true,
+	get: function() {
+		return requireOptionalBoolean;
+	}
+});
+Object.defineProperty(exports, "resolveNotificationUrl", {
+	enumerable: true,
+	get: function() {
+		return resolveNotificationUrl;
+	}
+});
+Object.defineProperty(exports, "resolveRateLimit", {
+	enumerable: true,
+	get: function() {
+		return resolveRateLimit;
+	}
+});
+Object.defineProperty(exports, "supportsStreamingBody", {
+	enumerable: true,
+	get: function() {
+		return supportsStreamingBody;
+	}
+});
+Object.defineProperty(exports, "systemClock", {
+	enumerable: true,
+	get: function() {
+		return systemClock;
+	}
+});
+
+//# sourceMappingURL=url-BaMCQpYH.cjs.map