itd-api 0.10.3 → 0.11.0

package/dist/shared/{url-DS0-lrl-.js → url-Bg61sk_Y.js}

@@ -1,5 +1,5 @@
-import { O as isItdRateLimitError, _ as ItdStateError, a as ItdConfigError, b as isItdApiError, d as ItdForbiddenError, f as ItdNetworkError, g as ItdServerError, h as ItdRateLimitError, i as ItdAuthError, l as ItdFileError, m as ItdPhoneVerificationError, n as ItdApiError, o as ItdConflictError, p as ItdNotFoundError, s as ItdError, t as ItdAbortError, v as ItdTimeoutError, y as ItdValidationError } from "./errors-GI10kZxk.js";
-import { C as shouldSendCredentials, S as resolveFetch, _ as originOf, b as isBlob, d as buildQuery, g as normalizeBaseUrl, h as joinUrl, i as redactHeaders, m as isSameSite, n as redactBody, p as hostOf, s as CookieJar, v as RuntimeMode, w as shouldUseCookieJar, y as createDeviceId } from "./redact-DJV0XM3n.js";
+import { C as ItdValidationError, N as isItdRateLimitError, S as ItdTimeoutError, T as isItdApiError, _ as ItdNotFoundError, a as ItdAbortError, b as ItdServerError, c as ItdAuthError, d as ItdError, g as ItdNetworkError, h as ItdForbiddenError, i as requireOptionalBoolean, l as ItdConfigError, n as isRecord, o as ItdApiError, p as ItdFileError, r as requireNonNegative, t as isObjectLike, u as ItdConflictError, v as ItdPhoneVerificationError, w as TimeoutBudget, x as ItdStateError, y as ItdRateLimitError } from "./validate-D7_kq3g5.js";
+import { C as shouldSendCredentials, E as LogLevel, O as isLevelEnabled, S as resolveFetch, _ as originOf, b as isBlob, d as buildQuery, g as normalizeBaseUrl, h as joinUrl, i as redactHeaders, k as resolveLogger, m as isSameSite, n as redactBody, p as hostOf, s as CookieJar, v as RuntimeMode, w as shouldUseCookieJar, y as createDeviceId } from "./redact-C5oxIvcc.js";
 //#region src/core/async-dispose.ts
 /**
 * Подставляет метод `await using` там, где `Symbol.asyncDispose` отсутствует.
@@ -62,30 +62,9 @@ const RateLimitPacing = Object.freeze({
 	Off: "off"
 });
 //#endregion
-//#region src/core/validate.ts
-/**
-* Проверки, общие для резолверов конфигурации.
-*
-* Настройки исполнения и настройки сессии разбираются в разных модулях, но сообщать
-* об ошибке должны одинаково: пользователю всё равно, какой слой отверг его значение.
-*/
-/** Похоже ли значение на объект настроек, а не на массив или `null`. */
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** @throws {ItdConfigError} если значение задано и не является неотрицательным числом */
-function requirePositive(value, name) {
-	if (!Number.isFinite(value) || value < 0) throw new ItdConfigError(`${name} должен быть неотрицательным числом, получено: ${value}`);
-	return value;
-}
-/** @throws {ItdConfigError} если значение задано и не является boolean */
-function requireOptionalBoolean(value, name) {
-	if (value !== void 0 && typeof value !== "boolean") throw new ItdConfigError(`${name} должен быть boolean`);
-}
-//#endregion
 //#region src/core/version.ts
 /** Версия библиотеки. Попадает в `User-Agent`. */
-const LIBRARY_VERSION = "0.10.3";
+const LIBRARY_VERSION = "0.11.0";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -120,13 +99,13 @@ const DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([
 ]);
 function resolveHeaders(headers) {
 	if (headers === void 0) return {};
-	if (!isRecord$1(headers)) throw new ItdConfigError("headers должен быть объектом строк");
+	if (!isObjectLike(headers)) throw new ItdConfigError("headers должен быть объектом строк");
 	for (const [name, value] of Object.entries(headers)) if (typeof value !== "string") throw new ItdConfigError(`headers.${name} должен быть строкой`);
 	return { ...headers };
 }
 function resolveHooks(hooks) {
 	if (hooks === void 0) return {};
-	if (!isRecord$1(hooks)) throw new ItdConfigError("hooks должен быть объектом");
+	if (!isObjectLike(hooks)) throw new ItdConfigError("hooks должен быть объектом");
 	for (const name of [
 		"onRequest",
 		"onResponse",
@@ -135,27 +114,6 @@ function resolveHooks(hooks) {
 	]) if (hooks[name] !== void 0 && typeof hooks[name] !== "function") throw new ItdConfigError(`hooks.${name} должен быть функцией`);
 	return { ...hooks };
 }
-function resolveLogger(logger) {
-	if (logger === void 0 || logger === false) return void 0;
-	if (logger === true) return consoleLogger();
-	if (!isRecord$1(logger)) throw new ItdConfigError("logger должен быть boolean или объектом Logger");
-	for (const method of [
-		"debug",
-		"info",
-		"warn",
-		"error"
-	]) if (typeof logger[method] !== "function") throw new ItdConfigError(`logger.${method} должен быть функцией`);
-	return logger;
-}
-/** Логгер поверх `console` — включается опцией `logger: true`. */
-function consoleLogger() {
-	return {
-		debug: (message, ...args) => console.debug(`[itd-api] ${message}`, ...args),
-		info: (message, ...args) => console.info(`[itd-api] ${message}`, ...args),
-		warn: (message, ...args) => console.warn(`[itd-api] ${message}`, ...args),
-		error: (message, ...args) => console.error(`[itd-api] ${message}`, ...args)
-	};
-}
 /**
 * Приводит настройки повторов к полному виду.
 *
@@ -167,15 +125,15 @@ function consoleLogger() {
 */
 function resolveRetry(retry) {
 	if (retry === false) return void 0;
-	if (retry !== void 0 && !isRecord$1(retry)) throw new ItdConfigError("retry должен быть объектом или false");
+	if (retry !== void 0 && !isObjectLike(retry)) throw new ItdConfigError("retry должен быть объектом или false");
 	const options = retry ?? {};
 	const attempts = options.attempts ?? 3;
 	if (!Number.isInteger(attempts) || attempts < 1) throw new ItdConfigError(`retry.attempts должен быть целым числом от 1, получено: ${attempts}`);
 	const jitter = options.jitter ?? .3;
 	if (!Number.isFinite(jitter) || jitter < 0 || jitter > 1) throw new ItdConfigError(`retry.jitter должен быть в диапазоне 0…1, получено: ${jitter}`);
 	if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") throw new ItdConfigError("retry.shouldRetry должен быть функцией");
-	const baseDelay = requirePositive(options.baseDelay ?? 500, "retry.baseDelay");
-	const maxDelay = requirePositive(options.maxDelay ?? 3e4, "retry.maxDelay");
+	const baseDelay = requireNonNegative(options.baseDelay ?? 500, "retry.baseDelay");
+	const maxDelay = requireNonNegative(options.maxDelay ?? 3e4, "retry.maxDelay");
 	if (attempts === 1) return void 0;
 	return {
 		attempts,
@@ -223,10 +181,10 @@ function resolvePacing(pacing) {
 function resolveBucketOverrides(overrides, bucket, catalog) {
 	const builtIn = catalog.bucketOverrides;
 	if (overrides === void 0) return builtIn;
-	if (!isRecord$1(overrides)) throw new ItdConfigError("rateLimit.bucketOverrides должен быть объектом");
+	if (!isObjectLike(overrides)) throw new ItdConfigError("rateLimit.bucketOverrides должен быть объектом");
 	const resolved = { ...builtIn };
 	for (const [name, override] of Object.entries(overrides)) {
-		if (!isRecord$1(override)) throw new ItdConfigError(`rateLimit.bucketOverrides.${name} должен быть объектом`);
+		if (!isObjectLike(override)) throw new ItdConfigError(`rateLimit.bucketOverrides.${name} должен быть объектом`);
 		assertKnownBucket(name, "rateLimit.bucketOverrides", bucket, catalog);
 		if (override.concurrency !== void 0) requireConcurrency(override.concurrency, `rateLimit.bucketOverrides.${name}.concurrency`);
 		if (override.limit !== void 0 && (!Number.isFinite(override.limit) || override.limit <= 0)) throw new ItdConfigError(`rateLimit.bucketOverrides.${name}.limit должен быть положительным числом, получено: ${override.limit}`);
@@ -252,7 +210,7 @@ function resolveBucketOverrides(overrides, bucket, catalog) {
 */
 function resolveRateLimit(rateLimit, catalog) {
 	if (rateLimit === false) return void 0;
-	if (rateLimit !== void 0 && !isRecord$1(rateLimit)) throw new ItdConfigError("rateLimit должен быть объектом или false");
+	if (rateLimit !== void 0 && !isObjectLike(rateLimit)) throw new ItdConfigError("rateLimit должен быть объектом или false");
 	const defaults = {
 		concurrency: 6,
 		rps: void 0,
@@ -262,7 +220,6 @@ function resolveRateLimit(rateLimit, catalog) {
 		bucketConcurrency: 6,
 		bucketOverrides: catalog.bucketOverrides,
 		bucket: void 0,
-		bucketLimits: catalog.bucketLimits,
 		defaultBucket: catalog.defaultBucket
 	};
 	if (!rateLimit) return defaults;
@@ -270,7 +227,7 @@ function resolveRateLimit(rateLimit, catalog) {
 	if (rateLimit.rps !== void 0) requireRps(rateLimit.rps, "rateLimit.rps");
 	const retryDelays = rateLimit.retryDelays ?? defaults.retryDelays;
 	if (!Array.isArray(retryDelays)) throw new ItdConfigError("rateLimit.retryDelays должен быть массивом чисел");
-	for (const delay of retryDelays) requirePositive(delay, "rateLimit.retryDelays");
+	for (const delay of retryDelays) requireNonNegative(delay, "rateLimit.retryDelays");
 	requireOptionalBoolean(rateLimit.buckets, "rateLimit.buckets");
 	if (rateLimit.bucket !== void 0 && typeof rateLimit.bucket !== "function") throw new ItdConfigError("rateLimit.bucket должен быть функцией");
 	return {
@@ -282,7 +239,6 @@ function resolveRateLimit(rateLimit, catalog) {
 		bucketConcurrency: requireConcurrency(rateLimit.bucketConcurrency ?? concurrency, "rateLimit.bucketConcurrency"),
 		bucketOverrides: resolveBucketOverrides(rateLimit.bucketOverrides, rateLimit.bucket, catalog),
 		bucket: rateLimit.bucket,
-		bucketLimits: catalog.bucketLimits,
 		defaultBucket: catalog.defaultBucket
 	};
 }
@@ -292,13 +248,13 @@ function resolveRateLimit(rateLimit, catalog) {
 */
 function resolveServices(services) {
 	if (services === void 0) return [];
-	if (!isRecord$1(services)) throw new ItdConfigError("services должен быть объектом");
+	if (!isObjectLike(services)) throw new ItdConfigError("services должен быть объектом");
 	return Object.entries(services).map(([name, value]) => {
 		if (typeof value === "string") return {
 			name,
 			baseUrl: value
 		};
-		if (!isRecord$1(value)) throw new ItdConfigError(`services.${name} должен быть URL или объектом сервиса`);
+		if (!isObjectLike(value)) throw new ItdConfigError(`services.${name} должен быть URL или объектом сервиса`);
 		return {
 			...value,
 			name
@@ -315,11 +271,12 @@ function resolveServices(services) {
 * @throws {ItdConfigError} при некорректных значениях
 */
 function resolveRuntimeConfig(options, catalog) {
-	if (!isRecord$1(options)) throw new ItdConfigError("опции клиента должны быть объектом");
+	if (!isObjectLike(options)) throw new ItdConfigError("опции клиента должны быть объектом");
 	const mode = options.mode ?? RuntimeMode.Auto;
 	if (!Object.values(RuntimeMode).includes(mode)) throw new ItdConfigError(`mode должен быть одним из ${Object.values(RuntimeMode).join(", ")}, получено: ${mode}`);
-	const timeout = requirePositive(options.timeout ?? 3e4, "timeout");
-	const shutdownTimeout = requirePositive(options.shutdownTimeout ?? 1e4, "shutdownTimeout");
+	const timeout = requireNonNegative(options.timeout ?? 3e4, "timeout");
+	const deadline = requireNonNegative(options.deadline ?? 0, "deadline");
+	const shutdownTimeout = requireNonNegative(options.shutdownTimeout ?? 1e4, "shutdownTimeout");
 	if (options.clock !== void 0 && (typeof options.clock !== "object" || options.clock === null || typeof options.clock.now !== "function" || typeof options.clock.schedule !== "function")) throw new ItdConfigError("clock должен предоставлять методы now() и schedule()");
 	if (options.userAgent !== void 0 && options.userAgent !== false && typeof options.userAgent !== "string") throw new ItdConfigError("userAgent должен быть строкой или false");
 	return {
@@ -328,6 +285,7 @@ function resolveRuntimeConfig(options, catalog) {
 		fetch: resolveFetch(options.fetch),
 		clock: options.clock ?? systemClock,
 		timeout,
+		deadline,
 		shutdownTimeout,
 		retry: resolveRetry(options.retry),
 		rateLimit: resolveRateLimit(options.rateLimit, catalog),
@@ -358,7 +316,7 @@ function withAttemptInterceptorScope(request, interceptors) {
 }
 /** Читает снимок attempt interceptors логической операции. @internal */
 function attemptInterceptorScope(request) {
-	return request[ATTEMPT_SCOPE] ?? [];
+	return request[ATTEMPT_SCOPE];
 }
 /**
 * Выполняет обёртки одной попытки.
@@ -366,8 +324,8 @@ function attemptInterceptorScope(request) {
 * Каждый `next` одноразовый: interceptor может short-circuit попытку синтетическим
 * `Response`, но не может незаметно породить два сетевых запроса внутри одного attempt.
 */
-async function runAttemptInterceptors(request, context, execute) {
-	return attemptInterceptorScope(request).reduceRight((next, { plugin, interceptor }) => async () => {
+async function runAttemptInterceptors(interceptors, context, execute) {
+	return interceptors.reduceRight((next, { plugin, interceptor }) => async () => {
 		let called = false;
 		const response = await interceptor(context, () => {
 			if (called) throw new ItdConfigError(`attempt interceptor плагина «${plugin}» вызвал next() больше одного раза`);
@@ -525,9 +483,13 @@ var PluginRegistry = class {
 	}
 	/** Проверяет добавление без вызова `install()`. @internal */
 	assertCanAdd(plugin) {
+		this.#orderWith(plugin);
+	}
+	/** Проверяет плагин и возвращает порядок обёрток вместе с ним. */
+	#orderWith(plugin) {
 		validatePluginDefinition(plugin);
 		if (this.#removing.has(plugin.name)) throw new ItdConfigError(`плагин «${plugin.name}» ещё отключается; дождитесь завершения unuse() или dispose()`);
-		orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
+		return orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
 	}
 	/** Проверяет удаление без изменения реестра. @internal */
 	assertCanRemove(name) {
@@ -543,8 +505,7 @@ var PluginRegistry = class {
 	* @throws {ItdConfigError} если плагин задан неверно, уже подключён или нарушает зависимости
 	*/
 	add(plugin, context) {
-		this.assertCanAdd(plugin);
-		const ordered = orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
+		const ordered = this.#orderWith(plugin);
 		const transformers = [];
 		const interceptors = [];
 		const register = (values, value, kind) => {
@@ -787,15 +748,10 @@ var DestinationScheduler = class {
 	register(bucket) {
 		this.#buckets.push(bucket);
 	}
-	/** Пересчитывает ближайший запуск после изменения очереди или ограничения. */
+	/** Пересчитывает запуск; существующий таймер заменяется только более ранним. */
 	changed() {
 		this.#drain();
 	}
-	/** Перепланирует пробуждение после изменения времени готовности бакета. */
-	timingChanged() {
-		this.#cancelWakeup();
-		this.#drain();
-	}
 	/** Отклоняет ожидающие задачи, сохраняя паузы и темп для повторного запуска клиента. */
 	stop() {
 		this.#cancelWakeup();
@@ -851,6 +807,70 @@ var DestinationScheduler = class {
 	}
 };
 /**
+* Очередь ожидающих задач в порядке постановки.
+*
+* Постановка в хвост, снятие головы, снятие произвольного узла при отмене и полная
+* очистка — за O(1) при любой длине: очередь рассчитана на десятки тысяч задач, разом
+* упёршихся в паузу `429`.
+*/
+var WaitingList = class {
+	#head;
+	#tail;
+	#size = 0;
+	get size() {
+		return this.#size;
+	}
+	push(task) {
+		const node = {
+			task,
+			prev: this.#tail,
+			next: void 0,
+			linked: true
+		};
+		if (this.#tail) this.#tail.next = node;
+		else this.#head = node;
+		this.#tail = node;
+		this.#size += 1;
+		return node;
+	}
+	shift() {
+		const node = this.#head;
+		if (!node) return void 0;
+		this.remove(node);
+		return node.task;
+	}
+	/** Снимает узел; `false`, если он уже снят. */
+	remove(node) {
+		if (!node.linked) return false;
+		node.linked = false;
+		if (node.prev) node.prev.next = node.next;
+		else this.#head = node.next;
+		if (node.next) node.next.prev = node.prev;
+		else this.#tail = node.prev;
+		node.prev = void 0;
+		node.next = void 0;
+		this.#size -= 1;
+		return true;
+	}
+	/** Снимает все узлы; задачи возвращаются в порядке постановки. */
+	drain() {
+		const tasks = [];
+		let node = this.#head;
+		while (node) {
+			const following = node.next;
+			node.linked = false;
+			node.prev = void 0;
+			node.next = void 0;
+			tasks.push(node.task);
+			node = following;
+		}
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+		return tasks;
+	}
+};
+/**
 * Состояние и очередь одного серверного бакета.
 *
 * Класс хранит локальную конкурентность, темп и серверную квоту, а решение о старте
@@ -879,12 +899,14 @@ var BucketQueue = class {
 	#flatPause;
 	/** Лимит бакета до первого ответа. */
 	#seedLimit;
+	/** Начальные ограничения из каталога, с которыми создана очередь. */
+	#definition;
 	/** Последнее, что сказал сервер. Живёт и в режиме `off` — ради `rateLimitState()`. */
 	#limit;
 	#remaining;
 	#active = 0;
 	#nextSlot = 0;
-	#waiting = [];
+	#waiting = new WaitingList();
 	/**
 	* Оценка остатка для режима `smooth`.
 	*
@@ -893,17 +915,19 @@ var BucketQueue = class {
 	*/
 	#tokens = 1;
 	#tokensAt;
-	constructor(destination, bucket, scheduler, options, clock, featureDefinition) {
+	constructor(destination, bucket, scheduler, options, clock, definition) {
 		this.#destination = destination;
 		this.#bucket = bucket;
 		this.#scheduler = scheduler;
 		this.#clock = clock;
+		this.#definition = definition;
 		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.#concurrency = options.buckets ? featureDefinition?.concurrency ?? options.bucketOverrides[bucket]?.concurrency ?? options.bucketConcurrency : options.concurrency;
-		const rps = options.buckets ? featureDefinition?.rps ?? options.bucketOverrides[bucket]?.rps : void 0;
+		const override = options.buckets ? options.bucketOverrides[bucket] : void 0;
+		this.#seedLimit = options.buckets ? override?.limit ?? definition?.limit : void 0;
+		this.#concurrency = options.buckets ? override?.concurrency ?? definition?.concurrency ?? options.bucketConcurrency : options.concurrency;
+		const rps = options.buckets ? override?.rps ?? definition?.rps : void 0;
 		this.#minGap = rps ? 1e3 / rps : 0;
 		scheduler.register(this);
 	}
@@ -911,17 +935,21 @@ var BucketQueue = class {
 	get bucket() {
 		return this.#bucket;
 	}
+	/** Начальные ограничения из каталога, с которыми создана очередь. */
+	get definition() {
+		return this.#definition;
+	}
 	/** Запросов бакета прошло в общую очередь и ещё не завершилось. */
 	get active() {
 		return this.#active;
 	}
 	/** Запросов бакета ждёт своей очереди. */
 	get pending() {
-		return this.#waiting.length;
+		return this.#waiting.size;
 	}
 	/** Есть ли ожидающая задача, для которой свободен локальный слот. */
 	get canStart() {
-		return this.#waiting.length > 0 && this.#active < this.#concurrency;
+		return this.#waiting.size > 0 && this.#active < this.#concurrency;
 	}
 	/** Момент, раньше которого локальное ограничение не разрешает следующий старт. */
 	get readyAt() {
@@ -934,13 +962,11 @@ var BucketQueue = class {
 			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.#scheduler.timingChanged();
+				if (!this.#waiting.remove(queued)) return;
+				queued.task.cancel(queueAbortError());
+				this.#scheduler.changed();
 			};
-			queued = {
+			queued = this.#waiting.push({
 				start: (complete) => {
 					detach();
 					Promise.resolve().then(task).then(resolve, reject).finally(complete);
@@ -949,8 +975,7 @@ var BucketQueue = class {
 					detach();
 					reject(reason);
 				}
-			};
-			this.#waiting.push(queued);
+			});
 			signal?.addEventListener("abort", onAbort, { once: true });
 			if (signal?.aborted) onAbort();
 			else this.#scheduler.changed();
@@ -994,7 +1019,7 @@ var BucketQueue = class {
 			this.#refill(capacity);
 			if (remaining < this.#tokens) this.#tokens = remaining;
 			const wait = this.#armPause(capacity);
-			this.#scheduler.timingChanged();
+			this.#scheduler.changed();
 			return wait;
 		}
 		if (remaining > 0) return 0;
@@ -1018,7 +1043,7 @@ var BucketQueue = class {
 			limit: this.#limit,
 			remaining: this.#remaining,
 			active: this.#active,
-			pending: this.#waiting.length
+			pending: this.#waiting.size
 		};
 	}
 	/** Отклоняет ещё не начатые задачи этого бакета. */
@@ -1027,9 +1052,8 @@ var BucketQueue = class {
 	}
 	/** Отклоняет ожидающие задачи; используется также при остановке всего направления. */
 	cancelWaiting(reason, notify = true) {
-		const pending = this.#waiting.splice(0, this.#waiting.length);
-		for (const task of pending) task.cancel(reason);
-		if (notify) this.#scheduler.timingChanged();
+		for (const task of this.#waiting.drain()) task.cancel(reason);
+		if (notify) this.#scheduler.changed();
 	}
 	/** Лимит бакета: сказанный сервером, иначе табличный. */
 	#capacity() {
@@ -1063,14 +1087,21 @@ var BucketQueue = class {
 	#hold(ms) {
 		if (ms <= 0) return;
 		this.#nextSlot = Math.max(this.#nextSlot, this.#clock.now() + ms);
-		this.#scheduler.timingChanged();
+		this.#scheduler.changed();
 	}
 };
-/** Лимит бакета до первого ответа: поправка пользователя важнее табличного значения. */
-function seedLimit(bucket, options) {
-	const override = options.bucketOverrides[bucket]?.limit;
-	if (override !== void 0) return override;
-	return options.bucketLimits[bucket];
+/** Совпадают ли начальные ограничения по всем трём полям. */
+function sameDefinition(left, right) {
+	return left?.limit === right?.limit && left?.concurrency === right?.concurrency && left?.rps === right?.rps;
+}
+/** Ограничения бакета для текста ошибки. */
+function describeDefinition(definition) {
+	const parts = [
+		definition?.limit === void 0 ? [] : [`limit ${definition.limit}`],
+		definition?.concurrency === void 0 ? [] : [`concurrency ${definition.concurrency}`],
+		definition?.rps === void 0 ? [] : [`rps ${definition.rps}`]
+	].flat();
+	return parts.length > 0 ? parts.join(", ") : "без ограничений";
 }
 /**
 * Очереди по парам «направление — серверный счётчик частоты».
@@ -1086,47 +1117,23 @@ var RequestQueuePool = class {
 	#clock;
 	/** Ключ `undefined` — основная очередь внутренних клиентов без известного направления. */
 	#destinations = /* @__PURE__ */ new Map();
-	/** Динамические определения feature вместе с числом использующих их клиентов. */
-	#featureBuckets = /* @__PURE__ */ new Map();
 	constructor(options, clock = systemClock) {
 		this.#options = options;
 		this.#clock = clock;
 	}
 	/**
-	* Регистрирует бакет подключаемого feature.
+	* Очередь бакета на направлении. При `buckets: false` бакет всегда `default`.
+	*
+	* Начальные ограничения приходят из каталога вызывающего клиента и запоминаются при
+	* создании очереди. Клиенты, разделяющие один пул через `ItdAccounts`, обязаны описывать
+	* бакет одинаково: расхождение обнаруживается при обращении к уже созданной очереди.
 	*
-	* Повтор той же декларации разрешён клиентам, разделяющим один pool через `ItdAccounts`.
-	* Возвращённая функция откатывает регистрацию, пока очередь бакета ещё не создана.
+	* @throws {ItdConfigError} если очередь бакета создана с другими ограничениями
 	*/
-	defineBucket(name, definition) {
-		const normalized = Object.freeze({
-			...definition.limit === void 0 ? {} : { limit: definition.limit },
-			...definition.concurrency === void 0 ? {} : { concurrency: definition.concurrency },
-			...definition.rps === void 0 ? {} : { rps: definition.rps }
-		});
-		const existing = this.#featureBuckets.get(name);
-		if (existing) {
-			if (existing.definition.limit !== normalized.limit || existing.definition.concurrency !== normalized.concurrency || existing.definition.rps !== normalized.rps) throw new 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) {
+	for(destination, bucket, definition) {
 		const fallback = this.#options.defaultBucket;
 		const name = this.#options.buckets ? bucket ?? fallback : fallback;
+		const limits = this.#options.buckets ? definition : void 0;
 		let entry = this.#destinations.get(destination);
 		if (!entry) {
 			entry = {
@@ -1137,9 +1144,9 @@ var RequestQueuePool = class {
 		}
 		let queue = entry.buckets.get(name);
 		if (!queue) {
-			queue = new BucketQueue(destination, name, entry.scheduler, this.#options, this.#clock, this.#featureBuckets.get(name)?.definition);
+			queue = new BucketQueue(destination, name, entry.scheduler, this.#options, this.#clock, limits);
 			entry.buckets.set(name, queue);
-		}
+		} else if (!sameDefinition(queue.definition, limits)) throw new ItdConfigError(`Бакет «${name}» уже используется с другими ограничениями: ${describeDefinition(queue.definition)} против ${describeDefinition(limits)}`);
 		return queue;
 	}
 	/** Снимки всех бакетов, о которых что-то известно. */
@@ -1159,7 +1166,6 @@ var RequestQueuePool = class {
 	clear() {
 		this.stop();
 		this.#destinations.clear();
-		this.#featureBuckets.clear();
 	}
 };
 //#endregion
@@ -1299,10 +1305,17 @@ async function dispatchRequestHook(hooks, field, context) {
 }
 //#endregion
 //#region src/core/execution/lifecycle.ts
-/** Объединяет отмену вызова, завершение клиента и общий таймаут логической операции. @internal */
-function createRequestAbortScope(signal, lifetimeSignal, timeout, clock) {
+/**
+* Объединяет отмену вызова, завершение владельца и срок ожидания в один сигнал.
+*
+* Истечение срока отменяет сигнал ошибкой из `expiry.error`; она же становится
+* `signal.reason`.
+*
+* @internal
+*/
+function createRequestAbortScope(signal, lifetimeSignal, clock, expiry) {
 	const controller = new AbortController();
-	let timeoutReached = false;
+	let expired;
 	const link = (source) => {
 		if (!source) return void 0;
 		if (source.aborted) {
@@ -1314,20 +1327,33 @@ function createRequestAbortScope(signal, lifetimeSignal, timeout, clock) {
 		return () => source.removeEventListener("abort", onAbort);
 	};
 	const detach = [link(signal), link(lifetimeSignal)];
-	const cancelTimer = timeout > 0 ? clock.schedule(() => {
-		timeoutReached = true;
-		controller.abort();
-	}, timeout) : void 0;
+	let cancelTimer = expiry && expiry.after > 0 ? clock.schedule(() => {
+		cancelTimer = void 0;
+		if (controller.signal.aborted) return;
+		expired = expiry.error();
+		controller.abort(expired);
+	}, expiry.after) : void 0;
+	const disarm = () => {
+		cancelTimer?.();
+		cancelTimer = void 0;
+	};
 	return {
 		signal: controller.signal,
-		timedOut: () => timeoutReached,
+		abort: (reason) => controller.abort(reason),
+		expired: () => expired,
+		disarm,
 		cleanup: () => {
-			cancelTimer?.();
+			disarm();
 			for (const remove of detach) remove?.();
 		}
 	};
 }
-/** Прерывает только ожидание; исходный промис может корректно завершить общую фоновую работу. @internal */
+/**
+* Прерывает только ожидание: исходный промис может корректно завершить фоновую работу,
+* а его позднее отклонение не станет необработанным.
+*
+* @internal
+*/
 function waitForRequest(promise, signal) {
 	if (signal.aborted) {
 		promise.catch(() => {});
@@ -1342,61 +1368,114 @@ function waitForRequest(promise, signal) {
 		if (onAbort) signal.removeEventListener("abort", onAbort);
 	});
 }
-/** Возвращает публичную ошибку, соответствующую причине остановки операции. @internal */
+/**
+* Возвращает публичную ошибку, соответствующую причине остановки ожидания.
+*
+* Истёкший срок отдаёт ошибку, созданную таймером области. Отмена с причиной-ошибкой
+* библиотеки (истёкший срок родительской области) отдаёт саму причину; прочая отмена
+* оборачивается в {@link ItdAbortError}.
+*
+* @internal
+*/
 function requestAbortError(scope, request, fallback) {
-	if (scope.timedOut()) return new ItdTimeoutError({
-		timeout: request.timeout,
-		method: request.method.toUpperCase(),
-		path: request.path
-	});
-	if (scope.signal.aborted && !(fallback instanceof ItdAbortError)) return new ItdAbortError(`Запрос ${request.method.toUpperCase()} ${request.path} отменён`, { cause: scope.signal.reason });
-	return fallback;
+	const expired = scope.expired();
+	if (expired) return expired;
+	if (!scope.signal.aborted) return fallback;
+	const reason = scope.signal.reason;
+	if (reason instanceof ItdTimeoutError) return reason;
+	if (fallback instanceof ItdAbortError) return fallback;
+	return new ItdAbortError(`Запрос ${request.method.toUpperCase()} ${request.path} отменён`, { cause: reason });
 }
 //#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 REQUEST_AUTH_RECOVERY_STATE = Symbol("itd-api.request-auth-recovery-state");
-const REQUEST_ERROR_OBSERVATION_STATE = Symbol("itd-api.request-error-observation-state");
-const DISPOSE_CLEANUP_REQUEST = Symbol("itd-api.dispose-cleanup-request");
+const OPERATION_STATE = Symbol("itd-api.operation-state");
+function operationState(request) {
+	const internal = request;
+	let state = internal[OPERATION_STATE];
+	if (!state) {
+		state = {};
+		internal[OPERATION_STATE] = state;
+	}
+	return state;
+}
+/**
+* Начинает новую логическую операцию со свежим служебным состоянием.
+*
+* Контейнер заменяется безусловно: пользовательский код мог передать spread-копию запроса,
+* уже прошедшего через pipeline. Такое повторное обращение является новой операцией и не
+* должно наследовать её попытки, очередь, auth recovery, reader или учёт `onError`.
+*
+* @internal
+*/
+function initializeOperationState(request, initial) {
+	const state = {
+		lifecycleSignal: initial.lifecycleSignal,
+		...initial.reader === void 0 ? {} : { reader: initial.reader },
+		...initial.disposeCleanup ? { disposeCleanup: true } : {}
+	};
+	return {
+		...request,
+		[OPERATION_STATE]: state
+	};
+}
+/** Функция чтения контракта операции, если запрос её несёт. @internal */
+function operationReaderOf(request) {
+	return request[OPERATION_STATE]?.reader;
+}
+/** Переносит служебное состояние логической операции на новый объект запроса. @internal */
+function withOperationState(prepared, source) {
+	const from = source;
+	const to = prepared;
+	to[OPERATION_STATE] = from[OPERATION_STATE] ?? {};
+	return prepared;
+}
+/** Общий сигнал операции, сохранённый {@link initializeOperationState}. @internal */
+function lifecycleSignalOf(request) {
+	return request[OPERATION_STATE]?.lifecycleSignal;
+}
 /** Возвращает общее для всех retry состояние восстановления авторизации. @internal */
 function requestAuthRecoveryState(request) {
-	const internal = request;
-	const current = internal[REQUEST_AUTH_RECOVERY_STATE];
+	const state = operationState(request);
+	const current = state.authRecovery;
 	if (current) return current;
-	const state = {
+	const recovery = {
 		recovered: false,
 		preparationErrors: /* @__PURE__ */ new Set()
 	};
-	internal[REQUEST_AUTH_RECOVERY_STATE] = state;
-	return state;
+	state.authRecovery = recovery;
+	return recovery;
 }
-/** Создаёт общую для копий логического запроса отметку вызова `onError`. @internal */
-function trackRequestErrorObservation(request) {
-	const internal = request;
-	internal[REQUEST_ERROR_OBSERVATION_STATE] ??= {
+/** Создаёт общий для копий логического запроса учёт вызовов `onError`. @internal */
+function trackRequestErrorReporting(request) {
+	const state = operationState(request);
+	state.errorReporting ??= {
 		errors: /* @__PURE__ */ new Set(),
-		lifecycleAbortedDuringNotification: false
+		abortReported: false
 	};
 }
+function errorReportingState(request) {
+	trackRequestErrorReporting(request);
+	return operationState(request).errorReporting;
+}
 /** Отмечает, что ошибка логического запроса уже была передана в `onError`. @internal */
-function markRequestErrorObserved(request, error) {
-	trackRequestErrorObservation(request);
-	request[REQUEST_ERROR_OBSERVATION_STATE]?.errors.add(error);
+function markRequestErrorReported(request, error) {
+	errorReportingState(request).errors.add(error);
 }
 /** Была ли конкретная ошибка этой логической операции уже передана в `onError`. @internal */
-function wasRequestErrorObserved(request, error) {
-	return request[REQUEST_ERROR_OBSERVATION_STATE]?.errors.has(error) ?? false;
-}
-/** Отмечает отмену lifecycle во время уже начатого локального `onError`. @internal */
-function markRequestErrorNotificationAborted(request) {
-	trackRequestErrorObservation(request);
-	const state = request[REQUEST_ERROR_OBSERVATION_STATE];
-	if (state) state.lifecycleAbortedDuringNotification = true;
+function wasRequestErrorReported(request, error) {
+	return request[OPERATION_STATE]?.errorReporting?.errors.has(error) ?? false;
 }
-/** Нужно ли верхней границе не запускать тот же `onError` повторно после отмены. @internal */
-function wasRequestErrorNotificationAborted(request) {
-	return request[REQUEST_ERROR_OBSERVATION_STATE]?.lifecycleAbortedDuringNotification ?? false;
+/**
+* Отмечает, что отмена операции передана в `onError`.
+*
+* @returns `false`, если это уже сделал другой уровень — повторно вызывать хук не нужно
+* @internal
+*/
+function claimAbortReport(request) {
+	const state = errorReportingState(request);
+	if (state.abortReported) return false;
+	state.abortReported = true;
+	return true;
 }
 /** Один раз присваивает низкоуровневому запросу семантический ID до входа в middleware. */
 function identifyRequest(request) {
@@ -1405,56 +1484,40 @@ function identifyRequest(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;
+	const state = operationState(request);
+	state.attempt = (state.attempt ?? 0) + 1;
 	return {
-		...tracked,
-		attempt: state.value
+		...request,
+		attempt: state.attempt
 	};
 }
 /** Возвращает номер последней начатой транспортной попытки. @internal */
 function currentTransportAttempt(request) {
-	return request[REQUEST_ATTEMPT_STATE]?.value ?? 0;
+	return request[OPERATION_STATE]?.attempt ?? 0;
 }
 /**
 * Вычисляет ключ очереди один раз на логическую операцию.
 *
 * Ключ спрашивают трижды: при постановке в очередь, при чтении заголовков ответа и при
-* паузе после `429`. Значение пишется прямо в объект запроса — слои ниже копируют его
-* через spread, и перечислимое символьное поле переходит в копии.
+* паузе после `429`. Значение хранится в общем состоянии операции, поэтому его видят все
+* копии запроса ниже по конвейеру. Ограничения бакета фиксируются вместе с ключом:
+* освобождение feature во время запроса не меняет очередь операции.
 *
 * @internal
 */
 function requestQueueKey(request, compute) {
-	const internal = request;
-	const cached = internal[REQUEST_QUEUE_KEY];
+	const state = operationState(request);
+	const cached = state.queueKey;
 	if (cached) return cached;
 	const key = compute(request);
-	internal[REQUEST_QUEUE_KEY] = key;
+	state.queueKey = key;
 	return key;
 }
-/** Помечает запрос как часть внутренней финализации уже начатого `dispose()`. @internal */
-function markDisposeCleanupRequest(request) {
-	return {
-		...request,
-		[DISPOSE_CLEANUP_REQUEST]: true
-	};
-}
 /** Разрешено ли запросу завершать внутреннюю очистку после `dispose()`. @internal */
 function isDisposeCleanupRequest(request) {
-	return request[DISPOSE_CLEANUP_REQUEST] === true;
+	return request[OPERATION_STATE]?.disposeCleanup === true;
 }
 /**
 * Собирает слои в один обработчик.
@@ -1484,129 +1547,143 @@ function withLayerHeaders(request, headers) {
 }
 //#endregion
 //#region src/core/execution/http.ts
+/** Собирает запрос конвейера из контракта операции и параметров вызова. */
+function operationRequest(operation, options) {
+	return {
+		...options,
+		operationId: operation.id,
+		method: operation.method,
+		retrySafety: options.retrySafety ?? operation.retrySafety
+	};
+}
 /**
 * Точка входа ресурсов в конвейер запросов.
 *
-* Принимает готовую цепочку обработки и предоставляет ресурсам методы `request`/`execute`.
-* О слоях и их порядке ресурсы не знают.
+* Заводит общий lifecycle логической операции — отмену, освобождение клиента и `deadline`, —
+* передаёт запрос собранной цепочке стадий и сообщает в `onError` об ошибках, которые
+* не дошли до транспорта. О стадиях и их порядке ресурсы не знают.
 */
 var HttpClient = class {
 	#handler;
-	#plugins;
 	#baseUrl;
-	#timeout;
+	#deadline;
 	#clock;
 	#lifetimeSignal;
 	#hooks;
 	#assertActive;
+	#activeScopes = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.#handler = deps.handler;
-		this.#plugins = deps.plugins;
 		this.#baseUrl = deps.baseUrl;
-		this.#timeout = deps.timeout;
+		this.#deadline = deps.deadline;
 		this.#clock = deps.clock;
 		this.#lifetimeSignal = deps.lifetimeSignal;
 		this.#hooks = deps.hooks;
 		this.#assertActive = deps.assertActive;
-	}
-	/** Базовый URL, к которому обращается клиент. */
-	get baseUrl() {
-		return this.#baseUrl;
+		if (this.#lifetimeSignal && !this.#lifetimeSignal.aborted) this.#lifetimeSignal.addEventListener("abort", () => {
+			for (const scope of this.#activeScopes) scope.abort(this.#lifetimeSignal?.reason);
+		}, { once: true });
 	}
 	/**
-	* Выполняет запрос к API через собранный конвейер.
+	* Выполняет низкоуровневый запрос через собранный конвейер.
 	*
 	* @typeParam T ожидаемая форма ответа после снятия обёртки `{ data: … }`
 	* @throws {ItdApiError} если сервер ответил статусом ≥ 400
-	* @throws {ItdTimeoutError} если истёк таймаут
+	* @throws {ItdTimeoutError} если истёк `timeout` попытки или `deadline` операции
 	* @throws {ItdAbortError} если запрос отменён через `signal`
 	* @throws {ItdNetworkError} если запрос не дошёл до сервера
 	*/
 	request(options) {
-		const request = identifyRequest(options);
-		return this.#runWithLifecycle(request, (prepared) => this.#handler(prepared));
+		return this.#run(identifyRequest(options));
 	}
 	/** Выполняет контракт операции; `next()` плагина возвращает результат после `read`. */
 	execute(operation, options) {
-		return this.#run(operation, options);
-	}
-	#run(operation, options) {
-		const request = identifyRequest({
-			...options,
-			operationId: operation.id,
-			method: operation.method,
-			retrySafety: options.retrySafety ?? operation.retrySafety
-		});
-		return this.#runWithLifecycle(request, async (prepared) => operation.read(await this.#handler(prepared), prepared));
+		return this.#run(operationRequest(operation, options), { reader: operation.read });
 	}
 	/** Выполняет внутреннюю операцию финализации после начала `ItdClient.dispose()`. @internal */
 	cleanupOperation(operation, options) {
-		const request = identifyRequest({
-			...options,
-			operationId: operation.id,
-			method: operation.method,
-			retrySafety: options.retrySafety ?? operation.retrySafety
+		return this.#run(operationRequest(operation, options), {
+			allowDisposed: true,
+			reader: operation.read,
+			disposeCleanup: true
 		});
-		return this.#runWithLifecycle(request, async (prepared) => {
-			const cleanupRequest = markDisposeCleanupRequest(prepared);
-			return operation.read(await this.#handler(cleanupRequest), prepared);
-		}, true);
 	}
-	async #runWithLifecycle(request, execute, allowDisposed = false) {
-		if (!allowDisposed) this.#assertActive?.();
-		const timeout = request.timeout ?? this.#timeout;
-		const scope = createRequestAbortScope(request.signal, this.#lifetimeSignal, timeout, this.#clock);
+	async #run(request, options = {}) {
+		if (!options.allowDisposed) this.#assertActive?.();
+		const deadline = request.deadline ?? this.#deadline;
+		const scope = createRequestAbortScope(request.signal, void 0, this.#clock, {
+			after: deadline,
+			error: () => new ItdTimeoutError({
+				timeout: deadline,
+				method: request.method.toUpperCase(),
+				path: request.path,
+				budget: TimeoutBudget.Deadline
+			})
+		});
+		if (this.#lifetimeSignal?.aborted) scope.abort(this.#lifetimeSignal.reason);
+		else this.#activeScopes.add(scope);
 		const startedAt = this.#clock.now();
-		trackRequestErrorObservation(request);
+		const tracked = initializeOperationState(request, {
+			lifecycleSignal: scope.signal,
+			reader: options.reader,
+			disposeCleanup: options.disposeCleanup
+		});
 		try {
-			const pending = this.#plugins.run(request, (prepared) => execute({
-				...prepared,
-				signal: scope.signal,
-				timeout: 0
-			}), scope.signal);
-			return await waitForRequest(Promise.resolve(pending), scope.signal);
+			return await waitForRequest(this.#handler(tracked), scope.signal);
 		} catch (error) {
-			const failure = requestAbortError(scope, {
-				timeout,
-				method: request.method,
-				path: request.path
-			}, error);
-			if (!(wasRequestErrorObserved(request, error) || scope.signal.aborted && wasRequestErrorNotificationAborted(request))) {
-				markRequestErrorObserved(request, error);
-				let headers;
-				try {
-					headers = new Headers({
-						...request.layerHeaders,
-						...request.headers
-					});
-				} catch {
-					headers = new Headers();
-				}
-				const notification = dispatchRequestHook(this.#hooks, "onError", {
-					operationId: request.operationId,
-					signal: scope.signal,
-					method: request.method.toUpperCase(),
-					path: request.path,
-					url: joinUrl(request.baseUrl ?? this.#baseUrl, request.path) + buildQuery(request.query),
-					headers,
-					attempt: request.attempt ?? 1,
-					duration: this.#clock.now() - startedAt,
-					error: failure
-				});
-				try {
-					await waitForRequest(notification, scope.signal);
-				} catch (hookError) {
-					if (!scope.signal.aborted) throw hookError;
+			const failure = requestAbortError(scope, request, error);
+			if (hasRequestHook(this.#hooks, "onError")) {
+				if (!(wasRequestErrorReported(tracked, error) || wasRequestErrorReported(tracked, failure) || scope.signal.aborted && !claimAbortReport(tracked))) {
+					markRequestErrorReported(tracked, error);
+					markRequestErrorReported(tracked, failure);
+					await this.#notifyError(tracked, scope.signal, startedAt, failure);
 				}
 			}
 			throw failure;
 		} finally {
+			this.#activeScopes.delete(scope);
 			scope.cleanup();
 		}
 	}
+	/** Сообщает об ошибке, которую транспорт не видел: очередь, авторизация, плагины, отмена. */
+	async #notifyError(request, signal, startedAt, error) {
+		let headers;
+		try {
+			headers = new Headers({
+				...request.layerHeaders,
+				...request.headers
+			});
+		} catch {
+			headers = new Headers();
+		}
+		const notification = dispatchRequestHook(this.#hooks, "onError", {
+			operationId: request.operationId,
+			signal,
+			method: request.method.toUpperCase(),
+			path: request.path,
+			url: joinUrl(request.baseUrl ?? this.#baseUrl, request.path) + buildQuery(request.query),
+			headers,
+			attempt: currentTransportAttempt(request) || 1,
+			duration: this.#clock.now() - startedAt,
+			error
+		});
+		try {
+			await waitForRequest(notification, signal);
+		} catch (hookError) {
+			if (!signal.aborted) throw hookError;
+		}
+	}
 };
 //#endregion
 //#region src/core/operation.ts
+/** HTTP-метод операции. */
+const OperationMethod = Object.freeze({
+	Get: "GET",
+	Post: "POST",
+	Put: "PUT",
+	Patch: "PATCH",
+	Delete: "DELETE"
+});
 /** Семантическая безопасность автоматического повтора операции. */
 const RetrySafety = Object.freeze({
 	/** Автоматический повтор не создаёт неприемлемого эффекта; обычно это чтение. */
@@ -1676,7 +1753,7 @@ function isRequestBodyReplayable(request) {
 /** Разрешает retrySafety запроса из явного override, каталога либо raw fallback. */
 function resolveRetryPolicy(request, catalog) {
 	let retrySafety;
-	const known = catalog.retrySafetyOf(request.operationId);
+	const known = catalog.definitionOf(request.operationId)?.retrySafety;
 	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;
@@ -1690,15 +1767,22 @@ function resolveRetryPolicy(request, catalog) {
 	};
 }
 /**
+* Ошибка, после которой повтор невозможен в принципе: отмена либо истёкший общий срок операции.
+* Таймаут отдельной попытки сюда не входит — он повторяется как сетевой сбой.
+*/
+function isTerminal(error) {
+	return error instanceof ItdAbortError || error instanceof ItdTimeoutError && error.budget === TimeoutBudget.Deadline;
+}
+/**
 * Стоит ли повторять запрос после этой ошибки.
 *
 * `429` гарантирует, что операция не была обработана, поэтому допускает даже unsafe retry.
-* Обрыв сети, timeout и `5xx` такой гарантии не дают и требуют safe/idempotent операции.
+* Обрыв сети, таймаут попытки и `5xx` такой гарантии не дают и требуют safe/idempotent операции.
 * Ошибка подготовки файла возникает до обращения к серверу и потому зависит только от
 * собственного признака retryable и повторяемости тела.
 */
 function isRetryable(error, policy) {
-	if (error instanceof ItdAbortError || !policy.bodyReplayable) return false;
+	if (isTerminal(error) || !policy.bodyReplayable) return false;
 	const repeatableOperation = policy.retrySafety === RetrySafety.Safe || policy.retrySafety === RetrySafety.Idempotent;
 	if (error instanceof ItdApiError) {
 		if (error.status === 429) return true;
@@ -1726,7 +1810,7 @@ function backoffDelay(retryAttempt, options, random) {
 function createRetryScheduler(options, random = Math.random) {
 	return (error, retryAttempt, policy) => {
 		if (retryAttempt >= options.attempts) return void 0;
-		if (error instanceof ItdAbortError || !policy.bodyReplayable) return void 0;
+		if (isTerminal(error) || !policy.bodyReplayable) return void 0;
 		if (options.shouldRetry) return options.shouldRetry(error, retryAttempt, policy) ? backoffDelay(retryAttempt, options, random) : void 0;
 		if (!isRetryable(error, policy)) return void 0;
 		if (error instanceof ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
@@ -1735,6 +1819,8 @@ function createRetryScheduler(options, random = Math.random) {
 }
 //#endregion
 //#region src/core/execution/middleware.ts
+/** Сигнал для запроса без lifecycle: никогда не срабатывает. */
+const IDLE_SIGNAL = new AbortController().signal;
 /** Ожидание повтора, которое уважает отмену запроса. */
 function sleep(clock, ms, signal) {
 	if (!signal) return new Promise((resolve) => clock.schedule(resolve, ms));
@@ -1752,6 +1838,39 @@ function sleep(clock, ms, signal) {
 	});
 }
 /**
+* Слой плагинов: обёртки логической операции.
+*
+* Transformer видит запрос и результат по одному разу, независимо от повторов и обновления
+* авторизации, и получает запрос с пользовательским `signal`; слои ниже — с общим сигналом
+* операции. Служебное состояние операции переносится на запрос, собранный обёрткой заново.
+* Здесь же к операции привязывается снимок attempt interceptors; сами они выполняются
+* транспортом на каждой попытке.
+*/
+function createPluginsMiddleware(plugins) {
+	return (request, next) => {
+		const lifecycle = lifecycleSignalOf(request) ?? request.signal;
+		return plugins.run(request, (prepared) => {
+			return next(withOperationState({
+				...prepared,
+				...lifecycle ? { signal: lifecycle } : {}
+			}, request));
+		}, lifecycle ?? IDLE_SIGNAL);
+	};
+}
+/**
+* Слой контракта операции: превращает разобранное тело ответа в публичный результат.
+*
+* Обёртки операции получают готовый результат метода, а не форму ответа сервера. У
+* `raw`-запроса функции чтения нет, тело возвращается как есть.
+*/
+function createDecodeMiddleware() {
+	return async (request, next) => {
+		const body = await next(request);
+		const read = operationReaderOf(request);
+		return read ? read(body, request) : body;
+	};
+}
+/**
 * Слой очереди: ограничение конкурентности и частоты.
 *
 * Должен стоять непосредственно вокруг одной транспортной попытки: тогда ожидание retry
@@ -1763,13 +1882,6 @@ function createQueueMiddleware(schedule) {
 	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
 }
 /**
-* Слой плагинов.
-*
-* Стоит снаружи повторов и очереди: operation transformers видят запрос и ответ по одному
-* разу, иначе, например, текст поста зашифруется дважды. Здесь же к операции привязывается
-* snapshot attempt interceptors; сами они выполняются транспортом на каждой попытке.
-*/
-/**
 * Слой сервисов.
 *
 * Запросу с полем `service` подставляет хост сервиса, его заголовки и `skipAuth`, если
@@ -1807,15 +1919,16 @@ function createServicesMiddleware(registry) {
 }
 /** Однократная auth-подготовка вне retry исходного запроса. */
 function createAuthPreflightMiddleware(getAuth) {
-	return async (request, next) => {
-		if (!request.skipAuth) {
-			const auth = getAuth();
-			if (auth.preflight) {
-				const pending = auth.preflight(request.skipAuthRefresh !== true);
-				await (request.signal ? waitForRequest(pending, request.signal) : pending);
-			}
-		}
-		return next(request);
+	return (request, next) => {
+		if (request.skipAuth) return next(request);
+		const auth = getAuth();
+		const preflight = auth.preflight;
+		if (!preflight) return next(request);
+		return (async () => {
+			const pending = preflight.call(auth, request.skipAuthRefresh !== true);
+			await (request.signal ? waitForRequest(pending, request.signal) : pending);
+			return next(request);
+		})();
 	};
 }
 /**
@@ -1824,18 +1937,22 @@ function createAuthPreflightMiddleware(getAuth) {
 * Загрузка storage, внешний `getToken` и ленивый sign-in могут быть асинхронными; sign-in
 * сам входит в ту же queue. Поэтому эти действия обязаны завершиться до захвата её слота.
 */
-function createAuthPreparationMiddleware(auth) {
-	return async (request, next) => {
-		if (!request.skipAuth) {
-			const pending = auth.prepare();
+function createAuthPreparationMiddleware(getAuth) {
+	return (request, next) => {
+		if (request.skipAuth) return next(request);
+		const auth = getAuth();
+		const prepare = auth.prepare;
+		if (!prepare) return next(request);
+		return (async () => {
 			try {
+				const pending = prepare.call(auth);
 				await (request.signal ? waitForRequest(pending, request.signal) : pending);
 			} catch (error) {
 				requestAuthRecoveryState(request).preparationErrors.add(error);
 				throw error;
 			}
-		}
-		return next(request);
+			return next(request);
+		})();
 	};
 }
 /**
@@ -1869,10 +1986,10 @@ function createAttemptMiddleware() {
 */
 function createAuthRecoveryMiddleware(auth) {
 	return async (request, next) => {
-		const recovery = requestAuthRecoveryState(request);
 		try {
 			return await next(request);
 		} catch (error) {
+			const recovery = requestAuthRecoveryState(request);
 			const preparationFailed = recovery.preparationErrors.delete(error);
 			if (request.skipAuthRefresh || recovery.recovered || preparationFailed || !isItdApiError(error) || error.status !== 401) throw error;
 			const pending = auth.recover();
@@ -1901,55 +2018,62 @@ function resolveBackoff(retry, global) {
 * Слой повторов.
 *
 * Ответ `429` обрабатывается отдельно от прочих ошибок лестницей пауз и с придержанием
-* всей очереди; сетевые сбои и `5xx` — экспоненциальным откатом. Настройка `retry`
-* у отдельного запроса имеет приоритет над глобальной.
+* всей очереди; сетевые сбои, таймаут попытки и `5xx` — экспоненциальным откатом.
+* Настройка `retry` у отдельного запроса имеет приоритет над глобальной.
 */
 function createRetryMiddleware(deps) {
 	const globalScheduler = deps.retry ? createRetryScheduler(deps.retry) : void 0;
-	const nextDelay = (error, retryAttempt, rateLimitAttempt, request, policy, backoff) => {
-		if (isItdRateLimitError(error)) {
-			if (!policy.bodyReplayable) return void 0;
-			const wait = error.retryAfter ?? deps.rateLimitDelays[rateLimitAttempt - 1];
-			if (wait === void 0) return void 0;
-			deps.pauseQueue?.(wait, request);
-			deps.logger?.debug(`лимит частоты, повтор ${rateLimitAttempt} через ${wait} мс`);
-			return wait;
-		}
-		return backoff?.(error, retryAttempt, policy);
+	const ladder = deps.rateLimitDelays;
+	const ladderCeiling = ladder && ladder.length > 0 ? Math.max(...ladder) : 0;
+	/** Пауза по лестнице `429`; `undefined` — лестница пройдена или пауза сервера слишком велика. */
+	const ladderDelay = (error, rateLimitAttempt, request, policy) => {
+		if (!ladder || !policy.bodyReplayable || rateLimitAttempt > ladder.length) return void 0;
+		if (error.retryAfter !== void 0 && error.retryAfter > ladderCeiling) return void 0;
+		const wait = error.retryAfter ?? ladder[rateLimitAttempt - 1];
+		if (wait === void 0) return void 0;
+		deps.pauseQueue?.(wait, request);
+		deps.logger?.info(`лимит частоты ${request.method.toUpperCase()} ${request.path}, повтор ${rateLimitAttempt} через ${wait} мс`);
+		return wait;
 	};
-	return async (request, next) => {
-		const trackedRequest = trackRequestAttempts(request);
+	return (request, next) => {
+		const backoff = resolveBackoff(request.retry, globalScheduler);
+		if (!backoff && (!ladder || ladder.length === 0)) return next(request);
 		const method = request.method.toUpperCase();
 		const policy = resolveRetryPolicy(request, deps.catalog);
-		const backoff = resolveBackoff(request.retry, globalScheduler);
-		let retryAttempt = 0;
-		let rateLimitAttempt = 0;
-		for (;;) try {
-			return await next(trackedRequest);
-		} catch (error) {
-			const transportAttempt = currentTransportAttempt(trackedRequest);
-			if (isItdRateLimitError(error)) rateLimitAttempt += 1;
-			else retryAttempt += 1;
-			const delay = nextDelay(error, retryAttempt, rateLimitAttempt, trackedRequest, policy, backoff);
-			if (delay === void 0) throw error;
-			const notification = dispatchRequestHook(deps.hooks, "onRetry", {
-				operationId: request.operationId,
-				signal: request.signal,
-				method,
-				path: request.path,
-				url: deps.buildUrl(request),
-				headers: new Headers({
-					...request.layerHeaders,
-					...request.headers
-				}),
-				attempt: transportAttempt,
-				error,
-				delay
-			});
-			await (request.signal ? waitForRequest(notification, request.signal) : notification);
-			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${transportAttempt + 1} через ${delay} мс`);
-			await sleep(deps.clock ?? systemClock, delay, request.signal);
-		}
+		return (async () => {
+			let retryAttempt = 0;
+			let rateLimitAttempt = 0;
+			for (;;) try {
+				return await next(request);
+			} catch (error) {
+				if (request.signal?.aborted) throw error;
+				const transportAttempt = currentTransportAttempt(request);
+				const rateLimited = ladder !== void 0 && isItdRateLimitError(error);
+				if (rateLimited) rateLimitAttempt += 1;
+				else retryAttempt += 1;
+				const delay = rateLimited ? ladderDelay(error, rateLimitAttempt, request, policy) : backoff?.(error, retryAttempt, policy);
+				if (delay === void 0) throw error;
+				if (hasRequestHook(deps.hooks, "onRetry")) {
+					const notification = dispatchRequestHook(deps.hooks, "onRetry", {
+						operationId: request.operationId,
+						signal: request.signal,
+						method,
+						path: request.path,
+						url: deps.buildUrl(request),
+						headers: new Headers({
+							...request.layerHeaders,
+							...request.headers
+						}),
+						attempt: transportAttempt,
+						error,
+						delay
+					});
+					await (request.signal ? waitForRequest(notification, request.signal) : notification);
+				}
+				deps.logger?.info(`повтор ${method} ${request.path}, попытка ${transportAttempt + 1} через ${delay} мс`);
+				await sleep(deps.clock ?? systemClock, delay, request.signal);
+			}
+		})();
 	};
 }
 //#endregion
@@ -1979,15 +2103,6 @@ function unwrapData(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;
@@ -2031,6 +2146,13 @@ function pickString(source, field) {
 //#endregion
 //#region src/core/error-factory.ts
 /**
+* Отличает строковый машинный код (`NOT_FOUND`) от обычного текста и HTML страницы прокси.
+* Ограничение длины не даёт случайно принять большое служебное тело за код ошибки.
+*/
+function readPlainTextErrorCode(value) {
+	return value.length <= 128 && /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/.test(value) ? value : void 0;
+}
+/**
 * Сводит ошибки по полям к единой форме `{ поле: [сообщения] }`.
 *
 * Понимает две документированные формы:
@@ -2070,14 +2192,17 @@ function collectFieldErrors(source) {
 */
 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 (typeof body === "string") {
+		const message = asString(body.trim()) ?? fallbackMessage;
+		return {
+			code: readPlainTextErrorCode(message) ?? "UNKNOWN_ERROR",
+			message,
+			detail: void 0,
+			title: void 0,
+			fieldErrors: {},
+			userId: void 0
+		};
+	}
 	if (!isRecord(body)) return {
 		code: "UNKNOWN_ERROR",
 		message: fallbackMessage,
@@ -2271,33 +2396,15 @@ async function readBody(response) {
 	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);
-	});
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 /**
 * Единственное место, откуда библиотека ходит в сеть.
 *
-* Отвечает за сборку URL, заголовки, cookie, таймауты, разбор ответа и превращение любой
-* неудачи в типизированную ошибку. Авторизация, повторы, очередь и плагины — отдельные
-* слои конвейера, и транспорт о них не знает.
+* Отвечает за сборку URL, заголовки, cookie, срок одной попытки, разбор ответа и превращение
+* любой неудачи в типизированную ошибку. Авторизация, повторы, очередь и плагины — отдельные
+* стадии конвейера, и транспорт о них не знает.
 */
 var Transport = class {
 	#config;
@@ -2306,141 +2413,114 @@ var Transport = class {
 		this.#config = config;
 		this.#deps = deps;
 	}
-	/** Базовый URL, к которому обращается транспорт. */
-	get baseUrl() {
-		return this.#config.baseUrl;
-	}
 	/**
 	* Выполняет один сетевой запрос.
 	*
 	* @throws {ItdApiError} если сервер ответил статусом ≥ 400
-	* @throws {ItdTimeoutError} если истёк таймаут
+	* @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 attempt = request.attempt ?? 1;
 		const timeout = request.timeout ?? this.#config.timeout;
-		const abort = createRequestAbortScope(request.signal, this.#deps.lifetimeSignal, timeout, this.#config.clock);
-		const startedAt = this.#config.clock.now();
+		const method = request.method.toUpperCase();
+		const attempt = {
+			request,
+			method,
+			url: this.buildUrl(request),
+			abort: createRequestAbortScope(request.signal, void 0, this.#config.clock, {
+				after: timeout,
+				error: () => new ItdTimeoutError({
+					timeout,
+					method,
+					path: request.path,
+					budget: TimeoutBudget.Attempt
+				})
+			}),
+			startedAt: this.#config.clock.now(),
+			number: request.attempt ?? 1
+		};
+		const { signal } = attempt.abort;
 		let cleanupBody;
 		try {
-			const headers = await abortable(this.#buildHeaders(request, url), abort.signal).catch((error) => {
-				throw this.#toTransportError(error, abort, request, method, timeout);
-			});
+			let headers;
+			try {
+				headers = await waitForRequest(this.#buildHeaders(request, attempt.url), signal);
+			} catch (error) {
+				throw this.#toTransportError(attempt, error);
+			}
 			let body;
 			try {
-				const prepared = await this.#prepareBody(request, headers, abort.signal, attempt);
+				const prepared = await this.#prepareBody(attempt, headers);
 				body = prepared.body;
 				cleanupBody = prepared.cleanup;
 			} catch (error) {
-				const failure = abort.signal.aborted || error instanceof ItdError ? this.#toTransportError(error, abort, request, method, timeout) : new ItdConfigError(`Не удалось подготовить тело ${method} ${request.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-				const context = {
-					operationId: request.operationId,
-					signal: abort.signal,
-					method,
-					path: request.path,
-					url,
-					headers,
-					attempt
-				};
-				await this.#dispatchErrorHook(request, {
-					...context,
-					duration: this.#config.clock.now() - startedAt,
-					error: failure
-				}, abort, timeout);
+				const failure = signal.aborted || error instanceof ItdError ? this.#toTransportError(attempt, error) : new ItdConfigError(`Не удалось подготовить тело ${attempt.method} ${request.path}: ${describe(error)}`, { cause: error });
+				await this.#report(attempt, headers, failure);
 				throw failure;
 			}
-			const context = {
-				operationId: request.operationId,
-				signal: abort.signal,
-				method,
-				path: request.path,
-				url,
-				headers,
-				attempt
-			};
-			try {
-				await abortable(dispatchRequestHook(this.#config.hooks, "onRequest", context), abort.signal);
+			let context;
+			const contextOf = () => context ??= this.#context(attempt, headers);
+			if (hasRequestHook(this.#config.hooks, "onRequest")) try {
+				await waitForRequest(dispatchRequestHook(this.#config.hooks, "onRequest", { ...contextOf() }), signal);
 			} catch (error) {
-				const failure = abort.signal.aborted ? this.#toTransportError(error, abort, request, method, timeout) : error;
-				await this.#dispatchErrorHook(request, {
-					...context,
-					duration: this.#config.clock.now() - startedAt,
-					error: failure
-				}, abort, timeout);
+				const failure = this.#abortedOr(attempt, error);
+				await this.#report(attempt, headers, failure);
 				throw failure;
 			}
-			this.#config.logger?.debug(`→ ${method} ${request.path}`, {
+			const logger = this.#config.logger;
+			if (logger && isLevelEnabled(logger, LogLevel.Debug)) logger.debug(`→ ${attempt.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);
-					}
-				});
+				response = await waitForRequest(this.#fetch(attempt, headers, body, contextOf), signal);
 			} catch (error) {
-				const duration = this.#config.clock.now() - startedAt;
-				await this.#dispatchErrorHook(request, {
-					...context,
-					duration,
-					error
-				}, abort, timeout);
-				this.#config.logger?.warn(`× ${method} ${request.path} (${duration} мс): ${error instanceof Error ? error.message : String(error)}`);
-				throw error;
+				const failure = this.#abortedOr(attempt, error);
+				await this.#report(attempt, headers, failure);
+				this.#config.logger?.warn(`× ${attempt.method} ${request.path} (${this.#elapsed(attempt)} мс): ${describe(failure)}`);
+				throw failure;
 			}
 			if (this.#deps.onRateLimit) {
 				const { limit, remaining } = readRateLimit(response.headers);
 				this.#deps.onRateLimit(limit, remaining, request);
 			}
-			if (this.#config.useCookieJar) (request.cookieJar ?? this.#deps.cookies)?.setFromResponse(response.url || url, response);
+			if (this.#config.useCookieJar) (request.cookieJar ?? this.#deps.cookies)?.setFromResponse(response.url || attempt.url, response);
 			if (response.ok && hasRequestHook(this.#config.hooks, "onResponse")) {
 				const hookResponse = response.clone();
 				try {
-					await abortable(dispatchRequestHook(this.#config.hooks, "onResponse", {
-						...context,
+					await waitForRequest(dispatchRequestHook(this.#config.hooks, "onResponse", {
+						...contextOf(),
 						status: response.status,
-						duration: this.#config.clock.now() - startedAt,
+						duration: this.#elapsed(attempt),
 						response: hookResponse
-					}), abort.signal);
+					}), signal);
 				} catch (error) {
 					response.body?.cancel().catch(() => {});
-					const failure = abort.signal.aborted ? this.#toTransportError(error, abort, request, method, timeout) : error;
-					await this.#dispatchErrorHook(request, {
-						...context,
-						duration: this.#config.clock.now() - startedAt,
-						error: failure
-					}, abort, timeout);
+					const failure = this.#abortedOr(attempt, error);
+					await this.#report(attempt, headers, failure);
 					throw failure;
 				} finally {
 					if (!hookResponse.bodyUsed) hookResponse.body?.cancel().catch(() => {});
 				}
 			}
-			const payload = await this.#readBodyOrFail(response, context, request, method, abort, timeout, startedAt);
-			const duration = this.#config.clock.now() - startedAt;
+			let payload;
+			try {
+				payload = await waitForRequest(readBody(response), signal);
+				attempt.abort.disarm();
+			} catch (error) {
+				await response.body?.cancel().catch(() => {});
+				const failure = this.#toTransportError(attempt, error);
+				await this.#report(attempt, headers, failure);
+				this.#config.logger?.warn(`× ${attempt.method} ${request.path}: не удалось прочитать тело ответа — ${failure.message}`);
+				throw failure;
+			}
+			const duration = this.#elapsed(attempt);
 			if (!response.ok) {
 				const error = createApiError({
-					method,
+					method: attempt.method,
 					path: request.path,
 					status: response.status,
 					now: this.#config.clock.now(),
@@ -2449,58 +2529,96 @@ var Transport = class {
 					response,
 					body: payload
 				});
-				await this.#dispatchErrorHook(request, {
-					...context,
-					duration,
-					error
-				}, abort, timeout);
-				this.#config.logger?.warn(`← ${response.status} ${method} ${request.path} (${duration} мс): ${error.message}`);
+				await this.#report(attempt, headers, error);
+				this.#config.logger?.warn(`← ${response.status} ${attempt.method} ${request.path} (${duration} мс): ${error.message}`);
 				throw error;
 			}
-			this.#config.logger?.debug(`← ${response.status} ${method} ${request.path} (${duration} мс)`);
+			this.#config.logger?.debug(`← ${response.status} ${attempt.method} ${request.path} (${duration} мс)`);
 			return request.raw ? payload : unwrapData(payload);
 		} finally {
 			try {
 				await cleanupBody?.();
 			} catch (error) {
-				this.#config.logger?.warn(`не удалось закрыть тело ${method} ${request.path}`, error);
+				this.#config.logger?.warn(`не удалось закрыть тело ${attempt.method} ${request.path}`, error);
 			} finally {
-				abort.cleanup();
+				attempt.abort.cleanup();
 			}
 		}
 	};
-	async #dispatchErrorHook(request, context, abort, timeout) {
-		markRequestErrorObserved(request, context.error);
-		const onAbort = () => markRequestErrorNotificationAborted(request);
-		if (abort.signal.aborted) onAbort();
-		else abort.signal.addEventListener("abort", onAbort, { once: true });
-		try {
-			await abortable(dispatchRequestHook(this.#config.hooks, "onError", context), abort.signal);
-		} catch (error) {
-			const failure = abort.signal.aborted ? this.#toTransportError(error, abort, request, context.method, timeout) : error;
-			markRequestErrorObserved(request, failure);
-			throw failure;
-		} finally {
-			abort.signal.removeEventListener("abort", onAbort);
+	/**
+	* Итоговый URL со строкой запроса. Нужен и слою повторов — для хука `onRetry`.
+	*
+	* Хост берётся из самого запроса, если он там задан: у сервисов платформы свои домены.
+	*/
+	buildUrl(request) {
+		const base = request.baseUrl ?? this.#config.baseUrl;
+		return joinUrl(base, request.path) + buildQuery(request.query);
+	}
+	/**
+	* Собирает общие заголовки клиента: `User-Agent`, идентификатор устройства,
+	* заголовки конфигурации и cookie для указанного адреса.
+	*/
+	async platformHeaders(url, cookieJar = this.#deps.cookies) {
+		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 && cookieJar) {
+			const cookie = cookieJar.getHeader(url);
+			if (cookie) setHeader(headers, "Cookie", cookie);
 		}
+		return headers;
+	}
+	/** Данные попытки для хуков `onRequest`, `onResponse` и перехватчиков. */
+	#context(attempt, headers) {
+		return {
+			operationId: attempt.request.operationId,
+			signal: attempt.abort.signal,
+			method: attempt.method,
+			path: attempt.request.path,
+			url: attempt.url,
+			headers,
+			attempt: attempt.number
+		};
+	}
+	#elapsed(attempt) {
+		return this.#config.clock.now() - attempt.startedAt;
+	}
+	/** Ошибка хука: отмена во время его работы становится транспортной ошибкой, остальное — как есть. */
+	#abortedOr(attempt, error) {
+		return attempt.abort.signal.aborted ? this.#toTransportError(attempt, error) : error;
+	}
+	/**
+	* Дополняет общие заголовки значением `Accept`, заголовками конвейера и вызова.
+	* Заголовки вызова применяются последними.
+	*/
+	async #buildHeaders(request, url) {
+		const headers = await this.platformHeaders(url, request.cookieJar);
+		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;
 	}
 	/** Подготавливает тело внутри попытки, чтобы поток можно было открыть заново при retry. */
-	async #prepareBody(request, headers, signal, attempt) {
+	async #prepareBody(attempt, headers) {
+		const { request } = attempt;
+		const { signal } = attempt.abort;
 		if (request.bodyFactory) {
 			if (request.body !== void 0 && request.body !== null) throw new ItdConfigError("body и bodyFactory нельзя задавать одновременно");
 			const pending = Promise.resolve(request.bodyFactory({
 				signal,
-				attempt
+				attempt: attempt.number
 			}));
 			let prepared;
 			try {
-				prepared = await abortable(pending, signal);
+				prepared = await waitForRequest(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);
+						this.#config.logger?.warn(`не удалось закрыть отложенное тело ${attempt.method} ${request.path}`, cleanupError);
 					}
 				}).catch(() => {});
 				throw error;
@@ -2525,72 +2643,76 @@ var Transport = class {
 			cleanup: void 0
 		};
 	}
-	/** Читает тело и преобразует ошибку чтения в транспортную ошибку библиотеки. */
-	async #readBodyOrFail(response, context, request, method, abort, timeout, startedAt) {
-		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 this.#dispatchErrorHook(request, {
-				...context,
-				duration: this.#config.clock.now() - startedAt,
-				error: failure
-			}, abort, timeout);
-			this.#config.logger?.warn(`× ${method} ${request.path}: не удалось прочитать тело ответа — ${failure.message}`);
-			throw failure;
-		}
+	/** Вызывает `fetch` через перехватчики попытки; сбой сети становится ошибкой библиотеки. */
+	#fetch(attempt, headers, body, contextOf) {
+		const init = {
+			method: attempt.method,
+			headers,
+			signal: attempt.abort.signal,
+			...body !== void 0 ? { body } : {},
+			...this.#config.sendCredentials ? { credentials: "include" } : {}
+		};
+		if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) init.duplex = "half";
+		const execute = async () => {
+			try {
+				return await this.#config.fetch(attempt.url, init);
+			} catch (error) {
+				throw this.#toTransportError(attempt, error);
+			}
+		};
+		const interceptors = attemptInterceptorScope(attempt.request);
+		if (!interceptors) return execute();
+		return runAttemptInterceptors(interceptors, {
+			...contextOf(),
+			body
+		}, execute);
 	}
 	/**
-	* Итоговый URL со строкой запроса. Нужен и слою повторов — для хука `onRetry`.
+	* Сообщает хуку `onError` об ошибке попытки и отмечает её как переданную.
 	*
-	* Хост берётся из самого запроса, если он там задан: у сервисов платформы свои домены.
-	*/
-	buildUrl(request) {
-		const base = request.baseUrl ?? this.#config.baseUrl;
-		return joinUrl(base, request.path) + buildQuery(request.query);
-	}
-	/**
-	* Собирает общие заголовки клиента: `User-Agent`, идентификатор устройства,
-	* заголовки конфигурации и cookie для указанного адреса.
+	* Ожидание хука ограничено lifecycle операции; срок попытки на него не действует.
+	* Если ошибка попытки — сама отмена операции, о ней сообщает тот уровень, который заметил
+	* её первым; второй хук не вызывает. Отмена, заставшая хук с другой ошибкой, остаётся за
+	* верхней границей операции.
+	*
+	* @throws ошибку самого хука, если операция не отменена
 	*/
-	async platformHeaders(url, cookieJar = this.#deps.cookies) {
-		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 && cookieJar) {
-			const cookie = cookieJar.getHeader(url);
-			if (cookie) setHeader(headers, "Cookie", cookie);
+	async #report(attempt, headers, error) {
+		const { request } = attempt;
+		attempt.abort.disarm();
+		if (!hasRequestHook(this.#config.hooks, "onError")) return;
+		markRequestErrorReported(request, error);
+		const lifecycle = request.signal;
+		const notify = () => dispatchRequestHook(this.#config.hooks, "onError", {
+			...this.#context(attempt, headers),
+			duration: this.#elapsed(attempt),
+			error
+		});
+		if (lifecycle?.aborted) {
+			if (claimAbortReport(request)) notify().catch(() => {});
+			return;
+		}
+		try {
+			const pending = notify();
+			await (lifecycle ? waitForRequest(pending, lifecycle) : pending);
+		} catch (hookError) {
+			if (lifecycle?.aborted) return;
+			markRequestErrorReported(request, hookError);
+			throw hookError;
 		}
-		return headers;
-	}
-	/**
-	* Дополняет общие заголовки значением `Accept`, заголовками конвейера и вызова.
-	* Заголовки вызова применяются последними.
-	*/
-	async #buildHeaders(request, url) {
-		const headers = await this.platformHeaders(url, request.cookieJar);
-		if (!headers.has("Accept")) headers.set("Accept", "application/json");
-		for (const [name, value] of Object.entries(request.layerHeaders ?? {})) setHeader(headers, name, value);
-		for (const [name, value] of Object.entries(request.headers ?? {})) setHeader(headers, name, value);
-		return headers;
 	}
-	/** Превращает исключение `fetch` в понятную ошибку библиотеки. */
-	#toTransportError(error, abort, request, method, timeout) {
-		const aborted = abort.signal.aborted || error instanceof Error && error.name === "AbortError";
-		if (aborted && abort.timedOut()) return new ItdTimeoutError({
-			timeout,
-			method,
-			path: request.path
-		});
-		if (aborted) {
+	/** Превращает исключение `fetch` или отмену в понятную ошибку библиотеки. */
+	#toTransportError(attempt, error) {
+		const { abort, method, request } = attempt;
+		if (abort.signal.aborted || error instanceof Error && error.name === "AbortError") {
+			const expired = abort.expired();
+			if (expired) return expired;
 			const reason = abort.signal.reason;
+			if (reason instanceof ItdTimeoutError) return reason;
 			return new ItdAbortError(`Запрос ${method} ${request.path} отменён`, reason !== void 0 ? { cause: reason } : void 0);
 		}
 		if (error instanceof ItdError) return error;
-		return new ItdNetworkError(`Не удалось выполнить ${method} ${request.path}: ${error instanceof Error ? error.message : String(error)}`, {
+		return new ItdNetworkError(`Не удалось выполнить ${method} ${request.path}: ${describe(error)}`, {
 			method,
 			path: request.path,
 			cause: error
@@ -2602,6 +2724,7 @@ var Transport = class {
 /** Имена стадий обработки запроса в порядке выполнения. @internal */
 const ClientRuntimeStage = Object.freeze({
 	OperationPlugins: "operation_plugins",
+	Decode: "decode",
 	Services: "services",
 	AuthPreflight: "auth_preflight",
 	Retry: "retry",
@@ -2649,14 +2772,27 @@ function createClientRuntime(options, internals) {
 			path: request.path
 		}) ?? catalog.bucketOf(request.operationId);
 	};
-	const queueKeyFor = (request) => requestQueueKey(request, (target) => ({
-		destination: originOf(transport.buildUrl(target)) || void 0,
-		bucket: bucketFor(target)
-	}));
+	/** Origin направления, мемоизированный по базовому адресу. */
+	const origins = /* @__PURE__ */ new Map();
+	const destinationOf = (baseUrl) => {
+		if (origins.has(baseUrl)) return origins.get(baseUrl);
+		if (origins.size >= 256) origins.clear();
+		const origin = originOf(baseUrl) || void 0;
+		origins.set(baseUrl, origin);
+		return origin;
+	};
+	const queueKeyFor = (request) => requestQueueKey(request, (target) => {
+		const bucket = bucketFor(target);
+		return {
+			destination: destinationOf(target.baseUrl ?? config.baseUrl),
+			bucket,
+			definition: catalog.bucketDefinitionOf(bucket)
+		};
+	});
 	const queueFor = (request) => {
 		if (!queues) return void 0;
 		const key = queueKeyFor(request);
-		return queues.for(key.destination, key.bucket);
+		return queues.for(key.destination, key.bucket, key.definition);
 	};
 	/** Передаёт остаток из заголовков ответа бакету запроса; тот решает, тормозить ли себя. */
 	const observeRateLimit = (limit, remaining, request) => {
@@ -2665,16 +2801,21 @@ function createClientRuntime(options, internals) {
 		const waited = queue.observe(limit, remaining);
 		if (waited > 0) config.logger?.debug(`остаток лимита ${remaining} из ${limit ?? "?"}, бакет ${queue.bucket} ждёт ${waited} мс`);
 	};
-	transport = new Transport({
-		...config,
-		hooks: config.hooks
-	}, {
+	transport = new Transport(config, {
 		onRateLimit: queues ? observeRateLimit : void 0,
 		cookies: config.useCookieJar ? jar : void 0,
-		getDeviceId: () => auth.deviceId(),
-		lifetimeSignal: lifetime.signal
+		getDeviceId: () => auth.deviceId()
 	});
-	const stages = [
+	/** Стадии логической операции: выполняются один раз на вызов метода. */
+	const operationStages = [{
+		name: ClientRuntimeStage.OperationPlugins,
+		middleware: createPluginsMiddleware(plugins)
+	}, {
+		name: ClientRuntimeStage.Decode,
+		middleware: createDecodeMiddleware()
+	}];
+	/** Стадии исполнения: от выбора сервиса до транспортной попытки. */
+	const executionStages = [
 		{
 			name: ClientRuntimeStage.Services,
 			middleware: createServicesMiddleware(services)
@@ -2689,7 +2830,7 @@ function createClientRuntime(options, internals) {
 				clock: config.clock,
 				catalog,
 				retry: config.retry,
-				rateLimitDelays: config.rateLimit?.retryDelays ?? [],
+				rateLimitDelays: config.rateLimit?.retryDelays,
 				pauseQueue: queues ? (ms, request) => queueFor(request)?.pause(ms) : void 0,
 				hooks: config.hooks,
 				logger: config.logger,
@@ -2702,39 +2843,41 @@ function createClientRuntime(options, internals) {
 		},
 		{
 			name: ClientRuntimeStage.AuthPreparation,
-			middleware: createAuthPreparationMiddleware({ prepare: () => auth.prepare() })
+			middleware: createAuthPreparationMiddleware(() => auth)
 		}
 	];
-	if (queues) stages.push({
+	if (queues) executionStages.push({
 		name: ClientRuntimeStage.Queue,
 		middleware: createQueueMiddleware((request, task) => {
 			const queue = queueFor(request);
 			return queue ? queue.schedule(task, request.signal) : task();
 		})
 	});
-	stages.push({
+	executionStages.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) => {
+	const execution = composePipeline(executionStages.map(({ middleware }) => middleware), transport.send);
+	/**
+	* Проверки между стадиями операции и исполнения: обёртка плагина уже могла изменить запрос,
+	* а после начала `dispose()` завершаются только служебные запросы финализации.
+	*/
+	const guardedExecution = (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);
+		return execution(request);
 	};
 	const http = new HttpClient({
-		handler: clientHandler,
-		plugins,
+		handler: composePipeline(operationStages.map(({ middleware }) => middleware), guardedExecution),
 		baseUrl: config.baseUrl,
-		timeout: config.timeout,
+		deadline: config.deadline,
 		clock: config.clock,
 		lifetimeSignal: lifetime.signal,
 		hooks: config.hooks,
@@ -2746,8 +2889,8 @@ function createClientRuntime(options, internals) {
 		cookies: jar
 	});
 	const stageOrder = Object.freeze([
-		ClientRuntimeStage.OperationPlugins,
-		...stages.map(({ name }) => name),
+		...operationStages.map(({ name }) => name),
+		...executionStages.map(({ name }) => name),
 		ClientRuntimeStage.Transport
 	]);
 	return {
@@ -2780,7 +2923,6 @@ function createClientRuntime(options, internals) {
 		},
 		platformHeaders: (url) => transport.platformHeaders(url),
 		rateLimitState: () => queues?.states() ?? [],
-		registerRateLimitBucket: (name, definition) => queues?.defineBucket(name, definition),
 		close: () => {
 			if (ownsQueues) queues?.stop();
 		},
@@ -3406,20 +3548,23 @@ function operationBucket(id) {
 }
 //#endregion
 //#region src/domain/catalog.ts
+/** Ограничения встроенных бакетов: ёмкость из таблицы плюс встроенные поправки. */
+const BUCKET_DEFINITIONS = Object.freeze(Object.fromEntries(Object.entries(BUCKET_LIMITS).map(([name, limit]) => [name, Object.freeze({
+	limit,
+	...DEFAULT_BUCKET_OVERRIDES[name]
+})])));
 /**
 * Каталог операций итд.com, которым пользуется ядро.
 *
 * Единственное место, где generic request executor встречается с таблицами конкретного API.
-* Собирается из уже существующих функций каталога: собственной логики здесь нет.
 *
 * @internal
 */
 const ITD_CATALOG = Object.freeze({
 	definitionOf: (id) => isBuiltInOperationId(id) ? OPERATIONS[id] : void 0,
-	retrySafetyOf: (id) => isBuiltInOperationId(id) ? operationRetrySafety(id) : void 0,
-	methodOf: (id) => isBuiltInOperationId(id) ? operationMethod(id) : void 0,
 	bucketOf: (id) => operationBucket(id),
 	isKnownBucket,
+	bucketDefinitionOf: (name) => BUCKET_DEFINITIONS[name],
 	bucketLimits: BUCKET_LIMITS,
 	bucketOverrides: DEFAULT_BUCKET_OVERRIDES,
 	defaultBucket: DEFAULT_RATE_LIMIT_BUCKET
@@ -3914,7 +4059,6 @@ function localDeviceId() {
 function anonymousAuth() {
 	return {
 		token: () => Promise.resolve(null),
-		prepare: () => Promise.resolve(),
 		currentHeaders: () => ({}),
 		recover: () => Promise.resolve(false),
 		deviceId: localDeviceId(),
@@ -3936,7 +4080,6 @@ function bearerToken(accessToken) {
 	const headers = { Authorization: `Bearer ${accessToken}` };
 	return {
 		token: () => Promise.resolve(accessToken),
-		prepare: () => Promise.resolve(),
 		currentHeaders: () => headers,
 		recover: () => Promise.resolve(false),
 		deviceId: localDeviceId(),
@@ -4106,6 +4249,6 @@ function resolveNotificationUrl(notification) {
 	return clickUrl || "/notifications";
 }
 //#endregion
-export { identityResult as $, SpanType as A, operationRetrySafety as B, ItdErrorCode as C, ReportReason as D, QrLocationPrecision as E, OPERATIONS as F, isRecord as G, DEFAULT_RATE_LIMIT_BUCKET as H, defineBuiltInOperation as I, pickNumber as J, pickArray as K, isBuiltInOperationId as L, ViewSource as M, WallAccess as N, ReportTargetType as O, ITD_CATALOG as P, defineOperation as Q, operationBucket as R, InteractionType as S, NotificationType as T, createClientRuntime as U, BUCKET_LIMITS as V, createApiError as W, pickString as X, pickObject as Y, RetrySafety as Z, CaptchaType as _, installAsyncDisposeFallback as _t, tokenProvider as a, assertPluginRemovable as at, FeedTab as b, normalizeNotification as c, DEFAULT_STATUS_BASE_URL as ct, canonicalNotificationType as d, LIBRARY_VERSION as dt, voidResult as et, isKnownNotificationType as f, isRecord$1 as ft, CaptchaField as g, systemClock as gt, CaptchaChoice as h, createDeadline as ht, bearerToken as i, RequestQueuePool as it, ViewReason as j, ServiceState as k, readNotificationEvent as l, STATUS_SERVICE as lt, AttachmentType as m, RateLimitPacing as mt, formatNotificationText as n, requestAbortError as nt, passthroughOperation as o, orderPluginDefinitions as ot, AccessType as p, requireOptionalBoolean as pt, pickBoolean as q, anonymousAuth as r, mergeService as rt, voidOperation as s, DEFAULT_BASE_URL as st, resolveNotificationUrl as t, createRequestAbortScope as tt, readUnreadCountEvent as u, resolveRateLimit as ut, CommentSort as v, LikesVisibility as w, IncidentKind as x, EventChannelStatus as y, operationMethod as z };
+export { identityResult as $, SpanType as A, operationRetrySafety as B, ItdErrorCode as C, ReportReason as D, QrLocationPrecision as E, OPERATIONS as F, pickArray as G, DEFAULT_RATE_LIMIT_BUCKET as H, defineBuiltInOperation as I, pickObject as J, pickBoolean as K, isBuiltInOperationId as L, ViewSource as M, WallAccess as N, ReportTargetType as O, ITD_CATALOG as P, defineOperation as Q, operationBucket as R, InteractionType as S, NotificationType as T, createClientRuntime as U, BUCKET_LIMITS as V, createApiError as W, OperationMethod as X, pickString as Y, RetrySafety as Z, CaptchaType as _, tokenProvider as a, assertPluginRemovable as at, FeedTab as b, normalizeNotification as c, DEFAULT_STATUS_BASE_URL as ct, canonicalNotificationType as d, LIBRARY_VERSION as dt, voidResult as et, isKnownNotificationType as f, RateLimitPacing as ft, CaptchaField as g, CaptchaChoice as h, installAsyncDisposeFallback as ht, bearerToken as i, RequestQueuePool as it, ViewReason as j, ServiceState as k, readNotificationEvent as l, STATUS_SERVICE as lt, AttachmentType as m, systemClock as mt, formatNotificationText as n, requestAbortError as nt, passthroughOperation as o, orderPluginDefinitions as ot, AccessType as p, createDeadline as pt, pickNumber as q, anonymousAuth as r, mergeService as rt, voidOperation as s, DEFAULT_BASE_URL as st, resolveNotificationUrl as t, createRequestAbortScope as tt, readUnreadCountEvent as u, resolveRateLimit as ut, CommentSort as v, LikesVisibility as w, IncidentKind as x, EventChannelStatus as y, operationMethod as z };
 
-//# sourceMappingURL=url-DS0-lrl-.js.map
+//# sourceMappingURL=url-Bg61sk_Y.js.map