itd-api 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_multi_storage = require("./multi-storage-D1keK2Op.cjs");
+const require_multi_storage = require("./multi-storage-C8R5Crwo.cjs");
 const require_storage = require("./storage-ycBqLBRB.cjs");
 const require_runtime = require("./runtime-CFEsf-jD.cjs");
 //#region src/core/emitter.ts
@@ -727,7 +727,7 @@ function normalizeBaseUrl(baseUrl) {
 //#endregion
 //#region src/core/version.ts
 /** Версия библиотеки. Попадает в `User-Agent`. */
-const LIBRARY_VERSION = "0.3.0";
+const LIBRARY_VERSION = "0.4.0";
 //#endregion
 //#region src/core/config.ts
 /** Базовый URL API итд.com. Домен записан в punycode: `итд.com`. */
@@ -1052,15 +1052,271 @@ function withLayerHeaders(request, headers) {
 	};
 }
 //#endregion
-//#region src/core/plugins.ts
-/** Пустой набор — отдаётся, пока плагинов нет, чтобы не заводить объект на каждый запрос. */
-const NO_KEYS = /* @__PURE__ */ new Set();
+//#region src/core/plugins/hooks.ts
+const REQUEST_HOOK_DISPATCHERS = /* @__PURE__ */ new WeakMap();
+const PLUGIN_HOOK_SCOPE = Symbol("itd-api.plugin-hooks");
+/** Создаёт динамический набор hooks, связанный с диспетчером registry. @internal */
+function createRequestHooks(dispatcher) {
+	const hooks = {};
+	REQUEST_HOOK_DISPATCHERS.set(hooks, dispatcher);
+	return hooks;
+}
+/** Привязывает к запросу неизменяемый снимок plugin hooks. @internal */
+function withRequestHookScope(request, hooks) {
+	const scoped = request;
+	return scoped[PLUGIN_HOOK_SCOPE] === hooks ? scoped : {
+		...request,
+		[PLUGIN_HOOK_SCOPE]: hooks
+	};
+}
+/** Читает снимок plugin hooks, привязанный к логическому запросу. @internal */
+function requestHookScope(request) {
+	return request[PLUGIN_HOOK_SCOPE] ?? [];
+}
+/**
+* Вызывает публичный хук, сохраняя привязанный к логическому запросу снимок плагинов.
+*
+* Обычные наборы хуков по-прежнему получают только публичный контекст. Дополнительный
+* аргумент используется исключительно внутренним составным набором PluginRegistry.
+*
+* @internal
+*/
+async function dispatchRequestHook(hooks, field, context, request) {
+	const dispatcher = REQUEST_HOOK_DISPATCHERS.get(hooks);
+	if (dispatcher) {
+		await dispatcher(field, context, request);
+		return;
+	}
+	const hook = hooks[field];
+	await hook?.(context);
+}
+//#endregion
+//#region src/core/retry.ts
+/**
+* Методы, повтор которых безопасен по определению.
+*
+* `DELETE` формально тоже идемпотентен, но его повтор после успеха вернёт `404`
+* и собьёт с толку — в список он не входит.
+*/
+const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+/**
+* Стоит ли повторять запрос после этой ошибки.
+*
+* Отдельно разобран `429`: он повторяется даже для запросов на запись, потому что
+* гарантирует, что запрос **не был обработан**. Обрыв сети и `5xx` такой гарантии не дают —
+* сервер мог успеть создать пост, — поэтому запись по умолчанию не повторяется.
+*/
+function isRetryable(error, method, retryWrites, retryNetworkWrite) {
+	if (error instanceof require_storage.ItdAbortError) return false;
+	const safeToRepeat = retryWrites || IDEMPOTENT_METHODS.has(method);
+	if (error instanceof require_storage.ItdApiError) {
+		if (error.status === 429) return true;
+		if (error.status >= 500) return safeToRepeat;
+		return false;
+	}
+	if (error instanceof require_storage.ItdNetworkError || error instanceof require_storage.ItdTimeoutError) return safeToRepeat || retryNetworkWrite;
+	if (error instanceof require_storage.ItdFileError) return error.retryable && (safeToRepeat || retryNetworkWrite);
+	return false;
+}
+/** Экспоненциальная пауза со случайным разбросом. */
+function backoffDelay(attempt, options, random) {
+	const exponential = options.baseDelay * 2 ** (attempt - 1);
+	const capped = Math.min(exponential, options.maxDelay);
+	const spread = capped * options.jitter * (random() * 2 - 1);
+	return Math.max(0, Math.round(capped + spread));
+}
+/**
+* Собирает планировщик повторов для транспорта.
+*
+* Поведение при `Retry-After`: пауза, названная сервером, соблюдается точно — она
+* авторитетнее нашего расчёта. Но если сервер просит ждать дольше, чем `maxDelay`,
+* повтор **не выполняется вовсе**: молча спать десять минут внутри вызова библиотека
+* не должна, лучше отдать {@link ItdRateLimitError} и дать решить вызывающему коду.
+*
+* @param options настройки повторов после подстановки значений по умолчанию
+* @param random источник случайности; подменяется в тестах ради предсказуемости
+*
+* @example
+* ```ts
+* const scheduler = createRetryScheduler(config.retry);
+* const delay = scheduler(error, 1, 'GET'); // 500 мс ± 30%
+* ```
+*/
+function createRetryScheduler(options, random = Math.random) {
+	return (error, attempt, method, retryNetworkWrite = false) => {
+		if (attempt >= options.attempts) return void 0;
+		if (options.shouldRetry) return options.shouldRetry(error, attempt) ? backoffDelay(attempt, options, random) : void 0;
+		if (!isRetryable(error, method, options.retryWrites, retryNetworkWrite)) return void 0;
+		if (error instanceof require_storage.ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
+		return backoffDelay(attempt, options, random);
+	};
+}
+//#endregion
+//#region src/core/middleware.ts
+/** Ожидание повтора, которое уважает отмену запроса. */
+function sleep(clock, ms, signal) {
+	if (!signal) return new Promise((resolve) => clock.schedule(resolve, ms));
+	if (signal.aborted) return Promise.reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
+	return new Promise((resolve, reject) => {
+		const cancel = clock.schedule(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			cancel();
+			reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Слой очереди: ограничение конкурентности и частоты.
+*
+* `skipQueue` пропускает запрос мимо очереди — так поступают служебные запросы, которые
+* порождены изнутри другого запроса и не могут ждать освободившегося слота.
+*
+* Очередь выбирается по запросу: у каждого сервиса платформы свой хост и свой лимит.
+*/
+function createQueueMiddleware(schedule) {
+	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
+}
+/**
+* Слой плагинов.
+*
+* Стоит снаружи повторов и внутри очереди: плагин должен увидеть запрос и ответ по одному
+* разу, независимо от числа попыток, — иначе, например, текст поста зашифруется дважды.
+*/
+function createPluginsMiddleware(plugins) {
+	return (request, next) => plugins.run(request, next);
+}
+/**
+* Слой сервисов.
+*
+* Запросу с полем `service` подставляет хост сервиса, его заголовки и `skipAuth`, если
+* сервис объявлен публичным. Заданный у запроса `baseUrl` не трогает.
+*
+* Стоит снаружи повторов и авторизации, чтобы выставленный здесь `skipAuth` был ей виден.
+*/
+function createServicesMiddleware(registry) {
+	return async (request, next) => {
+		const service = request.service === void 0 ? void 0 : registry.require(request.service);
+		let prepared = request;
+		if (request.baseUrl !== void 0) {
+			const baseUrl = normalizeBaseUrl(request.baseUrl);
+			if (baseUrl !== request.baseUrl) prepared = {
+				...prepared,
+				baseUrl
+			};
+			if (!(service?.baseUrl === baseUrl ? service.auth !== false : registry.isPrimarySite(baseUrl)) && prepared.skipAuth === void 0) prepared = {
+				...prepared,
+				skipAuth: true
+			};
+		}
+		if (!service) return next(prepared);
+		if (prepared.baseUrl === void 0) prepared = {
+			...prepared,
+			baseUrl: service.baseUrl
+		};
+		if (service.headers) prepared = withLayerHeaders(prepared, service.headers);
+		if (service.auth === false && prepared.skipAuth === void 0) prepared = {
+			...prepared,
+			skipAuth: true
+		};
+		return next(prepared);
+	};
+}
+async function applyAuth(request, deps) {
+	if (request.skipAuth) return request;
+	const headers = await deps.getAuthHeaders();
+	return Object.keys(headers).length > 0 ? withLayerHeaders(request, headers) : request;
+}
 /**
-* Имена, которые плагин заявить не может.
+* Слой авторизации.
 *
-* Заявленные опции ресурсы переносят в описание запроса поверх собранных полей, поэтому
-* имя из {@link RawRequestOptions} подменило бы путь, тело или заголовки любого вызова.
+* Подставляет заголовок `Authorization` и обрабатывает `401`: обновляет токен и повторяет
+* запрос ровно один раз. Стоит внутри повторов, поэтому обычным попыткам он не виден —
+* они уже работают со свежим токеном.
 */
+function createAuthMiddleware(deps) {
+	return async (request, next) => {
+		const authorized = await applyAuth(request, deps);
+		try {
+			return await next(authorized);
+		} catch (error) {
+			if (request.skipAuthRefresh || !deps.autoRefresh || !require_storage.isItdApiError(error) || error.status !== 401) throw error;
+			if (!await deps.onUnauthorized()) throw error;
+			return next(await applyAuth({
+				...request,
+				skipAuthRefresh: true
+			}, deps));
+		}
+	};
+}
+/**
+* Выбирает планировщик отката для конкретного запроса.
+*
+* `retry` у запроса переопределяет глобальную настройку: `false` выключает повторы,
+* объект задаёт свои. Обработка `429` от этого не зависит — она общая.
+*/
+function resolveBackoff(retry, global) {
+	if (retry === void 0) return global;
+	if (retry === false) return void 0;
+	const resolved = resolveRetry(retry);
+	return resolved ? createRetryScheduler(resolved) : void 0;
+}
+/**
+* Слой повторов.
+*
+* Ответ `429` обрабатывается отдельно от прочих ошибок лестницей пауз и с придержанием
+* всей очереди; сетевые сбои и `5xx` — экспоненциальным откатом. Настройка `retry`
+* у отдельного запроса имеет приоритет над глобальной.
+*/
+function createRetryMiddleware(deps) {
+	const globalScheduler = deps.retry ? createRetryScheduler(deps.retry) : void 0;
+	const nextDelay = (error, attempt, request, method, backoff) => {
+		if (require_storage.isItdRateLimitError(error)) {
+			const wait = error.retryAfter ?? deps.rateLimitDelays[attempt - 1];
+			if (wait === void 0) return void 0;
+			deps.pauseQueue?.(wait, request);
+			deps.logger?.debug(`лимит частоты, попытка ${attempt + 1} через ${wait} мс`);
+			return wait;
+		}
+		return backoff?.(error, attempt, method, request.retryNetworkWrite ?? false);
+	};
+	return async (request, next) => {
+		const method = request.method.toUpperCase();
+		const backoff = resolveBackoff(request.retry, globalScheduler);
+		for (let attempt = 1;; attempt++) try {
+			return await next({
+				...request,
+				attempt
+			});
+		} catch (error) {
+			const delay = nextDelay(error, attempt, request, method, backoff);
+			if (delay === void 0) throw error;
+			await dispatchRequestHook(deps.hooks, "onRetry", {
+				method,
+				path: request.path,
+				url: deps.buildUrl(request),
+				headers: new Headers({
+					...request.layerHeaders,
+					...request.headers
+				}),
+				attempt,
+				error,
+				delay
+			}, request);
+			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${attempt + 1} через ${delay} мс`);
+			await sleep(deps.clock ?? systemClock, delay, request.signal);
+		}
+	};
+}
+//#endregion
+//#region src/core/plugins/order.ts
 const RESERVED_OPTION_KEYS = /* @__PURE__ */ new Set([
 	"signal",
 	"timeout",
@@ -1101,7 +1357,8 @@ function validateNameList(plugin, field) {
 		seen.add(value);
 	}
 }
-function validateHooks(plugin, hooks) {
+/** Проверяет набор hooks, переданный плагином. @internal */
+function validatePluginHooks(plugin, hooks) {
 	if (typeof hooks !== "object" || hooks === null) throw new require_storage.ItdConfigError(`плагин «${plugin}» передал в useHooks() не объект`);
 	for (const field of HOOK_FIELDS) if (hooks[field] !== void 0 && typeof hooks[field] !== "function") throw new require_storage.ItdConfigError(`плагин «${plugin}»: useHooks().${field} должен быть функцией`);
 }
@@ -1188,30 +1445,14 @@ function orderPluginDefinitions(plugins) {
 	if (ordered.length !== entries.length) throw new require_storage.ItdConfigError(`циклический порядок плагинов: ${entries.filter(({ plugin }) => (indegree.get(plugin.name) ?? 0) > 0).map(({ plugin }) => plugin.name).join(" → ")}`);
 	return ordered;
 }
-/** Проверяет, можно ли удалить плагин, не нарушив обязательные зависимости. @internal */
+/** Проверяет, можно ли удалить плагин без нарушения обязательных зависимостей. @internal */
 function assertPluginRemovable(plugins, name) {
 	const dependent = plugins.find((plugin) => plugin.requires?.includes(name));
 	if (dependent) throw new require_storage.ItdConfigError(`нельзя отключить плагин «${name}»: от него зависит «${dependent.name}»`);
 }
-const REQUEST_HOOK_DISPATCHERS = /* @__PURE__ */ new WeakMap();
-const PLUGIN_HOOK_SCOPE = Symbol("itd-api.plugin-hooks");
-/**
-* Вызывает публичный хук, сохраняя привязанный к логическому запросу снимок плагинов.
-*
-* Обычные наборы хуков по-прежнему получают только публичный контекст. Дополнительный
-* аргумент используется исключительно внутренним составным набором PluginRegistry.
-*
-* @internal
-*/
-async function dispatchRequestHook(hooks, field, context, request) {
-	const dispatcher = REQUEST_HOOK_DISPATCHERS.get(hooks);
-	if (dispatcher) {
-		await dispatcher(field, context, request);
-		return;
-	}
-	const hook = hooks[field];
-	await hook?.(context);
-}
+//#endregion
+//#region src/core/plugins/registry.ts
+const NO_KEYS = /* @__PURE__ */ new Set();
 /**
 * Список подключённых плагинов и собранная из них цепочка обёрток.
 *
@@ -1269,7 +1510,7 @@ var PluginRegistry = class {
 				transformers.push(transformer);
 			},
 			useHooks: (value) => {
-				validateHooks(plugin.name, value);
+				validatePluginHooks(plugin.name, value);
 				hooks.push({ ...value });
 			}
 		});
@@ -1349,293 +1590,62 @@ var PluginRegistry = class {
 	*
 	* Возвращённый объект динамический: подключение и отключение плагина начинает действовать
 	* со следующего логического запроса без пересоздания транспорта.
-	*/
-	hooks(base) {
-		const hooks = {};
-		REQUEST_HOOK_DISPATCHERS.set(hooks, ((field, context, request) => this.#runHook(field, context, request, base)));
-		return hooks;
-	}
-	/**
-	* Прогоняет запрос через цепочку обёрток.
-	*
-	* Снимок цепочки берётся в начале: `unuse()` влияет на новые запросы, но не обрывает
-	* уже выполняющийся посередине.
-	*
-	* @param execute настоящий запрос, вызывается самой внутренней обёрткой
-	*/
-	async run(request, execute) {
-		const entries = [...this.#ordered];
-		for (const entry of entries) entry.activeRequests += 1;
-		const hookScope = entries.flatMap((entry) => entry.hooks);
-		const scoped = (current) => current[PLUGIN_HOOK_SCOPE] === hookScope ? current : {
-			...current,
-			[PLUGIN_HOOK_SCOPE]: hookScope
-		};
-		const chain = entries.flatMap((entry) => entry.transformers).reduceRight((next, transformer) => (current) => transformer(scoped(current), (prepared) => next(scoped(prepared))), (current) => execute(scoped(current)));
-		try {
-			return await chain(scoped(request));
-		} finally {
-			for (const entry of entries) {
-				entry.activeRequests -= 1;
-				if (entry.activeRequests === 0) {
-					entry.finishDrain?.();
-					entry.finishDrain = void 0;
-					entry.drain = void 0;
-				}
-			}
-		}
-	}
-	#rebuildOptionKeys() {
-		this.#optionKeys.clear();
-		for (const { plugin } of this.#ordered) for (const key of plugin.optionKeys ?? []) this.#optionKeys.add(key);
-	}
-	#waitForDrain(entry) {
-		if (entry.activeRequests === 0) return Promise.resolve();
-		entry.drain ??= new Promise((resolve) => {
-			entry.finishDrain = resolve;
-		});
-		return entry.drain;
-	}
-	#trackCleanup(cleanup) {
-		this.#cleanups.add(cleanup);
-		cleanup.then(() => this.#cleanups.delete(cleanup), () => this.#cleanups.delete(cleanup));
-		return cleanup;
-	}
-	async #runHook(field, context, request, base) {
-		const baseHook = base[field];
-		await baseHook?.(context);
-		const scope = request[PLUGIN_HOOK_SCOPE] ?? [];
-		for (const hooks of scope) {
-			const hook = hooks[field];
-			await hook?.(context);
-		}
-	}
-};
-//#endregion
-//#region src/core/retry.ts
-/**
-* Методы, повтор которых безопасен по определению.
-*
-* `DELETE` формально тоже идемпотентен, но его повтор после успеха вернёт `404`
-* и собьёт с толку — в список он не входит.
-*/
-const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-/**
-* Стоит ли повторять запрос после этой ошибки.
-*
-* Отдельно разобран `429`: он повторяется даже для запросов на запись, потому что
-* гарантирует, что запрос **не был обработан**. Обрыв сети и `5xx` такой гарантии не дают —
-* сервер мог успеть создать пост, — поэтому запись по умолчанию не повторяется.
-*/
-function isRetryable(error, method, retryWrites, retryNetworkWrite) {
-	if (error instanceof require_storage.ItdAbortError) return false;
-	const safeToRepeat = retryWrites || IDEMPOTENT_METHODS.has(method);
-	if (error instanceof require_storage.ItdApiError) {
-		if (error.status === 429) return true;
-		if (error.status >= 500) return safeToRepeat;
-		return false;
-	}
-	if (error instanceof require_storage.ItdNetworkError || error instanceof require_storage.ItdTimeoutError) return safeToRepeat || retryNetworkWrite;
-	if (error instanceof require_storage.ItdFileError) return error.retryable && (safeToRepeat || retryNetworkWrite);
-	return false;
-}
-/** Экспоненциальная пауза со случайным разбросом. */
-function backoffDelay(attempt, options, random) {
-	const exponential = options.baseDelay * 2 ** (attempt - 1);
-	const capped = Math.min(exponential, options.maxDelay);
-	const spread = capped * options.jitter * (random() * 2 - 1);
-	return Math.max(0, Math.round(capped + spread));
-}
-/**
-* Собирает планировщик повторов для транспорта.
-*
-* Поведение при `Retry-After`: пауза, названная сервером, соблюдается точно — она
-* авторитетнее нашего расчёта. Но если сервер просит ждать дольше, чем `maxDelay`,
-* повтор **не выполняется вовсе**: молча спать десять минут внутри вызова библиотека
-* не должна, лучше отдать {@link ItdRateLimitError} и дать решить вызывающему коду.
-*
-* @param options настройки повторов после подстановки значений по умолчанию
-* @param random источник случайности; подменяется в тестах ради предсказуемости
-*
-* @example
-* ```ts
-* const scheduler = createRetryScheduler(config.retry);
-* const delay = scheduler(error, 1, 'GET'); // 500 мс ± 30%
-* ```
-*/
-function createRetryScheduler(options, random = Math.random) {
-	return (error, attempt, method, retryNetworkWrite = false) => {
-		if (attempt >= options.attempts) return void 0;
-		if (options.shouldRetry) return options.shouldRetry(error, attempt) ? backoffDelay(attempt, options, random) : void 0;
-		if (!isRetryable(error, method, options.retryWrites, retryNetworkWrite)) return void 0;
-		if (error instanceof require_storage.ItdApiError && error.retryAfter !== void 0) return error.retryAfter > options.maxDelay ? void 0 : error.retryAfter;
-		return backoffDelay(attempt, options, random);
-	};
-}
-//#endregion
-//#region src/core/middleware.ts
-/** Ожидание повтора, которое уважает отмену запроса. */
-function sleep(clock, ms, signal) {
-	if (!signal) return new Promise((resolve) => clock.schedule(resolve, ms));
-	if (signal.aborted) return Promise.reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
-	return new Promise((resolve, reject) => {
-		const cancel = clock.schedule(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			cancel();
-			reject(new require_storage.ItdAbortError("Запрос отменён во время ожидания повтора"));
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
-/**
-* Слой очереди: ограничение конкурентности и частоты.
-*
-* `skipQueue` пропускает запрос мимо очереди — так поступают служебные запросы, которые
-* порождены изнутри другого запроса и не могут ждать освободившегося слота.
-*
-* Очередь выбирается по запросу: у каждого сервиса платформы свой хост и свой лимит.
-*/
-function createQueueMiddleware(schedule) {
-	return (request, next) => request.skipQueue ? next(request) : schedule(request, () => next(request));
-}
-/**
-* Слой плагинов.
-*
-* Стоит снаружи повторов и внутри очереди: плагин должен увидеть запрос и ответ по одному
-* разу, независимо от числа попыток, — иначе, например, текст поста зашифруется дважды.
-*/
-function createPluginsMiddleware(plugins) {
-	return (request, next) => plugins.run(request, next);
-}
-/**
-* Слой сервисов.
-*
-* Запросу с полем `service` подставляет хост сервиса, его заголовки и `skipAuth`, если
-* сервис объявлен публичным. Заданный у запроса `baseUrl` не трогает.
-*
-* Стоит снаружи повторов и авторизации, чтобы выставленный здесь `skipAuth` был ей виден.
-*/
-function createServicesMiddleware(registry) {
-	return async (request, next) => {
-		const service = request.service === void 0 ? void 0 : registry.require(request.service);
-		let prepared = request;
-		if (request.baseUrl !== void 0) {
-			const baseUrl = normalizeBaseUrl(request.baseUrl);
-			if (baseUrl !== request.baseUrl) prepared = {
-				...prepared,
-				baseUrl
-			};
-			if (!(service?.baseUrl === baseUrl ? service.auth !== false : registry.isPrimarySite(baseUrl)) && prepared.skipAuth === void 0) prepared = {
-				...prepared,
-				skipAuth: true
-			};
-		}
-		if (!service) return next(prepared);
-		if (prepared.baseUrl === void 0) prepared = {
-			...prepared,
-			baseUrl: service.baseUrl
-		};
-		if (service.headers) prepared = withLayerHeaders(prepared, service.headers);
-		if (service.auth === false && prepared.skipAuth === void 0) prepared = {
-			...prepared,
-			skipAuth: true
-		};
-		return next(prepared);
-	};
-}
-async function applyAuth(request, deps) {
-	if (request.skipAuth) return request;
-	const headers = await deps.getAuthHeaders();
-	return Object.keys(headers).length > 0 ? withLayerHeaders(request, headers) : request;
-}
-/**
-* Слой авторизации.
-*
-* Подставляет заголовок `Authorization` и обрабатывает `401`: обновляет токен и повторяет
-* запрос ровно один раз. Стоит внутри повторов, поэтому обычным попыткам он не виден —
-* они уже работают со свежим токеном.
-*/
-function createAuthMiddleware(deps) {
-	return async (request, next) => {
-		const authorized = await applyAuth(request, deps);
+	*/
+	hooks(base) {
+		return createRequestHooks((field, context, request) => this.#runHook(field, context, request, base));
+	}
+	/**
+	* Прогоняет запрос через цепочку обёрток.
+	*
+	* Снимок цепочки берётся в начале: `unuse()` влияет на новые запросы, но не обрывает
+	* уже выполняющийся посередине.
+	*
+	* @param execute настоящий запрос, вызывается самой внутренней обёрткой
+	*/
+	async run(request, execute) {
+		const entries = [...this.#ordered];
+		for (const entry of entries) entry.activeRequests += 1;
+		const hookScope = entries.flatMap((entry) => entry.hooks);
+		const scoped = (current) => withRequestHookScope(current, hookScope);
+		const chain = entries.flatMap((entry) => entry.transformers).reduceRight((next, transformer) => (current) => transformer(scoped(current), (prepared) => next(scoped(prepared))), (current) => execute(scoped(current)));
 		try {
-			return await next(authorized);
-		} catch (error) {
-			if (request.skipAuthRefresh || !deps.autoRefresh || !require_storage.isItdApiError(error) || error.status !== 401) throw error;
-			if (!await deps.onUnauthorized()) throw error;
-			return next(await applyAuth({
-				...request,
-				skipAuthRefresh: true
-			}, deps));
-		}
-	};
-}
-/**
-* Выбирает планировщик отката для конкретного запроса.
-*
-* `retry` у запроса переопределяет глобальную настройку: `false` выключает повторы,
-* объект задаёт свои. Обработка `429` от этого не зависит — она общая.
-*/
-function resolveBackoff(retry, global) {
-	if (retry === void 0) return global;
-	if (retry === false) return void 0;
-	const resolved = resolveRetry(retry);
-	return resolved ? createRetryScheduler(resolved) : void 0;
-}
-/**
-* Слой повторов.
-*
-* Ответ `429` обрабатывается отдельно от прочих ошибок лестницей пауз и с придержанием
-* всей очереди; сетевые сбои и `5xx` — экспоненциальным откатом. Настройка `retry`
-* у отдельного запроса имеет приоритет над глобальной.
-*/
-function createRetryMiddleware(deps) {
-	const globalScheduler = deps.retry ? createRetryScheduler(deps.retry) : void 0;
-	const nextDelay = (error, attempt, request, method, backoff) => {
-		if (require_storage.isItdRateLimitError(error)) {
-			const wait = error.retryAfter ?? deps.rateLimitDelays[attempt - 1];
-			if (wait === void 0) return void 0;
-			deps.pauseQueue?.(wait, request);
-			deps.logger?.debug(`лимит частоты, попытка ${attempt + 1} через ${wait} мс`);
-			return wait;
+			return await chain(scoped(request));
+		} finally {
+			for (const entry of entries) {
+				entry.activeRequests -= 1;
+				if (entry.activeRequests === 0) {
+					entry.finishDrain?.();
+					entry.finishDrain = void 0;
+					entry.drain = void 0;
+				}
+			}
 		}
-		return backoff?.(error, attempt, method, request.retryNetworkWrite ?? false);
-	};
-	return async (request, next) => {
-		const method = request.method.toUpperCase();
-		const backoff = resolveBackoff(request.retry, globalScheduler);
-		for (let attempt = 1;; attempt++) try {
-			return await next({
-				...request,
-				attempt
-			});
-		} catch (error) {
-			const delay = nextDelay(error, attempt, request, method, backoff);
-			if (delay === void 0) throw error;
-			await dispatchRequestHook(deps.hooks, "onRetry", {
-				method,
-				path: request.path,
-				url: deps.buildUrl(request),
-				headers: new Headers({
-					...request.layerHeaders,
-					...request.headers
-				}),
-				attempt,
-				error,
-				delay
-			}, request);
-			deps.logger?.debug(`повтор ${method} ${request.path}, попытка ${attempt + 1} через ${delay} мс`);
-			await sleep(deps.clock ?? systemClock, delay, request.signal);
+	}
+	#rebuildOptionKeys() {
+		this.#optionKeys.clear();
+		for (const { plugin } of this.#ordered) for (const key of plugin.optionKeys ?? []) this.#optionKeys.add(key);
+	}
+	#waitForDrain(entry) {
+		if (entry.activeRequests === 0) return Promise.resolve();
+		entry.drain ??= new Promise((resolve) => {
+			entry.finishDrain = resolve;
+		});
+		return entry.drain;
+	}
+	#trackCleanup(cleanup) {
+		this.#cleanups.add(cleanup);
+		cleanup.then(() => this.#cleanups.delete(cleanup), () => this.#cleanups.delete(cleanup));
+		return cleanup;
+	}
+	async #runHook(field, context, request, base) {
+		const baseHook = base[field];
+		await baseHook?.(context);
+		for (const hooks of requestHookScope(request)) {
+			const hook = hooks[field];
+			await hook?.(context);
 		}
-	};
-}
+	}
+};
 //#endregion
 //#region src/core/rate-limit.ts
 /** Ошибка отмены запроса, который ещё не дошёл до транспорта. */
@@ -4925,6 +4935,140 @@ var CommentsResource = class extends BaseResource {
 	}
 };
 //#endregion
+//#region src/core/attachments/url-source.ts
+/** Убирает параметры MIME и приводит его к форме для сравнения. */
+function normalizeMimeType(contentType) {
+	return contentType?.split(";", 1)[0]?.trim().toLowerCase() || void 0;
+}
+/** Достаёт имя файла из пути URL. */
+function filenameFromUrl(url) {
+	const last = url.pathname.split("/").pop();
+	if (!last) return void 0;
+	try {
+		return decodeURIComponent(last) || void 0;
+	} catch {
+		return last;
+	}
+}
+/** Проверяет объявленный размер и возвращает его, если заголовок корректен. */
+function declaredSize(response, maxBytes, url) {
+	const header = response.headers.get("content-length");
+	if (header === null) return void 0;
+	const size = Number(header);
+	if (!Number.isFinite(size) || size < 0 || !Number.isInteger(size)) return void 0;
+	if (maxBytes !== void 0 && size > maxBytes) throw require_multi_storage.fileTooLarge(url, maxBytes, size);
+	return size;
+}
+/** Получает HTTP-ответ источника и проверяет его статус. */
+async function fetchFile(target, options, context) {
+	let requested;
+	try {
+		requested = new URL(target);
+	} catch {
+		throw new require_storage.ItdConfigError(`«${target}» не разбирается как адрес`);
+	}
+	if (requested.protocol !== "http:" && requested.protocol !== "https:") throw new require_storage.ItdConfigError(`вложение по адресу поддерживает только http и https, получено: ${requested.protocol}`);
+	let response;
+	try {
+		response = await context.fetch(requested, { ...context.signal ? { signal: context.signal } : {} });
+	} catch (error) {
+		if (context.signal?.aborted || error instanceof Error && error.name === "AbortError") throw error;
+		throw new require_storage.ItdFileError(`не удалось получить файл по адресу ${requested.href}`, {
+			reason: require_storage.ItdFileErrorReason.Network,
+			url: requested.href,
+			retryable: true,
+			cause: error
+		});
+	}
+	const finalUrl = response.url ? new URL(response.url) : requested;
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => {});
+		throw new require_storage.ItdFileError(`источник ${finalUrl.href} ответил статусом ${response.status}`, {
+			reason: require_storage.ItdFileErrorReason.Http,
+			url: finalUrl.href,
+			status: response.status,
+			retryable: response.status === 408 || response.status === 429 || response.status >= 500
+		});
+	}
+	const { maxBytes } = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	let size;
+	try {
+		size = declaredSize(response, maxBytes, finalUrl.href);
+	} catch (error) {
+		await response.body?.cancel().catch(() => {});
+		throw error;
+	}
+	return {
+		response,
+		url: finalUrl,
+		size
+	};
+}
+/** Читает ответ с контролем размера до создания итогового `Blob`. */
+async function responseBlob(response, url, maxBytes, streamBufferBytes, signal) {
+	if (!response.body) {
+		const blob = await response.blob();
+		if (maxBytes !== void 0 && blob.size > maxBytes) throw require_multi_storage.fileTooLarge(url, maxBytes, blob.size);
+		return blob;
+	}
+	const chunks = [];
+	const reader = require_multi_storage.boundedFileStream(response.body, {
+		...maxBytes !== void 0 ? { maxBytes } : {},
+		streamBufferBytes,
+		...signal ? { signal } : {},
+		url,
+		retryableRead: true
+	}).getReader();
+	try {
+		for (;;) {
+			const next = await reader.read();
+			if (next.done) break;
+			chunks.push(next.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return new Blob(chunks.map((chunk) => Uint8Array.from(chunk).buffer));
+}
+/** Скачивает файл целиком с ограничением размера. @internal */
+async function downloadFile(target, options, context) {
+	const resolved = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url } = await fetchFile(target, options, context);
+	const blob = await responseBlob(response, url.href, resolved.maxBytes, resolved.streamBufferBytes, context.signal);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	const filename = options.filename ?? filenameFromUrl(url);
+	return {
+		file: new Blob([blob], { type: contentType ?? "" }),
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {}
+	};
+}
+/** Открывает HTTP-ответ как ограниченный поток. @internal */
+async function openUrlFile(target, options, context) {
+	const resolved = require_multi_storage.resolveFileStreamOptions(options, require_multi_storage.DEFAULT_URL_FILE_MAX_BYTES);
+	const { response, url, size } = await fetchFile(target, options, context);
+	if (!response.body) throw new require_storage.ItdFileError(`источник ${url.href} не предоставил потоковое тело`, {
+		reason: require_storage.ItdFileErrorReason.StreamUnavailable,
+		url: url.href
+	});
+	const stream = require_multi_storage.boundedFileStream(response.body, {
+		...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+		streamBufferBytes: resolved.streamBufferBytes,
+		...context.signal ? { signal: context.signal } : {},
+		url: url.href,
+		retryableRead: true
+	});
+	const filename = options.filename ?? filenameFromUrl(url);
+	const contentType = normalizeMimeType(options.contentType ?? response.headers.get("content-type") ?? void 0);
+	return {
+		stream,
+		...filename ? { filename } : {},
+		...contentType ? { contentType } : {},
+		...size !== void 0 ? { size } : {},
+		close: () => stream.cancel().catch(() => {})
+	};
+}
+//#endregion
 //#region src/core/mime.ts
 /** Изображения, которые принимает `POST /api/files/upload`. */
 const IMAGE_MIME_TYPES = Object.freeze([
@@ -5173,7 +5317,7 @@ var FilesResource = class extends BaseResource {
 	async #prepareBuffer(input, options, context) {
 		const content = await this.#resolveBuffer(input, context);
 		const filename = options.filename ?? content.filename ?? this.#nameFromMime(options.contentType ?? content.contentType);
-		const contentType = require_multi_storage.normalizeMimeType(options.contentType ?? content.contentType) ?? require_multi_storage.normalizeMimeType(require_runtime.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType) ?? normalizeMimeType(require_runtime.isBlob(content.file) ? content.file.type : void 0) ?? mimeFromFilename(filename);
 		if (options.validateMime !== false) assertAllowedMime(contentType, filename);
 		const blob = require_runtime.isBlob(content.file) && (!contentType || content.file.type === contentType) ? content.file : new Blob([content.file], { type: contentType ?? "" });
 		const limits = require_multi_storage.resolveFileStreamOptions(options);
@@ -5194,7 +5338,7 @@ var FilesResource = class extends BaseResource {
 		if (typeof input === "object" && input !== null && "open" in input) opened = await input.open(context);
 		else if (typeof input === "object" && input !== null && "url" in input) {
 			const { url, ...urlOptions } = input;
-			opened = await require_multi_storage.openUrlFile(url, urlOptions, context);
+			opened = await openUrlFile(url, urlOptions, context);
 		} else throw new require_storage.ItdConfigError("потоковое вложение должно иметь форму { open } или { url, mode }");
 		if (!opened || typeof ReadableStream === "undefined" || !(opened.stream instanceof ReadableStream)) {
 			await opened?.close?.();
@@ -5202,7 +5346,7 @@ var FilesResource = class extends BaseResource {
 		}
 		try {
 			const filename = options.filename ?? opened.filename ?? this.#nameFromMime(options.contentType ?? opened.contentType);
-			const contentType = require_multi_storage.normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
+			const contentType = normalizeMimeType(options.contentType ?? opened.contentType) ?? mimeFromFilename(filename);
 			if (options.validateMime !== false) assertAllowedMime(contentType, filename);
 			const limits = require_multi_storage.resolveFileStreamOptions({
 				mode: require_multi_storage.FileTransferMode.Stream,
@@ -5240,7 +5384,7 @@ var FilesResource = class extends BaseResource {
 		if ("load" in input) return input.load(context);
 		if ("url" in input) {
 			const { url, ...urlOptions } = input;
-			return require_multi_storage.downloadFile(url, urlOptions, context);
+			return downloadFile(url, urlOptions, context);
 		}
 		if ("file" in input) return input;
 		if ("open" in input) throw new require_storage.ItdConfigError("потоковый источник нельзя использовать как буферный");
@@ -5248,7 +5392,7 @@ var FilesResource = class extends BaseResource {
 	}
 	/** Подбирает непустое имя, обязательное для multipart. */
 	#nameFromMime(contentType) {
-		const extension = require_multi_storage.normalizeMimeType(contentType)?.split("/")[1];
+		const extension = normalizeMimeType(contentType)?.split("/")[1];
 		return extension ? `file.${extension}` : "file";
 	}
 };
@@ -5470,7 +5614,6 @@ var NotificationsResource = class extends BaseResource {
 };
 //#endregion
 //#region src/core/time.ts
-/** Отметка времени без часового пояса: `2026-07-23 23:14:25`, возможно с долями секунды. */
 const NAIVE_STAMP = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
 /**
 * Приводит отметку времени без часового пояса к ISO-8601, считая её временем UTC.
@@ -5489,6 +5632,21 @@ function utcStampToIso(value) {
 	const iso = `${match[1]}T${match[2]}Z`;
 	return Number.isFinite(Date.parse(iso)) ? iso : value;
 }
+/**
+* Разбирает дату API в объект `Date`.
+*
+* @returns `null`, если строки нет или она не разбирается
+*
+* @example
+* ```ts
+* const created = toDate(post.createdAt);
+* ```
+*/
+function toDate(value) {
+	if (!value) return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date : null;
+}
 //#endregion
 //#region src/resources/platform.ts
 /** Приводит `last_checked` каждого сервиса к ISO. Остальное остаётся как прислал сервер. */
@@ -6419,7 +6577,7 @@ function resolvePoll(input) {
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const BUILD_UPDATE = Symbol.for("itd.postBuilder.update");
 /**
-* Проверяет данные поста.
+* Проверяет и нормализует данные поста.
 *
 * Отдельного внимания заслуживает `wallRecipientId`: API принимает там **только UUID**,
 * а имя пользователя молча приводит к ошибке на сервере. Проверка здесь превращает
@@ -6439,10 +6597,11 @@ function validatePost(input) {
 	if (wallRecipientId !== void 0 && wallRecipientId !== null) {
 		if (!UUID_PATTERN.test(wallRecipientId)) throw new require_storage.ItdConfigError(`wallRecipientId должен быть UUID, а не именем пользователя (получено: «${wallRecipientId}»). Идентификатор можно взять из профиля: (await itd.users.get(username)).id`);
 	}
+	const { poll: inputPoll, ...data } = input;
 	return {
-		...input,
+		...data,
 		...input.spans !== void 0 ? { spans: validateSpans(content, input.spans) } : {},
-		...input.poll !== void 0 ? { poll: resolvePoll(input.poll) } : {}
+		...inputPoll !== void 0 ? { poll: resolvePoll(inputPoll) } : {}
 	};
 }
 /**
@@ -6639,7 +6798,8 @@ function post(content) {
 }
 /** Приводит любую форму входа к готовым данным поста. */
 function resolvePost(input) {
-	return resolveInput(input, () => post(), validatePost);
+	const resolved = typeof input === "function" ? input(post()) : input;
+	return isBuilder(resolved) ? validatePost(resolved.build()) : validatePost(resolved);
 }
 function validatePostUpdate(input) {
 	if (!input || typeof input !== "object") throw new require_storage.ItdConfigError("Для обновления поста нужен объект с явно заданным content");
@@ -8651,6 +8811,92 @@ function createAccounts(options = {}) {
 	return new ItdAccounts(options);
 }
 //#endregion
+//#region src/core/attachments/factories.ts
+function fromUrl(url, options = {}) {
+	if (require_multi_storage.resolveFileStreamOptions(options, 104857600).mode === require_multi_storage.FileTransferMode.Stream) return { open: (context) => openUrlFile(url, options, context) };
+	return { load: (context) => downloadFile(url, options, context) };
+}
+/**
+* Создаёт повторяемый пользовательский поток.
+*
+* Фабрика вызывается заново для каждой попытки; возвращать один и тот же поток нельзя.
+*/
+function fromStream(factory, options = {}) {
+	const resolved = require_multi_storage.resolveFileStreamOptions({
+		...options,
+		mode: require_multi_storage.FileTransferMode.Stream
+	}, void 0);
+	require_multi_storage.optionalBytes(options.size, "size");
+	return { open: async (context) => {
+		let opened;
+		try {
+			opened = await factory(context);
+		} catch (error) {
+			if (error instanceof require_storage.ItdFileError || error instanceof require_storage.ItdConfigError || context.signal?.aborted) throw error;
+			throw new require_storage.ItdFileError("не удалось открыть поток вложения", {
+				reason: require_storage.ItdFileErrorReason.Read,
+				retryable: true,
+				cause: error
+			});
+		}
+		const content = require_multi_storage.isReadableByteStream(opened) ? { stream: opened } : opened;
+		if (!content || !require_multi_storage.isReadableByteStream(content.stream)) throw new require_storage.ItdConfigError("fromStream должен вернуть ReadableStream или { stream }");
+		const size = options.size ?? content.size;
+		require_multi_storage.optionalBytes(size, "size");
+		if (resolved.maxBytes !== void 0 && size !== void 0 && size > resolved.maxBytes) {
+			await content.close?.();
+			throw require_multi_storage.fileTooLarge(void 0, resolved.maxBytes, size);
+		}
+		const contentType = normalizeMimeType(options.contentType ?? content.contentType);
+		return {
+			stream: require_multi_storage.boundedFileStream(content.stream, {
+				...resolved.maxBytes !== void 0 ? { maxBytes: resolved.maxBytes } : {},
+				streamBufferBytes: resolved.streamBufferBytes,
+				...context.signal ? { signal: context.signal } : {},
+				retryableRead: true
+			}),
+			...options.filename ?? content.filename ? { filename: options.filename ?? content.filename } : {},
+			...contentType ? { contentType } : {},
+			...size !== void 0 ? { size } : {},
+			...content.close ? { close: content.close } : {}
+		};
+	} };
+}
+//#endregion
+//#region src/models/guards.ts
+/**
+* Свой ли это профиль.
+*
+* @example
+* ```ts
+* if (isMyProfile(profile)) console.log(profile.subscription.isActive);
+* ```
+*/
+function isMyProfile(profile) {
+	return "subscription" in profile;
+}
+//#endregion
+//#region src/models/status-helpers.ts
+const STATUS_WINDOW_DAYS = 90;
+/**
+* Разворачивает историю сервиса в массив на 90 суток.
+* Сутки без данных становятся `null`.
+*
+* @returns массив, где индекс — сколько суток назад: `[0]` — сегодня
+*
+* @example
+* ```ts
+* const status = await itd.platform.status();
+* const days = statusDays(status.services[0]);
+*
+* days[0]?.uptime;                              // доступность за сегодня
+* days.filter((day) => day === null).length;    // за сколько суток данных нет
+* ```
+*/
+function statusDays(service) {
+	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
+}
+//#endregion
 //#region src/notifications/text.ts
 /** Имя, которое подставляется, если участник неизвестен. */
 const UNKNOWN_ACTOR = "Пользователь";
@@ -9067,54 +9313,6 @@ function renderSpans(content, spans = [], options = {}) {
 	return result;
 }
 //#endregion
-//#region src/types/models.ts
-/**
-* Свой ли это профиль.
-*
-* @example
-* ```ts
-* if (isMyProfile(profile)) console.log(profile.subscription.isActive);
-* ```
-*/
-function isMyProfile(profile) {
-	return "subscription" in profile;
-}
-/** Глубина истории статуса в сутках. Столько элементов отдаёт {@link statusDays}. */
-const STATUS_WINDOW_DAYS = 90;
-/**
-* Разбирает дату API в объект `Date`.
-*
-* @returns `null`, если строки нет или она не разбирается
-*
-* @example
-* ```ts
-* const created = toDate(post.createdAt);
-* ```
-*/
-function toDate(value) {
-	if (!value) return null;
-	const date = new Date(value);
-	return Number.isFinite(date.getTime()) ? date : null;
-}
-/**
-* Разворачивает историю сервиса в массив на 90 суток.
-* Сутки без данных становятся `null`.
-*
-* @returns массив, где индекс — сколько суток назад: `[0]` — сегодня
-*
-* @example
-* ```ts
-* const status = await itd.platform.status();
-* const days = statusDays(status.services[0]);
-*
-* days[0]?.uptime;                              // доступность за сегодня
-* days.filter((day) => day === null).length;    // за сколько суток данных нет
-* ```
-*/
-function statusDays(service) {
-	return Array.from({ length: STATUS_WINDOW_DAYS }, (_, index) => service.days[String(index)] ?? null);
-}
-//#endregion
 exports.ALLOWED_MIME_TYPES = ALLOWED_MIME_TYPES;
 exports.AUDIO_MIME_TYPES = AUDIO_MIME_TYPES;
 exports.AUTH_FLAG_COOKIE = require_multi_storage.AUTH_FLAG_COOKIE;
@@ -9203,8 +9401,8 @@ exports.createMultiTokenStorage = require_multi_storage.createMultiTokenStorage;
 exports.createRecordMultiStorage = require_multi_storage.createRecordMultiStorage;
 exports.createTokenStorage = require_storage.createTokenStorage;
 exports.formatNotificationText = formatNotificationText;
-exports.fromStream = require_multi_storage.fromStream;
-exports.fromUrl = require_multi_storage.fromUrl;
+exports.fromStream = fromStream;
+exports.fromUrl = fromUrl;
 exports.isBuilder = isBuilder;
 exports.isItdApiError = require_storage.isItdApiError;
 exports.isItdAuthError = require_storage.isItdAuthError;