itd-api 0.10.4 → 0.11.0

package/dist/shared/{url-BNTKqBMB.cjs → url-DTgkCWv5.cjs}

@@ -1,5 +1,5 @@
-const require_errors = require("./errors-BmP3TKoW.cjs");
-const require_redact = require("./redact-lAmck1Z6.cjs");
+const require_validate = require("./validate-CFx2dISs.cjs");
+const require_redact = require("./redact-DoC7lSsp.cjs");
 //#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 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.10.4";
+const LIBRARY_VERSION = "0.11.0";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -120,42 +99,21 @@ const DEFAULT_RATE_LIMIT_DELAYS = Object.freeze([
 ]);
 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} должен быть строкой`);
+	if (!require_validate.isObjectLike(headers)) throw new require_validate.ItdConfigError("headers должен быть объектом строк");
+	for (const [name, value] of Object.entries(headers)) if (typeof value !== "string") throw new require_validate.ItdConfigError(`headers.${name} должен быть строкой`);
 	return { ...headers };
 }
 function resolveHooks(hooks) {
 	if (hooks === void 0) return {};
-	if (!isRecord$1(hooks)) throw new require_errors.ItdConfigError("hooks должен быть объектом");
+	if (!require_validate.isObjectLike(hooks)) throw new require_validate.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} должен быть функцией`);
+	]) if (hooks[name] !== void 0 && typeof hooks[name] !== "function") throw new require_validate.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)
-	};
-}
 /**
 * Приводит настройки повторов к полному виду.
 *
@@ -167,15 +125,15 @@ function consoleLogger() {
 */
 function resolveRetry(retry) {
 	if (retry === false) return void 0;
-	if (retry !== void 0 && !isRecord$1(retry)) throw new require_errors.ItdConfigError("retry должен быть объектом или false");
+	if (retry !== void 0 && !require_validate.isObjectLike(retry)) throw new require_validate.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}`);
+	if (!Number.isInteger(attempts) || attempts < 1) throw new require_validate.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 (!Number.isFinite(jitter) || jitter < 0 || jitter > 1) throw new require_validate.ItdConfigError(`retry.jitter должен быть в диапазоне 0…1, получено: ${jitter}`);
+	if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") throw new require_validate.ItdConfigError("retry.shouldRetry должен быть функцией");
+	const baseDelay = require_validate.requireNonNegative(options.baseDelay ?? 500, "retry.baseDelay");
+	const maxDelay = require_validate.requireNonNegative(options.maxDelay ?? 3e4, "retry.maxDelay");
 	if (attempts === 1) return void 0;
 	return {
 		attempts,
@@ -198,19 +156,19 @@ function resolveRetry(retry) {
 */
 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(", ")}`);
+	throw new require_validate.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}`);
+	if (!Number.isInteger(value) || value < 1) throw new require_validate.ItdConfigError(`${name} должен быть целым числом от 1, получено: ${value}`);
 	return value;
 }
 function requireRps(value, name) {
-	if (!Number.isFinite(value) || value <= 0) throw new require_errors.ItdConfigError(`${name} должен быть положительным числом, получено: ${value}`);
+	if (!Number.isFinite(value) || value <= 0) throw new require_validate.ItdConfigError(`${name} должен быть положительным числом, получено: ${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}`);
+	if (pacing !== void 0 && !known.includes(pacing)) throw new require_validate.ItdConfigError(`rateLimit.pacing должен быть одним из ${known.join(", ")}, получено: ${pacing}`);
 	return pacing ?? RateLimitPacing.React;
 }
 /**
@@ -223,13 +181,13 @@ function resolvePacing(pacing) {
 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 должен быть объектом");
+	if (!require_validate.isObjectLike(overrides)) throw new require_validate.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} должен быть объектом`);
+		if (!require_validate.isObjectLike(override)) throw new require_validate.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}`);
+		if (override.limit !== void 0 && (!Number.isFinite(override.limit) || override.limit <= 0)) throw new require_validate.ItdConfigError(`rateLimit.bucketOverrides.${name}.limit должен быть положительным числом, получено: ${override.limit}`);
 		if (override.rps !== void 0) requireRps(override.rps, `rateLimit.bucketOverrides.${name}.rps`);
 		const built = builtIn[name];
 		resolved[name] = Object.freeze({
@@ -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 require_errors.ItdConfigError("rateLimit должен быть объектом или false");
+	if (rateLimit !== void 0 && !require_validate.isObjectLike(rateLimit)) throw new require_validate.ItdConfigError("rateLimit должен быть объектом или false");
 	const defaults = {
 		concurrency: 6,
 		rps: void 0,
@@ -262,17 +220,16 @@ function resolveRateLimit(rateLimit, catalog) {
 		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) requireRps(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 должен быть функцией");
+	if (!Array.isArray(retryDelays)) throw new require_validate.ItdConfigError("rateLimit.retryDelays должен быть массивом чисел");
+	for (const delay of retryDelays) require_validate.requireNonNegative(delay, "rateLimit.retryDelays");
+	require_validate.requireOptionalBoolean(rateLimit.buckets, "rateLimit.buckets");
+	if (rateLimit.bucket !== void 0 && typeof rateLimit.bucket !== "function") throw new require_validate.ItdConfigError("rateLimit.bucket должен быть функцией");
 	return {
 		concurrency,
 		rps: rateLimit.rps,
@@ -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 require_errors.ItdConfigError("services должен быть объектом");
+	if (!require_validate.isObjectLike(services)) throw new require_validate.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 или объектом сервиса`);
+		if (!require_validate.isObjectLike(value)) throw new require_validate.ItdConfigError(`services.${name} должен быть URL или объектом сервиса`);
 		return {
 			...value,
 			name
@@ -315,19 +271,21 @@ function resolveServices(services) {
 * @throws {ItdConfigError} при некорректных значениях
 */
 function resolveRuntimeConfig(options, catalog) {
-	if (!isRecord$1(options)) throw new require_errors.ItdConfigError("опции клиента должны быть объектом");
+	if (!require_validate.isObjectLike(options)) throw new require_validate.ItdConfigError("опции клиента должны быть объектом");
 	const mode = options.mode ?? require_redact.RuntimeMode.Auto;
-	if (!Object.values(require_redact.RuntimeMode).includes(mode)) throw new require_errors.ItdConfigError(`mode должен быть одним из ${Object.values(require_redact.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");
+	if (!Object.values(require_redact.RuntimeMode).includes(mode)) throw new require_validate.ItdConfigError(`mode должен быть одним из ${Object.values(require_redact.RuntimeMode).join(", ")}, получено: ${mode}`);
+	const timeout = require_validate.requireNonNegative(options.timeout ?? 3e4, "timeout");
+	const deadline = require_validate.requireNonNegative(options.deadline ?? 0, "deadline");
+	const shutdownTimeout = require_validate.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 require_validate.ItdConfigError("clock должен предоставлять методы now() и schedule()");
+	if (options.userAgent !== void 0 && options.userAgent !== false && typeof options.userAgent !== "string") throw new require_validate.ItdConfigError("userAgent должен быть строкой или false");
 	return {
 		baseUrl: require_redact.normalizeBaseUrl(options.baseUrl ?? "https://xn--d1ah4a.com"),
 		services: resolveServices(options.services),
 		fetch: require_redact.resolveFetch(options.fetch),
 		clock: options.clock ?? systemClock,
 		timeout,
+		deadline,
 		shutdownTimeout,
 		retry: resolveRetry(options.retry),
 		rateLimit: resolveRateLimit(options.rateLimit, catalog),
@@ -337,7 +295,7 @@ function resolveRuntimeConfig(options, catalog) {
 		mode,
 		useCookieJar: require_redact.shouldUseCookieJar(mode),
 		sendCredentials: require_redact.shouldSendCredentials(mode),
-		logger: resolveLogger(options.logger)
+		logger: require_redact.resolveLogger(options.logger)
 	};
 }
 //#endregion
@@ -358,7 +316,7 @@ function withAttemptInterceptorScope(request, interceptors) {
 }
 /** Читает снимок attempt interceptors логической операции. @internal */
 function attemptInterceptorScope(request) {
-	return request[ATTEMPT_SCOPE] ?? [];
+	return request[ATTEMPT_SCOPE];
 }
 /**
 * Выполняет обёртки одной попытки.
@@ -366,15 +324,15 @@ 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 require_errors.ItdConfigError(`attempt interceptor плагина «${plugin}» вызвал next() больше одного раза`);
+			if (called) throw new require_validate.ItdConfigError(`attempt interceptor плагина «${plugin}» вызвал next() больше одного раза`);
 			called = true;
 			return next();
 		});
-		if (!isResponse(response)) throw new require_errors.ItdConfigError(`attempt interceptor плагина «${plugin}» должен вернуть Response`);
+		if (!isResponse(response)) throw new require_validate.ItdConfigError(`attempt interceptor плагина «${plugin}» должен вернуть Response`);
 		return response;
 	}, execute)();
 }
@@ -395,13 +353,13 @@ function isPluginName(value) {
 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} должен быть массивом`);
+	if (!Array.isArray(values)) throw new require_validate.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 (!isPluginName(value)) throw new require_errors.ItdConfigError(`плагин «${plugin.name}»: имя «${value}» в ${field} должно соответствовать ${PLUGIN_NAME_FORMAT}`);
-		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}»`);
+		if (typeof value !== "string" || value.trim() === "") throw new require_validate.ItdConfigError(`плагин «${plugin.name}»: ${field} содержит пустое имя плагина`);
+		if (!isPluginName(value)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}»: имя «${value}» в ${field} должно соответствовать ${PLUGIN_NAME_FORMAT}`);
+		if (value === plugin.name) throw new require_validate.ItdConfigError(`плагин «${plugin.name}» не может указать себя в ${field}`);
+		if (seen.has(value)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}»: ${field} повторяет имя «${value}»`);
 		seen.add(value);
 	}
 }
@@ -415,10 +373,10 @@ function validateNameList(plugin, field) {
 * @internal
 */
 function validatePluginDefinition(plugin) {
-	if (typeof plugin?.install !== "function") throw new require_errors.ItdConfigError("Плагин должен быть объектом с методом install()");
+	if (typeof plugin?.install !== "function") throw new require_validate.ItdConfigError("Плагин должен быть объектом с методом install()");
 	const name = plugin.name;
-	if (typeof name !== "string" || name.trim() === "") throw new require_errors.ItdConfigError("У плагина должно быть непустое имя");
-	if (!isPluginName(name)) throw new require_errors.ItdConfigError(`Имя плагина «${name}» должно соответствовать ${PLUGIN_NAME_FORMAT}`);
+	if (typeof name !== "string" || name.trim() === "") throw new require_validate.ItdConfigError("У плагина должно быть непустое имя");
+	if (!isPluginName(name)) throw new require_validate.ItdConfigError(`Имя плагина «${name}» должно соответствовать ${PLUGIN_NAME_FORMAT}`);
 	for (const field of RELATION_FIELDS) validateNameList(plugin, field);
 }
 function addEdge(from, to, edges, indegree) {
@@ -437,7 +395,7 @@ function orderPluginDefinitions(plugins) {
 	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}» уже подключён`);
+		if (byName.has(plugin.name)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}» уже подключён`);
 		const entry = {
 			plugin,
 			sequence
@@ -446,9 +404,9 @@ function orderPluginDefinitions(plugins) {
 		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}»`);
+		for (const required of plugin.requires ?? []) if (!byName.has(required)) throw new require_validate.ItdConfigError(`плагину «${plugin.name}» требуется плагин «${required}»`);
+		for (const conflict of plugin.conflicts ?? []) if (byName.has(conflict)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}» несовместим с плагином «${conflict}»`);
+		for (const { plugin: other } of entries) if (other.conflicts?.includes(plugin.name)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}» несовместим с плагином «${other.name}»`);
 	}
 	const edges = /* @__PURE__ */ new Map();
 	const indegree = /* @__PURE__ */ new Map();
@@ -482,14 +440,14 @@ function orderPluginDefinitions(plugins) {
 	}
 	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(" → ")}`);
+		throw new require_validate.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}»`);
+	if (dependent) throw new require_validate.ItdConfigError(`нельзя отключить плагин «${name}»: от него зависит «${dependent.name}»`);
 }
 //#endregion
 //#region src/core/plugins/registry.ts
@@ -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 require_errors.ItdConfigError(`плагин «${plugin.name}» ещё отключается; дождитесь завершения unuse() или dispose()`);
-		orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
+		if (this.#removing.has(plugin.name)) throw new require_validate.ItdConfigError(`плагин «${plugin.name}» ещё отключается; дождитесь завершения unuse() или dispose()`);
+		return orderPluginDefinitions([...this.#ordered.map((entry) => entry.plugin), plugin]);
 	}
 	/** Проверяет удаление без изменения реестра. @internal */
 	assertCanRemove(name) {
@@ -543,12 +505,11 @@ 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) => {
-			if (typeof value !== "function") throw new require_errors.ItdConfigError(`плагин «${plugin.name}» передал в ${kind}.use() не функцию`);
+			if (typeof value !== "function") throw new require_validate.ItdConfigError(`плагин «${plugin.name}» передал в ${kind}.use() не функцию`);
 			values.push(value);
 			let active = true;
 			return () => {
@@ -566,7 +527,7 @@ var PluginRegistry = class {
 			},
 			attempts: { use: (interceptor) => register(interceptors, interceptor, "attempts") }
 		});
-		if (installed !== void 0 && typeof installed !== "function") throw new require_errors.ItdConfigError(`install() плагина «${plugin.name}» должен вернуть функцию или void`);
+		if (installed !== void 0 && typeof installed !== "function") throw new require_validate.ItdConfigError(`install() плагина «${plugin.name}» должен вернуть функцию или void`);
 		const teardown = installed;
 		this.#entries.set(plugin.name, {
 			plugin,
@@ -579,7 +540,7 @@ var PluginRegistry = class {
 		});
 		this.#ordered = ordered.map((definition) => {
 			const entry = this.#entries.get(definition.name);
-			if (!entry) throw new require_errors.ItdConfigError(`плагин «${definition.name}» не установлен`);
+			if (!entry) throw new require_validate.ItdConfigError(`плагин «${definition.name}» не установлен`);
 			return entry;
 		});
 	}
@@ -678,9 +639,9 @@ var PluginRegistry = class {
 			return interceptorScope.length === 0 ? prepared : withAttemptInterceptorScope(prepared, interceptorScope);
 		};
 		const validateContract = (prepared) => {
-			if (prepared.operationId !== operationId) throw new require_errors.ItdConfigError(`operation transformer не может заменить operationId «${operationId}» на «${prepared.operationId}»`);
-			if (prepared.method.toUpperCase() !== method) throw new require_errors.ItdConfigError(`operation transformer не может заменить метод «${method}» операции «${operationId}» на «${prepared.method}»`);
-			if (prepared.retrySafety !== void 0 && prepared.retrySafety !== retrySafety) throw new require_errors.ItdConfigError(`operation transformer не может заменить retrySafety операции «${operationId}»`);
+			if (prepared.operationId !== operationId) throw new require_validate.ItdConfigError(`operation transformer не может заменить operationId «${operationId}» на «${prepared.operationId}»`);
+			if (prepared.method.toUpperCase() !== method) throw new require_validate.ItdConfigError(`operation transformer не может заменить метод «${method}» операции «${operationId}» на «${prepared.method}»`);
+			if (prepared.retrySafety !== void 0 && prepared.retrySafety !== retrySafety) throw new require_validate.ItdConfigError(`operation transformer не может заменить retrySafety операции «${operationId}»`);
 		};
 		const chain = entries.flatMap((entry) => entry.transformers.map((transformer) => ({
 			plugin: entry.plugin.name,
@@ -688,7 +649,7 @@ var PluginRegistry = class {
 		}))).reduceRight((next, { plugin, transformer }) => (current) => {
 			let called = false;
 			return transformer(scoped(current), (prepared) => {
-				if (called) throw new require_errors.ItdConfigError(`operation transformer плагина «${plugin}» вызвал next() больше одного раза`);
+				if (called) throw new require_validate.ItdConfigError(`operation transformer плагина «${plugin}» вызвал next() больше одного раза`);
 				called = true;
 				validateContract(prepared);
 				return next(scoped(prepared));
@@ -720,14 +681,14 @@ var PluginRegistry = class {
 	*/
 	async #release(entry, deadline) {
 		const errors = [];
-		if (!await deadline.wait(this.#waitForDrain(entry))) errors.push(new require_errors.ItdStateError(`плагин «${entry.plugin.name}» не завершил операции за ${this.#options.shutdownTimeout} мс`));
+		if (!await deadline.wait(this.#waitForDrain(entry))) errors.push(new require_validate.ItdStateError(`плагин «${entry.plugin.name}» не завершил операции за ${this.#options.shutdownTimeout} мс`));
 		let teardownFailed = false;
 		let teardownFailure;
 		const teardown = Promise.resolve().then(() => entry.teardown?.()).catch((error) => {
 			teardownFailed = true;
 			teardownFailure = error;
 		});
-		if (!await deadline.wait(teardown)) errors.push(new require_errors.ItdStateError(`плагин «${entry.plugin.name}» не завершил teardown за ${this.#options.shutdownTimeout} мс`));
+		if (!await deadline.wait(teardown)) errors.push(new require_validate.ItdStateError(`плагин «${entry.plugin.name}» не завершил teardown за ${this.#options.shutdownTimeout} мс`));
 		else if (teardownFailed) throw teardownFailure;
 		return errors;
 	}
@@ -748,11 +709,11 @@ var PluginRegistry = class {
 //#region src/core/scheduling/rate-limit.ts
 /** Ошибка отмены запроса, который ещё не дошёл до транспорта. */
 function queueAbortError() {
-	return new require_errors.ItdAbortError("Запрос отменён во время ожидания очереди");
+	return new require_validate.ItdAbortError("Запрос отменён во время ожидания очереди");
 }
 /** Ошибка запроса, которого застала остановка очереди. */
 function queueStoppedError() {
-	return new require_errors.ItdAbortError("Клиент закрыт, запрос отменён");
+	return new require_validate.ItdAbortError("Клиент закрыт, запрос отменён");
 }
 /** Длина окна лимита на сервере. */
 const RATE_LIMIT_WINDOW = 6e4;
@@ -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 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) {
+	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 require_validate.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
@@ -1203,15 +1209,15 @@ var ServiceRegistry = class {
 	*/
 	define(definition) {
 		const raw = definition?.name;
-		if (typeof raw !== "string" || raw.trim() === "") throw new require_errors.ItdConfigError("У сервиса должно быть непустое имя");
+		if (typeof raw !== "string" || raw.trim() === "") throw new require_validate.ItdConfigError("У сервиса должно быть непустое имя");
 		const name = raw.trim();
-		if (this.#services.has(name)) throw new require_errors.ItdConfigError(`Сервис «${name}» уже зарегистрирован и не может быть заменён`);
+		if (this.#services.has(name)) throw new require_validate.ItdConfigError(`Сервис «${name}» уже зарегистрирован и не может быть заменён`);
 		const baseUrl = require_redact.normalizeBaseUrl(definition.baseUrl);
-		if (definition.auth !== void 0 && typeof definition.auth !== "boolean") throw new require_errors.ItdConfigError(`services.${name}.auth должен быть boolean`);
+		if (definition.auth !== void 0 && typeof definition.auth !== "boolean") throw new require_validate.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} должен быть строкой`);
+			if (typeof definition.headers !== "object" || definition.headers === null || Array.isArray(definition.headers)) throw new require_validate.ItdConfigError(`services.${name}.headers должен быть объектом строк`);
+			for (const [header, value] of Object.entries(definition.headers)) if (typeof value !== "string") throw new require_validate.ItdConfigError(`services.${name}.headers.${header} должен быть строкой`);
 			headers = Object.freeze({ ...definition.headers });
 		}
 		const normalized = {
@@ -1262,7 +1268,7 @@ var ServiceRegistry = class {
 		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"));
+			throw new require_validate.ItdConfigError(`Сервис «${name}» не зарегистрирован. ` + (known.length > 0 ? `Известны: ${known.join(", ")}` : "Зарегистрируйте его через itd.defineService() или опцию services"));
 		}
 		return service;
 	}
@@ -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,89 +1327,155 @@ 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(() => {});
-		return Promise.reject(new require_errors.ItdAbortError(void 0, { cause: signal.reason }));
+		return Promise.reject(new require_validate.ItdAbortError(void 0, { cause: signal.reason }));
 	}
 	let onAbort;
 	const aborted = new Promise((_resolve, reject) => {
-		onAbort = () => reject(new require_errors.ItdAbortError(void 0, { cause: signal.reason }));
+		onAbort = () => reject(new require_validate.ItdAbortError(void 0, { cause: signal.reason }));
 		signal.addEventListener("abort", onAbort, { once: true });
 	});
 	return Promise.race([promise, aborted]).finally(() => {
 		if (onAbort) signal.removeEventListener("abort", onAbort);
 	});
 }
-/** Возвращает публичную ошибку, соответствующую причине остановки операции. @internal */
+/**
+* Возвращает публичную ошибку, соответствующую причине остановки ожидания.
+*
+* Истёкший срок отдаёт ошибку, созданную таймером области. Отмена с причиной-ошибкой
+* библиотеки (истёкший срок родительской области) отдаёт саму причину; прочая отмена
+* оборачивается в {@link ItdAbortError}.
+*
+* @internal
+*/
 function requestAbortError(scope, request, fallback) {
-	if (scope.timedOut()) return new require_errors.ItdTimeoutError({
-		timeout: request.timeout,
-		method: request.method.toUpperCase(),
-		path: request.path
-	});
-	if (scope.signal.aborted && !(fallback instanceof require_errors.ItdAbortError)) return new require_errors.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 require_validate.ItdTimeoutError) return reason;
+	if (fallback instanceof require_validate.ItdAbortError) return fallback;
+	return new require_validate.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
+		});
+	}
+	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 require_validate.ItdTimeoutError({
+				timeout: deadline,
+				method: request.method.toUpperCase(),
+				path: request.path,
+				budget: require_validate.TimeoutBudget.Deadline
+			})
 		});
-		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);
+		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: require_redact.joinUrl(request.baseUrl ?? this.#baseUrl, request.path) + require_redact.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: require_redact.joinUrl(request.baseUrl ?? this.#baseUrl, request.path) + require_redact.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({
 	/** Автоматический повтор не создаёт неприемлемого эффекта; обычно это чтение. */
@@ -1618,7 +1695,7 @@ const RetrySafety = Object.freeze({
 });
 function snapshotAnnotation(value, operationId, copies) {
 	if (value === null || typeof value !== "object" && typeof value !== "function") return value;
-	if (typeof value === "function") throw new require_errors.ItdConfigError(`annotations операции «${operationId}» не должны содержать функции`);
+	if (typeof value === "function") throw new require_validate.ItdConfigError(`annotations операции «${operationId}» не должны содержать функции`);
 	const existing = copies.get(value);
 	if (existing !== void 0) return existing;
 	if (Array.isArray(value)) {
@@ -1628,13 +1705,13 @@ function snapshotAnnotation(value, operationId, copies) {
 		return Object.freeze(copy);
 	}
 	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) throw new require_errors.ItdConfigError(`annotations операции «${operationId}» должны состоять из обычных объектов, массивов и примитивов`);
+	if (prototype !== Object.prototype && prototype !== null) throw new require_validate.ItdConfigError(`annotations операции «${operationId}» должны состоять из обычных объектов, массивов и примитивов`);
 	const copy = Object.create(prototype);
 	copies.set(value, copy);
 	for (const key of Reflect.ownKeys(value)) {
 		const descriptor = Object.getOwnPropertyDescriptor(value, key);
 		if (!descriptor?.enumerable) continue;
-		if (!("value" in descriptor)) throw new require_errors.ItdConfigError(`annotations операции «${operationId}» не должны содержать getters или setters`);
+		if (!("value" in descriptor)) throw new require_validate.ItdConfigError(`annotations операции «${operationId}» не должны содержать getters или setters`);
 		Object.defineProperty(copy, key, {
 			value: snapshotAnnotation(descriptor.value, operationId, copies),
 			enumerable: true,
@@ -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,23 +1767,30 @@ function resolveRetryPolicy(request, catalog) {
 	};
 }
 /**
+* Ошибка, после которой повтор невозможен в принципе: отмена либо истёкший общий срок операции.
+* Таймаут отдельной попытки сюда не входит — он повторяется как сетевой сбой.
+*/
+function isTerminal(error) {
+	return error instanceof require_validate.ItdAbortError || error instanceof require_validate.ItdTimeoutError && error.budget === require_validate.TimeoutBudget.Deadline;
+}
+/**
 * Стоит ли повторять запрос после этой ошибки.
 *
 * `429` гарантирует, что операция не была обработана, поэтому допускает даже unsafe retry.
-* Обрыв сети, timeout и `5xx` такой гарантии не дают и требуют safe/idempotent операции.
+* Обрыв сети, таймаут попытки и `5xx` такой гарантии не дают и требуют safe/idempotent операции.
 * Ошибка подготовки файла возникает до обращения к серверу и потому зависит только от
 * собственного признака retryable и повторяемости тела.
 */
 function isRetryable(error, policy) {
-	if (error instanceof require_errors.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 require_errors.ItdApiError) {
+	if (error instanceof require_validate.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;
+	if (error instanceof require_validate.ItdNetworkError || error instanceof require_validate.ItdTimeoutError) return repeatableOperation;
+	if (error instanceof require_validate.ItdFileError) return error.retryable;
 	return false;
 }
 /** Экспоненциальная пауза со случайным разбросом. */
@@ -1726,19 +1810,21 @@ 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 require_errors.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 require_errors.ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
+		if (error instanceof require_validate.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
+/** Сигнал для запроса без lifecycle: никогда не срабатывает. */
+const IDLE_SIGNAL = new AbortController().signal;
 /** Ожидание повтора, которое уважает отмену запроса. */
 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("Запрос отменён во время ожидания повтора"));
+	if (signal.aborted) return Promise.reject(new require_validate.ItdAbortError("Запрос отменён во время ожидания повтора"));
 	return new Promise((resolve, reject) => {
 		const cancel = clock.schedule(() => {
 			signal.removeEventListener("abort", onAbort);
@@ -1746,12 +1832,45 @@ function sleep(clock, ms, signal) {
 		}, ms);
 		const onAbort = () => {
 			cancel();
-			reject(new require_errors.ItdAbortError("Запрос отменён во время ожидания повтора"));
+			reject(new require_validate.ItdAbortError("Запрос отменён во время ожидания повтора"));
 		};
 		signal.addEventListener("abort", onAbort, { once: true });
 	});
 }
 /**
+* Слой плагинов: обёртки логической операции.
+*
+* 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,12 +1986,12 @@ 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 || !require_errors.isItdApiError(error) || error.status !== 401) throw error;
+			if (request.skipAuthRefresh || recovery.recovered || preparationFailed || !require_validate.isItdApiError(error) || error.status !== 401) throw error;
 			const pending = auth.recover();
 			if (!await (request.signal ? waitForRequest(pending, request.signal) : pending)) throw error;
 			recovery.recovered = true;
@@ -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 (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);
+	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 (require_errors.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 && require_validate.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;
@@ -2047,7 +2162,7 @@ function readPlainTextErrorCode(value) {
 function collectFieldErrors(source) {
 	const result = {};
 	const errors = source.errors;
-	if (isRecord(errors)) {
+	if (require_validate.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;
@@ -2055,7 +2170,7 @@ function collectFieldErrors(source) {
 	}
 	const violations = source.violations;
 	if (Array.isArray(violations)) for (const violation of violations) {
-		if (!isRecord(violation)) continue;
+		if (!require_validate.isRecord(violation)) continue;
 		const field = asString(violation.field) ?? asString(violation.property);
 		const message = asString(violation.message);
 		if (!field || !message) continue;
@@ -2088,7 +2203,7 @@ function parseErrorBody(body, status, statusText = "") {
 			userId: void 0
 		};
 	}
-	if (!isRecord(body)) return {
+	if (!require_validate.isRecord(body)) return {
 		code: "UNKNOWN_ERROR",
 		message: fallbackMessage,
 		detail: void 0,
@@ -2107,7 +2222,7 @@ function parseErrorBody(body, status, statusText = "") {
 			userId: void 0
 		};
 	}
-	const inner = isRecord(body.error) ? body.error : body;
+	const inner = require_validate.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",
@@ -2174,30 +2289,30 @@ function getRequestId(headers) {
 }
 /** Соответствие кода ошибки конкретному классу. Приоритетнее, чем 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
+	VALIDATION_ERROR: require_validate.ItdValidationError,
+	RATE_LIMIT_EXCEEDED: require_validate.ItdRateLimitError,
+	UNAUTHORIZED: require_validate.ItdAuthError,
+	SESSION_EXPIRED: require_validate.ItdAuthError,
+	SESSION_REVOKED: require_validate.ItdAuthError,
+	SESSION_INVALID_REFRESH_TOKEN: require_validate.ItdAuthError,
+	REFRESH_TOKEN_MISSING: require_validate.ItdAuthError,
+	SESSION_NOT_FOUND: require_validate.ItdAuthError,
+	ACCOUNT_INVALID_CREDENTIALS: require_validate.ItdAuthError,
+	ACCESS_DENIED: require_validate.ItdForbiddenError,
+	ENTITY_NOT_FOUND: require_validate.ItdNotFoundError,
+	NOT_FOUND: require_validate.ItdNotFoundError,
+	ENTITY_ALREADY_EXISTS: require_validate.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;
+	if (status === 401) return require_validate.ItdAuthError;
+	if (status === 403) return require_validate.ItdForbiddenError;
+	if (status === 404) return require_validate.ItdNotFoundError;
+	if (status === 409) return require_validate.ItdConflictError;
+	if (status === 422) return require_validate.ItdValidationError;
+	if (status === 429) return require_validate.ItdRateLimitError;
+	if (status >= 500) return require_validate.ItdServerError;
+	return require_validate.ItdApiError;
 }
 /**
 * Готовит тело ответа к сохранению в `ItdApiError.raw`.
@@ -2208,7 +2323,7 @@ function classByStatus(status) {
 * значения секретов заменяются заглушкой.
 */
 function safeRawBody(body) {
-	if (!isRecord(body) || body.type !== "validation" || !isRecord(body.found)) return body;
+	if (!require_validate.isRecord(body) || body.type !== "validation" || !require_validate.isRecord(body.found)) return body;
 	return {
 		...body,
 		found: require_redact.redactBody(body.found)
@@ -2239,7 +2354,7 @@ function createApiError(context) {
 		response: context.response,
 		retryAfter: parseRetryAfter(context.headers?.get("retry-after"), context.now)
 	};
-	if (parsed.code === "PHONE_VERIFICATION_REQUIRED") return new require_errors.ItdPhoneVerificationError({
+	if (parsed.code === "PHONE_VERIFICATION_REQUIRED") return new require_validate.ItdPhoneVerificationError({
 		...init,
 		userId: parsed.userId
 	});
@@ -2252,7 +2367,7 @@ function setHeader(headers, name, value) {
 	try {
 		headers.set(name, value);
 	} catch (cause) {
-		throw new require_errors.ItdConfigError(`Некорректный HTTP-заголовок ${JSON.stringify(name)}: проверьте его имя и значение.`, { cause });
+		throw new require_validate.ItdConfigError(`Некорректный HTTP-заголовок ${JSON.stringify(name)}: проверьте его имя и значение.`, { cause });
 	}
 }
 /** Тело, которое отправляется как есть, без сериализации в JSON. */
@@ -2281,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;
@@ -2316,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 require_validate.ItdTimeoutError({
+					timeout,
+					method,
+					path: request.path,
+					budget: require_validate.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 require_errors.ItdError ? this.#toTransportError(error, abort, request, method, timeout) : new require_errors.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 require_validate.ItdError ? this.#toTransportError(attempt, error) : new require_validate.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 && require_redact.isLevelEnabled(logger, require_redact.LogLevel.Debug)) logger.debug(`→ ${attempt.method} ${request.path}`, {
 				headers: require_redact.redactHeaders(headers),
 				body: request.bodyFactory ? "[повторяемое тело]" : require_redact.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(),
@@ -2459,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 require_redact.joinUrl(base, request.path) + require_redact.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 require_errors.ItdConfigError("body и bodyFactory нельзя задавать одновременно");
+			if (request.body !== void 0 && request.body !== null) throw new require_validate.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;
@@ -2535,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 require_redact.joinUrl(base, request.path) + require_redact.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 require_errors.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;
-			return new require_errors.ItdAbortError(`Запрос ${method} ${request.path} отменён`, reason !== void 0 ? { cause: reason } : void 0);
+			if (reason instanceof require_validate.ItdTimeoutError) return reason;
+			return new require_validate.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)}`, {
+		if (error instanceof require_validate.ItdError) return error;
+		return new require_validate.ItdNetworkError(`Не удалось выполнить ${method} ${request.path}: ${describe(error)}`, {
 			method,
 			path: request.path,
 			cause: error
@@ -2612,6 +2724,7 @@ var Transport = class {
 /** Имена стадий обработки запроса в порядке выполнения. @internal */
 const ClientRuntimeStage = Object.freeze({
 	OperationPlugins: "operation_plugins",
+	Decode: "decode",
 	Services: "services",
 	AuthPreflight: "auth_preflight",
 	Retry: "retry",
@@ -2659,14 +2772,27 @@ function createClientRuntime(options, internals) {
 			path: request.path
 		}) ?? catalog.bucketOf(request.operationId);
 	};
-	const queueKeyFor = (request) => requestQueueKey(request, (target) => ({
-		destination: require_redact.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 = require_redact.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) => {
@@ -2675,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)
@@ -2699,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,
@@ -2712,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,
@@ -2756,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 {
@@ -2790,12 +2923,11 @@ function createClientRuntime(options, internals) {
 		},
 		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(), запрос отменён"));
+			lifetime.abort(new require_validate.ItdAbortError("Клиент освобождён через dispose(), запрос отменён"));
 			if (ownsQueues) queues?.clear();
 			auth.dispose();
 			await plugins.dispose();
@@ -3416,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
@@ -3796,7 +3931,7 @@ function isKnownNotificationType(type) {
 //#endregion
 //#region src/notifications/normalize.ts
 function asActor(value) {
-	if (!isRecord(value)) return void 0;
+	if (!require_validate.isRecord(value)) return void 0;
 	const id = asString(value.id);
 	if (!id) return void 0;
 	return {
@@ -3836,8 +3971,8 @@ function readActors(source) {
 * ```
 */
 function normalizeNotification(input) {
-	const source = isRecord(input) ? input : {};
-	const payload = isRecord(source.payload) ? source.payload : source;
+	const source = require_validate.isRecord(input) ? input : {};
+	const payload = require_validate.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);
@@ -3869,7 +4004,7 @@ function normalizeNotification(input) {
 * счётчик непрочитанных и признак звука.
 */
 function readNotificationEvent(data) {
-	const source = isRecord(data) ? data : {};
+	const source = require_validate.isRecord(data) ? data : {};
 	return {
 		notification: normalizeNotification(data),
 		unreadCount: typeof source.unreadCount === "number" ? source.unreadCount : void 0,
@@ -3882,8 +4017,8 @@ function readNotificationEvent(data) {
 * Возвращает `undefined`, если сервер прислал событие без вложенного `payload`.
 */
 function readUnreadCountEvent(data) {
-	if (!isRecord(data)) return void 0;
-	const payload = isRecord(data.payload) ? data.payload : void 0;
+	if (!require_validate.isRecord(data)) return void 0;
+	const payload = require_validate.isRecord(data.payload) ? data.payload : void 0;
 	if (!payload) return void 0;
 	return typeof payload.count === "number" ? payload.count : void 0;
 }
@@ -3924,7 +4059,6 @@ function localDeviceId() {
 function anonymousAuth() {
 	return {
 		token: () => Promise.resolve(null),
-		prepare: () => Promise.resolve(),
 		currentHeaders: () => ({}),
 		recover: () => Promise.resolve(false),
 		deviceId: localDeviceId(),
@@ -3946,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(),
@@ -4236,6 +4369,12 @@ Object.defineProperty(exports, "OPERATIONS", {
 		return OPERATIONS;
 	}
 });
+Object.defineProperty(exports, "OperationMethod", {
+	enumerable: true,
+	get: function() {
+		return OperationMethod;
+	}
+});
 Object.defineProperty(exports, "QrLocationPrecision", {
 	enumerable: true,
 	get: function() {
@@ -4398,18 +4537,6 @@ Object.defineProperty(exports, "isKnownNotificationType", {
 		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, "mergeService", {
 	enumerable: true,
 	get: function() {
@@ -4500,12 +4627,6 @@ Object.defineProperty(exports, "requestAbortError", {
 		return requestAbortError;
 	}
 });
-Object.defineProperty(exports, "requireOptionalBoolean", {
-	enumerable: true,
-	get: function() {
-		return requireOptionalBoolean;
-	}
-});
 Object.defineProperty(exports, "resolveNotificationUrl", {
 	enumerable: true,
 	get: function() {
@@ -4543,4 +4664,4 @@ Object.defineProperty(exports, "voidResult", {
 	}
 });
 
-//# sourceMappingURL=url-BNTKqBMB.cjs.map
+//# sourceMappingURL=url-DTgkCWv5.cjs.map