itd-api 0.9.1 → 0.9.3

package/dist/shared/{url-CzHqE-Fg.cjs → url-D6wsXm1T.cjs}

@@ -1,5 +1,5 @@
 const require_errors = require("./errors-BmP3TKoW.cjs");
-const require_redact = require("./redact-BP00URmQ.cjs");
+const require_redact = require("./redact-lAmck1Z6.cjs");
 //#region src/core/async-dispose.ts
 /**
 * Подставляет метод `await using` там, где `Symbol.asyncDispose` отсутствует.
@@ -85,7 +85,7 @@ function requireOptionalBoolean(value, name) {
 //#endregion
 //#region src/core/version.ts
 /** Версия библиотеки. Попадает в `User-Agent`. */
-const LIBRARY_VERSION = "0.9.1";
+const LIBRARY_VERSION = "0.9.3";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -386,6 +386,12 @@ const RELATION_FIELDS = [
 	"before",
 	"after"
 ];
+const PLUGIN_NAME_PART = "[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*";
+const PLUGIN_NAME_PATTERN = new RegExp(`^(?:${PLUGIN_NAME_PART}|@${PLUGIN_NAME_PART}(?:/${PLUGIN_NAME_PART})?(?::${PLUGIN_NAME_PART})?)$`);
+const PLUGIN_NAME_FORMAT = "name, @package[:addon] или @scope/package[:addon] с разделителями -, _ и .";
+function isPluginName(value) {
+	return PLUGIN_NAME_PATTERN.test(value);
+}
 function validateNameList(plugin, field) {
 	const values = plugin[field];
 	if (values === void 0) return;
@@ -393,6 +399,7 @@ function validateNameList(plugin, 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}»`);
 		seen.add(value);
@@ -411,6 +418,7 @@ function validatePluginDefinition(plugin) {
 	if (typeof plugin?.install !== "function") throw new require_errors.ItdConfigError("Плагин должен быть объектом с методом install()");
 	const name = plugin.name;
 	if (typeof name !== "string" || name.trim() === "") throw new require_errors.ItdConfigError("У плагина должно быть непустое имя");
+	if (!isPluginName(name)) throw new require_errors.ItdConfigError(`Имя плагина «${name}» должно соответствовать ${PLUGIN_NAME_FORMAT}`);
 	for (const field of RELATION_FIELDS) validateNameList(plugin, field);
 }
 function addEdge(from, to, edges, indegree) {
@@ -649,7 +657,7 @@ var PluginRegistry = class {
 	*
 	* @param execute выполнение логической операции, вызываемое самым внутренним transformer
 	*/
-	async run(request, execute) {
+	async run(request, execute, signal) {
 		const ordered = this.#ordered;
 		if (ordered.length === 0) return execute(request);
 		const entries = [...ordered];
@@ -661,6 +669,7 @@ var PluginRegistry = class {
 		const operationId = request.operationId;
 		const method = request.method.toUpperCase();
 		const retrySafety = request.retrySafety;
+		const context = Object.freeze({ signal });
 		const scoped = (current) => {
 			const prepared = current.retrySafety === void 0 ? {
 				...current,
@@ -683,7 +692,7 @@ var PluginRegistry = class {
 				called = true;
 				validateContract(prepared);
 				return next(scoped(prepared));
-			});
+			}, context);
 		}, (current) => {
 			validateContract(current);
 			return execute(scoped(current));
@@ -1067,8 +1076,8 @@ function seedLimit(bucket, options) {
 * Очереди по парам «направление — серверный счётчик частоты».
 *
 * Направление — origin уже разрешённого URL: разные локальные имена одного хоста делят
-* лимит, а запрос с разовым внешним `baseUrl` не попадает в основную очередь. Мощность
-* карты ограничена каталогом операций, поэтому ни TTL, ни вытеснение не нужны.
+* лимит, а запрос с разовым внешним `baseUrl` не попадает в основную очередь. Созданные
+* очереди сохраняются до `clear()`/`dispose()`, чтобы не терять известное состояние лимитов.
 *
 * @internal
 */
@@ -1278,10 +1287,117 @@ var ServiceRegistry = class {
 	}
 };
 //#endregion
+//#region src/core/plugins/hooks.ts
+/** Проверяет наличие публичного hook, не создавая дорогой контекст. @internal */
+function hasRequestHook(hooks, field) {
+	return hooks[field] !== void 0;
+}
+/** Последовательно вызывает публичный hook конструктора. @internal */
+async function dispatchRequestHook(hooks, field, context) {
+	const hook = hooks[field];
+	await hook?.(context);
+}
+//#endregion
+//#region src/core/execution/lifecycle.ts
+/** Объединяет отмену вызова, завершение клиента и общий таймаут логической операции. @internal */
+function createRequestAbortScope(signal, lifetimeSignal, timeout, clock) {
+	const controller = new AbortController();
+	let timeoutReached = false;
+	const link = (source) => {
+		if (!source) return void 0;
+		if (source.aborted) {
+			controller.abort(source.reason);
+			return;
+		}
+		const onAbort = () => controller.abort(source.reason);
+		source.addEventListener("abort", onAbort, { once: true });
+		return () => source.removeEventListener("abort", onAbort);
+	};
+	const detach = [link(signal), link(lifetimeSignal)];
+	const cancelTimer = timeout > 0 ? clock.schedule(() => {
+		timeoutReached = true;
+		controller.abort();
+	}, timeout) : void 0;
+	return {
+		signal: controller.signal,
+		timedOut: () => timeoutReached,
+		cleanup: () => {
+			cancelTimer?.();
+			for (const remove of detach) remove?.();
+		}
+	};
+}
+/** Прерывает только ожидание; исходный промис может корректно завершить общую фоновую работу. @internal */
+function waitForRequest(promise, signal) {
+	if (signal.aborted) {
+		promise.catch(() => {});
+		return Promise.reject(new require_errors.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 }));
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	return Promise.race([promise, aborted]).finally(() => {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	});
+}
+/** Возвращает публичную ошибку, соответствующую причине остановки операции. @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;
+}
+//#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");
+/** Возвращает общее для всех retry состояние восстановления авторизации. @internal */
+function requestAuthRecoveryState(request) {
+	const internal = request;
+	const current = internal[REQUEST_AUTH_RECOVERY_STATE];
+	if (current) return current;
+	const state = {
+		recovered: false,
+		preparationErrors: /* @__PURE__ */ new Set()
+	};
+	internal[REQUEST_AUTH_RECOVERY_STATE] = state;
+	return state;
+}
+/** Создаёт общую для копий логического запроса отметку вызова `onError`. @internal */
+function trackRequestErrorObservation(request) {
+	const internal = request;
+	internal[REQUEST_ERROR_OBSERVATION_STATE] ??= {
+		errors: /* @__PURE__ */ new Set(),
+		lifecycleAbortedDuringNotification: false
+	};
+}
+/** Отмечает, что ошибка логического запроса уже была передана в `onError`. @internal */
+function markRequestErrorObserved(request, error) {
+	trackRequestErrorObservation(request);
+	request[REQUEST_ERROR_OBSERVATION_STATE]?.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;
+}
+/** Нужно ли верхней границе не запускать тот же `onError` повторно после отмены. @internal */
+function wasRequestErrorNotificationAborted(request) {
+	return request[REQUEST_ERROR_OBSERVATION_STATE]?.lifecycleAbortedDuringNotification ?? false;
+}
 /** Один раз присваивает низкоуровневому запросу семантический ID до входа в middleware. */
 function identifyRequest(request) {
 	return request.operationId === void 0 ? {
@@ -1378,10 +1494,20 @@ var HttpClient = class {
 	#handler;
 	#plugins;
 	#baseUrl;
+	#timeout;
+	#clock;
+	#lifetimeSignal;
+	#hooks;
+	#assertActive;
 	constructor(deps) {
 		this.#handler = deps.handler;
 		this.#plugins = deps.plugins;
 		this.#baseUrl = deps.baseUrl;
+		this.#timeout = deps.timeout;
+		this.#clock = deps.clock;
+		this.#lifetimeSignal = deps.lifetimeSignal;
+		this.#hooks = deps.hooks;
+		this.#assertActive = deps.assertActive;
 	}
 	/** Базовый URL, к которому обращается клиент. */
 	get baseUrl() {
@@ -1398,7 +1524,7 @@ var HttpClient = class {
 	*/
 	request(options) {
 		const request = identifyRequest(options);
-		return this.#plugins.run(request, (prepared) => this.#handler(prepared));
+		return this.#runWithLifecycle(request, (prepared) => this.#handler(prepared));
 	}
 	/** Выполняет контракт операции; `next()` плагина возвращает результат после `read`. */
 	execute(operation, options) {
@@ -1411,7 +1537,7 @@ var HttpClient = class {
 			method: operation.method,
 			retrySafety: options.retrySafety ?? operation.retrySafety
 		});
-		return this.#plugins.run(request, async (prepared) => operation.read(await this.#handler(prepared), prepared));
+		return this.#runWithLifecycle(request, async (prepared) => operation.read(await this.#handler(prepared), prepared));
 	}
 	/** Выполняет внутреннюю операцию финализации после начала `ItdClient.dispose()`. @internal */
 	cleanupOperation(operation, options) {
@@ -1421,24 +1547,65 @@ var HttpClient = class {
 			method: operation.method,
 			retrySafety: options.retrySafety ?? operation.retrySafety
 		});
-		return this.#plugins.run(request, async (prepared) => {
+		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);
+		const startedAt = this.#clock.now();
+		trackRequestErrorObservation(request);
+		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);
+		} 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;
+				}
+			}
+			throw failure;
+		} finally {
+			scope.cleanup();
+		}
 	}
 };
 //#endregion
-//#region src/core/plugins/hooks.ts
-/** Проверяет наличие публичного hook, не создавая дорогой контекст. @internal */
-function hasRequestHook(hooks, field) {
-	return hooks[field] !== void 0;
-}
-/** Последовательно вызывает публичный hook конструктора. @internal */
-async function dispatchRequestHook(hooks, field, context) {
-	const hook = hooks[field];
-	await hook?.(context);
-}
-//#endregion
 //#region src/core/operation.ts
 /** Семантическая безопасность автоматического повтора операции. */
 const RetrySafety = Object.freeze({
@@ -1638,6 +1805,19 @@ function createServicesMiddleware(registry) {
 		return next(prepared);
 	};
 }
+/** Однократная 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);
+	};
+}
 /**
 * Подготавливает auth state до входа транспортной попытки в очередь.
 *
@@ -1646,7 +1826,15 @@ function createServicesMiddleware(registry) {
 */
 function createAuthPreparationMiddleware(auth) {
 	return async (request, next) => {
-		if (!request.skipAuth) await auth.prepare();
+		if (!request.skipAuth) {
+			const pending = auth.prepare();
+			try {
+				await (request.signal ? waitForRequest(pending, request.signal) : pending);
+			} catch (error) {
+				requestAuthRecoveryState(request).preparationErrors.add(error);
+				throw error;
+			}
+		}
 		return next(request);
 	};
 }
@@ -1681,11 +1869,15 @@ function createAttemptMiddleware() {
 */
 function createAuthRecoveryMiddleware(auth) {
 	return async (request, next) => {
+		const recovery = requestAuthRecoveryState(request);
 		try {
 			return await next(request);
 		} catch (error) {
-			if (request.skipAuthRefresh || !require_errors.isItdApiError(error) || error.status !== 401) throw error;
-			if (!await auth.recover()) throw error;
+			const preparationFailed = recovery.preparationErrors.delete(error);
+			if (request.skipAuthRefresh || recovery.recovered || preparationFailed || !require_errors.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;
 			return next({
 				...request,
 				skipAuthRefresh: true
@@ -1740,8 +1932,9 @@ function createRetryMiddleware(deps) {
 			else retryAttempt += 1;
 			const delay = nextDelay(error, retryAttempt, rateLimitAttempt, trackedRequest, policy, backoff);
 			if (delay === void 0) throw error;
-			await dispatchRequestHook(deps.hooks, "onRetry", {
+			const notification = dispatchRequestHook(deps.hooks, "onRetry", {
 				operationId: request.operationId,
+				signal: request.signal,
 				method,
 				path: request.path,
 				url: deps.buildUrl(request),
@@ -1753,6 +1946,7 @@ function createRetryMiddleware(deps) {
 				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);
 		}
@@ -2099,39 +2293,6 @@ function abortable(promise, signal) {
 	});
 }
 /**
-* Объединяет пользовательский `AbortSignal`, сигнал жизни клиента и таймаут.
-*
-* Реализовано вручную, а не через `AbortSignal.any`: последний появился только в Node 20,
-* а библиотека поддерживает Node 18. Причина отмены переносится от источника как есть.
-*/
-function createAbortBundle(userSignal, lifetimeSignal, timeout, clock) {
-	const controller = new AbortController();
-	let timedOut = false;
-	const link = (source) => {
-		if (!source) return void 0;
-		if (source.aborted) {
-			controller.abort(source.reason);
-			return;
-		}
-		const onAbort = () => controller.abort(source.reason);
-		source.addEventListener("abort", onAbort, { once: true });
-		return () => source.removeEventListener("abort", onAbort);
-	};
-	const unlink = [link(userSignal), link(lifetimeSignal)];
-	const cancelTimer = timeout > 0 ? clock.schedule(() => {
-		timedOut = true;
-		controller.abort();
-	}, timeout) : void 0;
-	return {
-		signal: controller.signal,
-		timedOut: () => timedOut,
-		cleanup: () => {
-			cancelTimer?.();
-			for (const detach of unlink) detach?.();
-		}
-	};
-}
-/**
 * Единственное место, откуда библиотека ходит в сеть.
 *
 * Отвечает за сборку URL, заголовки, cookie, таймауты, разбор ответа и превращение любой
@@ -2161,44 +2322,58 @@ var Transport = class {
 		const request = identifyRequest(input);
 		const method = request.method.toUpperCase();
 		const url = this.buildUrl(request);
-		const headers = await this.#buildHeaders(request, url);
 		const attempt = request.attempt ?? 1;
 		const timeout = request.timeout ?? this.#config.timeout;
-		const abort = createAbortBundle(request.signal, this.#deps.lifetimeSignal, timeout, this.#config.clock);
+		const abort = createRequestAbortScope(request.signal, this.#deps.lifetimeSignal, timeout, this.#config.clock);
 		const startedAt = this.#config.clock.now();
 		let cleanupBody;
 		try {
+			const headers = await abortable(this.#buildHeaders(request, url), abort.signal).catch((error) => {
+				throw this.#toTransportError(error, abort, request, method, timeout);
+			});
 			let body;
 			try {
 				const prepared = await this.#prepareBody(request, headers, abort.signal, attempt);
 				body = prepared.body;
 				cleanupBody = prepared.cleanup;
 			} catch (error) {
-				const failure = this.#toTransportError(error, abort, request, method, timeout);
+				const 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 dispatchRequestHook(this.#config.hooks, "onError", {
+				await this.#dispatchErrorHook(request, {
 					...context,
 					duration: this.#config.clock.now() - startedAt,
 					error: failure
-				});
+				}, abort, timeout);
 				throw failure;
 			}
 			const context = {
 				operationId: request.operationId,
+				signal: abort.signal,
 				method,
 				path: request.path,
 				url,
 				headers,
 				attempt
 			};
-			await dispatchRequestHook(this.#config.hooks, "onRequest", context);
+			try {
+				await abortable(dispatchRequestHook(this.#config.hooks, "onRequest", context), abort.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);
+				throw failure;
+			}
 			this.#config.logger?.debug(`→ ${method} ${request.path}`, {
 				headers: require_redact.redactHeaders(headers),
 				body: request.bodyFactory ? "[повторяемое тело]" : require_redact.redactBody(request.body)
@@ -2226,11 +2401,11 @@ var Transport = class {
 				});
 			} catch (error) {
 				const duration = this.#config.clock.now() - startedAt;
-				await dispatchRequestHook(this.#config.hooks, "onError", {
+				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;
 			}
@@ -2238,14 +2413,30 @@ var Transport = class {
 				const { limit, remaining } = readRateLimit(response.headers);
 				this.#deps.onRateLimit(limit, remaining, request);
 			}
-			if (this.#config.useCookieJar) this.#deps.cookies?.setFromResponse(url, response);
-			if (response.ok && hasRequestHook(this.#config.hooks, "onResponse")) await dispatchRequestHook(this.#config.hooks, "onResponse", {
-				...context,
-				status: response.status,
-				duration: this.#config.clock.now() - startedAt,
-				response: response.clone()
-			});
-			const payload = await this.#readBodyOrFail(response, context, request, method, abort, timeout);
+			if (this.#config.useCookieJar) (request.cookieJar ?? this.#deps.cookies)?.setFromResponse(response.url || url, response);
+			if (response.ok && hasRequestHook(this.#config.hooks, "onResponse")) {
+				const hookResponse = response.clone();
+				try {
+					await abortable(dispatchRequestHook(this.#config.hooks, "onResponse", {
+						...context,
+						status: response.status,
+						duration: this.#config.clock.now() - startedAt,
+						response: hookResponse
+					}), abort.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);
+					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;
 			if (!response.ok) {
 				const error = createApiError({
@@ -2258,11 +2449,11 @@ var Transport = class {
 					response,
 					body: payload
 				});
-				await dispatchRequestHook(this.#config.hooks, "onError", {
+				await this.#dispatchErrorHook(request, {
 					...context,
 					duration,
 					error
-				});
+				}, abort, timeout);
 				this.#config.logger?.warn(`← ${response.status} ${method} ${request.path} (${duration} мс): ${error.message}`);
 				throw error;
 			}
@@ -2278,6 +2469,21 @@ var Transport = class {
 			}
 		}
 	};
+	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);
+		}
+	}
 	/** Подготавливает тело внутри попытки, чтобы поток можно было открыть заново при retry. */
 	async #prepareBody(request, headers, signal, attempt) {
 		if (request.bodyFactory) {
@@ -2320,18 +2526,17 @@ var Transport = class {
 		};
 	}
 	/** Читает тело и преобразует ошибку чтения в транспортную ошибку библиотеки. */
-	async #readBodyOrFail(response, context, request, method, abort, timeout) {
-		const startedAt = this.#config.clock.now();
+	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 dispatchRequestHook(this.#config.hooks, "onError", {
+			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;
 		}
@@ -2349,14 +2554,14 @@ var Transport = class {
 	* Собирает общие заголовки клиента: `User-Agent`, идентификатор устройства,
 	* заголовки конфигурации и cookie для указанного адреса.
 	*/
-	async platformHeaders(url) {
+	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 && this.#deps.cookies) {
-			const cookie = this.#deps.cookies.getHeader(url);
+		if (this.#config.useCookieJar && cookieJar) {
+			const cookie = cookieJar.getHeader(url);
 			if (cookie) setHeader(headers, "Cookie", cookie);
 		}
 		return headers;
@@ -2366,7 +2571,7 @@ var Transport = class {
 	* Заголовки вызова применяются последними.
 	*/
 	async #buildHeaders(request, url) {
-		const headers = await this.platformHeaders(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);
@@ -2398,6 +2603,7 @@ var Transport = class {
 const ClientRuntimeStage = Object.freeze({
 	OperationPlugins: "operation_plugins",
 	Services: "services",
+	AuthPreflight: "auth_preflight",
 	Retry: "retry",
 	AuthRecovery: "auth_recovery",
 	AuthPreparation: "auth_preparation",
@@ -2473,6 +2679,10 @@ function createClientRuntime(options, internals) {
 			name: ClientRuntimeStage.Services,
 			middleware: createServicesMiddleware(services)
 		},
+		{
+			name: ClientRuntimeStage.AuthPreflight,
+			middleware: createAuthPreflightMiddleware(() => auth)
+		},
 		{
 			name: ClientRuntimeStage.Retry,
 			middleware: createRetryMiddleware({
@@ -2523,7 +2733,12 @@ function createClientRuntime(options, internals) {
 	const http = new HttpClient({
 		handler: clientHandler,
 		plugins,
-		baseUrl: config.baseUrl
+		baseUrl: config.baseUrl,
+		timeout: config.timeout,
+		clock: config.clock,
+		lifetimeSignal: lifetime.signal,
+		hooks: config.hooks,
+		assertActive: () => internals.assertActive?.("выполнить новый запрос")
 	});
 	auth = internals.auth({
 		config,
@@ -2741,11 +2956,6 @@ const OPERATIONS = freezeOperations({
 		retrySafety: RetrySafety.Safe,
 		bucket: "users"
 	},
-	"users.search": {
-		method: "GET",
-		retrySafety: RetrySafety.Safe,
-		bucket: "users"
-	},
 	"users.whoToFollow": {
 		method: "GET",
 		retrySafety: RetrySafety.Safe,
@@ -2982,11 +3192,6 @@ const OPERATIONS = freezeOperations({
 		retrySafety: RetrySafety.Safe,
 		bucket: "notifications"
 	},
-	"hashtags.search": {
-		method: "GET",
-		retrySafety: RetrySafety.Safe,
-		bucket: "hashtags"
-	},
 	"hashtags.trending": {
 		method: "GET",
 		retrySafety: RetrySafety.Safe,
@@ -4192,4 +4397,4 @@ Object.defineProperty(exports, "voidResult", {
 	}
 });
 
-//# sourceMappingURL=url-CzHqE-Fg.cjs.map
+//# sourceMappingURL=url-D6wsXm1T.cjs.map